public Recurser(string sourceDirectory, string directoryFilter, string fileFilter, FileEnumeratingBasicFileController controller)
            {
                _SourceDirectory = sourceDirectory;
                _DirectoryFilter = directoryFilter;
                _FileFilter      = fileFilter;
                _Controller      = controller;

                ExecutionInterval = TimeSpan.FromSeconds(10);
                _PollerPool.BeginAsync(this);
            }
            public void Dispose(FileEnumeratingBasicFileController controller)
            {
                lock (Pollers)
                {
                    if (_References.Contains(controller))
                    {
                        _References.Remove(controller);
                    }

                    if (_References.Count == 0)
                    {
                        Dispose();

                        if (Pollers.Contains(this))
                        {
                            Pollers.Remove(this);
                        }
                    }
                }
            }
            protected override void Execute(ThreadPool owner)
            {
                try
                {
                    Regex inc = STEM.Sys.IO.Path.BuildInclusiveFilter(FileFilter);
                    Regex exc = STEM.Sys.IO.Path.BuildExclusiveFilter(FileFilter);

                    FileEnumeratingBasicFileController any = _References.FirstOrDefault();

                    if (any == null)
                    {
                        return;
                    }

                    foreach (FileInfo f in EnumerateFiles(SourceDirectory, "*.*"))
                    {
                        if (inc == null || STEM.Sys.IO.Path.StringMatches(f.FileName, inc))
                        {
                            if (exc == null || !STEM.Sys.IO.Path.StringMatches(f.FileName, exc))
                            {
                                if (any.CoordinatedKeyManager.Locked(f.FileName))
                                {
                                    continue;
                                }

                                if (any.CoordinatedKeyManager.CoordinatedMachineHasLock(f.FileName, any.CoordinateWith) == Sys.State.CoordinatedKeyManager.RemoteLockExists.False)
                                {
                                    lock (_ObjectLock)
                                        Files[f.FileName] = f.FileSize;
                                }
                            }
                        }
                    }
                }
                catch
                {
                }
            }
            public static Poller GetPoller(string sourceDirectory, string fileFilter, FileEnumeratingBasicFileController controller)
            {
                lock (Pollers)
                {
                    Poller p = Pollers.FirstOrDefault(i => i.SourceDirectory.Equals(sourceDirectory, StringComparison.InvariantCultureIgnoreCase) && i.FileFilter.Equals(fileFilter, StringComparison.InvariantCultureIgnoreCase));

                    if (p == null)
                    {
                        p = new Poller();
                        p.SourceDirectory = sourceDirectory;
                        p.FileFilter      = fileFilter;
                        p.Files           = new Dictionary <string, long>(StringComparer.InvariantCultureIgnoreCase);

                        p._References.Add(controller);

                        _PollerPool.BeginAsync(p);

                        Pollers.Add(p);
                    }

                    if (!p._References.Contains(controller))
                    {
                        p._References.Add(controller);
                    }

                    return(p);
                }
            }