C#

using System;
using System.Collections.Generic;
using System.Linq;
using System.Data;

class Program
{
   static void Main(string[] args)
   {
      List<string> list = new List<string>
      {
         @"\base",
         @"\base\001",
         @"\base\001\cfg",
         @"\base\001\cfg\network", // <-- intruder
         @"\base\001\cfg\network\mgmnt", // terminating leaf
         @"\base\001\cfg\network\users", // terminating leaf
         @"\base\002",
         @"\base\002\copy",
         @"\base\002\copy\cfg",
         @"\base\002\copy\cfg\network", // <-- intruder
         @"\base\002\copy\cfg\network\mgmnt", // terminating leaf
         @"\base\002\copy\cfg\network\users", // terminating leaf
      };

      Tree tree = new Tree(list[0]);
      foreach (string item in list)
      {
         tree.Add(item);
      }

      var nodes_to_delete_iter = tree.Root.Descendants().Where(d => d.Children.Count == 0);
      var nodes_to_delete_list = nodes_to_delete_iter.ToList();

      int start_count = nodes_to_delete_iter.Count(); // <---- 4 Nodes selected here.   See "terminating leaf" in the folder list

      for (int index = nodes_to_delete_list.Count - 1; index > -1; index--)
      {
         Node leaf = nodes_to_delete_list[index];
         Console.WriteLine("Removing " + leaf.Path);
         nodes_to_delete_list.Remove(leaf);
         tree.Remove(leaf);
      }

      int final_count = nodes_to_delete_iter.Count(); // <---- At this point there are 2 nodes.  "See "intruder" in the folder list

      Console.ReadKey();
   }
}

public class Tree
{
   public Node Root { get; private set; }

   public Tree(string root_path)
   {
      Root = new Node(root_path);
   }

   public Node FindParent(string node_path)
   {
      int index = node_path.LastIndexOf("\\");
      string parent_path = node_path.Substring(0, index);
      Node parent_node = Root.Descendants().FirstOrDefault(n => n.Path == parent_path);
      return parent_node;
   }

   public Node Add(string node_path)
   {
      Node parent_node = FindParent(node_path);
      Node node = new Node(node_path);
      if (parent_node != null) { parent_node.Children.Add(node);  }
      return node;
   }

   public void Remove(Node node)
   {
      Node parent_node = FindParent(node.Path);
      parent_node.Children.Remove(node);
      node = null;
   }
}

public class Node
{
   public string Path { get; private set; }
   public List<Node> Children { get; private set; }

   public Node(string value)
   {
      Children = new List<Node>();
      Path = value;
   }

   public IEnumerable<Node> Descendants()
   {
      return new[] { this }.Concat(Children.SelectMany(child => child.Descendants()));
   }

   public override string ToString() // For Viewing in VS Debugger
   {
      return Path;
   }
}

public async Task<APIResponse<T>> ExecuteAsync<T>()
{
    var task = await Task.Run(() =>
    {
        var apiResponse = new APIResponse<T>
        {
            Success = true
        };

        IRestResponse<T> response = client.Execute<T>(request);

        if (response.StatusCode == HttpStatusCode.OK)
        {
            apiResponse.Result = response.Data;
            return apiResponse.Result;
        }
        else
        {
            apiResponse.Success = false;
            LogError(new Uri(baseURL), request, response);
            return default(T);
        }
    });

    return task;
}

public class APIResponse<T> : EventArgs
{
    public APIResponse()
    {
        Messages = new List<ReponseMessage>();
    }

    public List<ReponseMessage> Messages { get; set; }

    public T Result { get; set; }

    public bool Success { get; set; }
}

public class ReponseMessage
{
    public string Message { get; set; }

    public Exception Exception { get; set; }
}

public APIResponse<Disclaimer> GetDisclaimer(int id)
{
    APIExecutor webAPIExecutor = new APIExecutor("Disclaimer/GetDisclaimer");

    Task<APIResponse<Disclaimer>> results = webAPIExecutor.ExecuteAsync<Disclaimer>();

    return results.Result;
}

Hello
I am planning to make an app which could be used between defined times and if the time is not between the defined time then the app would give a warning and close the app.
Originally thinking about making a parental control app for parents and their kids so the parents can tell when it is enough.

I am using C# to make everything possible and I am using a database (MYSQL) to get the details.
The following are my questions:
Which way I should save in the database for different parents the timezone?
How I make the app to use that timezone which the parents defined?
If the parent will change the timezone while the app working and the time when the app can work then how the app will recognize that the data changed in the database?

I am newbie and I would be thankful for example or open source and some explanation if it is possible.
Thank you in advance all of the answers.

public class MixedCompressionStreamRewriter : FileStream

public static RecordHeaderBase FromFile(BinaryReader reader, uint internalIDMask = 0xFFFFFFFF)
{
	ModRecordConsolidator consolidator = reader.BaseStream as ModRecordConsolidator;
	if (consolidator != null)
		consolidator.EnableParseMode = true;
	RecordTypeInfo typeInfo = (RecordType)reader.ReadUInt32();
	if (consolidator != null)
		consolidator.EnableParseMode = false;
	if (typeInfo == RecordType.TES4)
		return new GameHeader(reader);
	else if (typeInfo.isContainer)
		return new GroupHeader(reader, typeInfo, internalIDMask);
	else
		return new RecordHeader(reader, typeInfo, internalIDMask);
}

public override int Read(byte[] array, int offset, int count)
{
	int result;
	if (compressionHeaderStream == null) // condition is true when problem occurs
	{
		result = base.Read(array, offset, count); // ***THIS IS WHERE THE ISSUES IS ***//
		if (!parseMode)
		{
			long equivalentBufferLocation = MemoryBufferStart + MemoryBuffer.Length;
			if (Position > equivalentBufferLocation)
			{
				long bufferCopyBytes = Position - equivalentBufferLocation;
				if (bufferCopyBytes > int.MaxValue)
					throw new OverflowException();
				offset += (count - (int)bufferCopyBytes);
				MemoryBuffer.Write(array, offset, (int)bufferCopyBytes);
			}
			if (MaxBufferSize != 0)
				if (MemoryBuffer.Length >= MaxBufferSize)
					FlushToOutput();
		}
	}
	else if (MemoryBuffer == null)
		result = base.Read(array, offset, count);
	else
		result = MemoryBuffer.Read(array, offset, count);
	return result;
}

public override bool CanRead { get { return true; } }
public override bool CanSeek { get { return true; } }