예제 #1
0
        private void EnumerateRecursive(IFindInFilesNode root, string relative, out bool cancelled)
        {
            currentPath = root;

            cancelled = false;
            foreach (IFindInFilesItem file in root.GetFiles())
            {
                if (CancellationPending)
                {
                    cancelled = true;
                    return;
                }

                bool include;
                {
                    include = extensionsIncluded.Length == 0;
                    string extension = file.GetExtension().ToLowerInvariant();
                    if (!include && (Array.IndexOf(extensionsIncluded, extension) >= 0))
                    {
                        include = true;
                    }
                    if (include && (Array.IndexOf(extensionsExcluded, extension) >= 0))
                    {
                        include = false;
                    }
                }

                if (include)
                {
                    TestFile(file, relative);
                }
            }
            foreach (IFindInFilesNode dir in root.GetDirectories())
            {
                if (CancellationPending)
                {
                    cancelled = true;
                    return;
                }
                EnumerateRecursive(dir, Path.Combine(relative, dir.GetFileName()), out cancelled);
            }
        }
예제 #2
0
 public IFindInFilesNode[] GetDirectories()
 {
     string[] directories = Directory.GetDirectories(root);
     IFindInFilesNode[] nodes = new IFindInFilesNode[directories.Length];
     for (int i = 0; i < nodes.Length; i++)
     {
         nodes[i] = new FindInFilesNode(directories[i]);
     }
     return nodes;
 }
예제 #3
0
        public FindInFilesTask(
            string pattern,
            IFindInFilesNode root,
            string extensions,
            bool caseSensitive,
            bool matchWholeWords)
        {
            if (String.IsNullOrEmpty(pattern))
            {
                throw new ArgumentException();
            }
            // ensure valid root
            try
            {
                root.GetFiles();
            }
            catch (Exception)
            {
                throw new ArgumentException();
            }

            this.pattern = pattern;
            this.root = root;
            if (!String.IsNullOrEmpty(extensions))
            {
                List<string> extensionsIncluded = new List<string>();
                List<string> extensionsExcluded = new List<string>();
                foreach (string extension1 in extensions.Split(new char[] { ';', ',' }, StringSplitOptions.RemoveEmptyEntries))
                {
                    string extension = extension1;
                    if (extension.StartsWith("*"))
                    {
                        extension = extension.Substring(1);
                    }
                    bool exclude = extension.StartsWith("!");
                    if (exclude)
                    {
                        extension = extension.Substring(1);
                    }
                    if (!extension.StartsWith("."))
                    {
                        extension = String.Concat(".", extension);
                    }
                    if (!exclude)
                    {
                        extensionsIncluded.Add(extension);
                    }
                    else
                    {
                        extensionsExcluded.Add(extension);
                    }
                }
                this.extensionsIncluded = extensionsIncluded.ToArray();
                this.extensionsExcluded = extensionsExcluded.ToArray();
            }
            this.caseSensitive = caseSensitive;
            this.matchWholeWords = matchWholeWords;

            this.WorkerReportsProgress = true;
            this.WorkerSupportsCancellation = true;
        }