Uso di proprietà MatchPattern di attività FindMatchingFiles del flusso di lavoro

Question

Sono personalizzare il flusso di lavoro di default del modello di processo di compilazione utilizzando TFS 2010 Team Build. C'è un'attività di nome FindMatchingFiles permette di cercare file specifici con un modello definito in proprietà MatchPattern. Funziona se a specificare una sola estensione del file. Esempio:

String.Format("{0}\\**\\\*.msi", SourcesDirectory)

Ma mi piacerebbe includere * .exe pure. Cercando seguente schema, ma non funziona:

String.Format("{0}\\**\\\*.(msi|exe)", SourcesDirectory)

Chiunque potrebbe mostrarmi come correggerlo?

Answer 1

È possibile utilizzare String.Format("{0}\**\*.msi;{0}\**\*.exe", SourcesDirectory)

Answer 2

Il FindMatchingFiles attività 's proprietà MatchPattern utilizza il

Sintassi supportato dall'argomento searchPattern del href="http://msdn.microsoft.com/en-us/library/wz42302f" rel="nofollow noreferrer"> Directory.GetFiles(String, String) metodo .

Ciò significa che non è possibile combinare più estensioni. Avrete bisogno di chiamare l'attività FindMatchingFiles due volte. È quindi possibile combinare i risultati di queste due chiamate quando li si utilizza (vale a dire se i risultati sono msiFiles e exeFiles, è possibile utilizzare msiFiles.Concat(exeFiles) come input per un ForEach).

Tuttavia, come si può vedere con @ di Antwoord risposta , l'attività realtà non sembrano accettare un punto e virgola delimitato elenco dei modelli, a differenza Directory.GetFiles.

Answer 3

FindMatchingFiles ha qualche strano modello di ricerca. Ecco il codice (decompilato usando ILSpy) in modo da poter testare i vostri modelli di ricerca, senza dover dare il via una nuova build.

Esso contiene una directory di root hardcoded nella seguente posizione (Z:)

List<string> matchingDirectories = GetMatchingDirectories(@"Z:", matchPattern.Substring(0, num), 0);

Codice:

using System;
using System.Collections.Generic;
using System.IO;

namespace DirectoryGetFiles
{

    ////    Use the FindMatchingFiles activity to find files. Specify the search criteria in the MatchPattern (String) property.
    ////    In this property, you can specify an argument that includes the following elements: 
    ////        Syntax that is supported by the searchPattern argument of the Directory GetFiles(String, String) method.
    ////
    ////        ** to specify a recursive search. For example:
    ////            To search the sources directory for text files, you could specify something that resembles the following
    ////            value for the MatchPattern property: String.Format("{0}\**\*.txt", SourcesDirectory).
    ////            
    ////            To search the sources directory for text files in one or more subdirectories that are called txtfiles, 
    ////            you could specify something that resembles the following value for the MatchPattern property: 
    ////            String.Format("{0}\**\txtfiles\*.txt", SourcesDirectory).

    class Program
    {
        static void Main(string[] args)
        {
            string searchPattern = @"_PublishedWebsites\Web\Scripts\jasmine-specs**\*.js";
            var results = Execute(searchPattern);

            foreach (var i in results)
            {
                Console.WriteLine("found: {0}", i);
            }

            Console.WriteLine("Done...");
            Console.ReadLine();
        }

        private static IEnumerable<string> Execute(string pattern)
        {
            string text = pattern;
            text = text.Replace(";;", "\0");
            var hashSet = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
            string[] array = text.Split(new char[]
    {
        ';'
    }, StringSplitOptions.RemoveEmptyEntries);

            for (int i = 0; i < array.Length; i++)
            {
                string text2 = array[i];
                string text3 = text2.Replace("\0", ";");
                if (IsValidPattern(text3))
                {
                    List<string> list = ComputeMatchingPaths(text3);
                    if (list.Count > 0)
                    {
                        using (List<string>.Enumerator enumerator = list.GetEnumerator())
                        {
                            while (enumerator.MoveNext())
                            {
                                string current = enumerator.Current;
                                hashSet.Add(current);
                            }
                            goto IL_15C;
                        }
                    }
                    ////Message = ActivitiesResources.Format("NoMatchesForSearchPattern", new object[]
                }
                else
                {
                    ////       Message = ActivitiesResources.Format("InvalidSearchPattern", new object[]
                }

            IL_15C: ;
            }

            return hashSet;//.OrderBy((string x) => x, FileSpec.TopDownComparer);
        }

        private static bool IsValidPattern(string pattern)
        {
            string text = "**" + Path.DirectorySeparatorChar;
            int num = pattern.IndexOf(text, StringComparison.Ordinal);
            return (num < 0 || (pattern.IndexOf(text, num + text.Length, StringComparison.OrdinalIgnoreCase) <= 0 && pattern.IndexOf(Path.DirectorySeparatorChar, num + text.Length) <= 0)) && pattern[pattern.Length - 1] != Path.DirectorySeparatorChar;
        }

        private static List<string> ComputeMatchingPaths(string matchPattern)
        {
            List<string> list = new List<string>();
            string text = "**" + Path.DirectorySeparatorChar;
            int num = matchPattern.IndexOf(text, 0, StringComparison.OrdinalIgnoreCase);
            if (num >= 0)
            {
                List<string> matchingDirectories = GetMatchingDirectories(@"Z:", matchPattern.Substring(0, num), 0);
                string searchPattern = matchPattern.Substring(num + text.Length);
                using (List<string>.Enumerator enumerator = matchingDirectories.GetEnumerator())
                {
                    while (enumerator.MoveNext())
                    {
                        string current = enumerator.Current;
                        list.AddRange(Directory.GetFiles(current, searchPattern, SearchOption.AllDirectories));
                    }
                    return list;
                }
            }
            int num2 = matchPattern.LastIndexOf(Path.DirectorySeparatorChar);
            if (num2 >= 0)
            {
                List<string> matchingDirectories2 = GetMatchingDirectories(string.Empty, matchPattern.Substring(0, num2 + 1), 0);
                string searchPattern2 = matchPattern.Substring(num2 + 1);
                using (List<string>.Enumerator enumerator2 = matchingDirectories2.GetEnumerator())
                {
                    while (enumerator2.MoveNext())
                    {
                        string current2 = enumerator2.Current;
                        try
                        {
                            list.AddRange(Directory.GetFiles(current2, searchPattern2, SearchOption.TopDirectoryOnly));
                        }
                        catch
                        {
                        }
                    }
                    return list;
                }
            }
            try
            {
                list.AddRange(Directory.GetFiles(Directory.GetCurrentDirectory(), matchPattern, SearchOption.TopDirectoryOnly));
            }
            catch
            {
            }
            return list;
        }

        private static List<string> GetMatchingDirectories(string rootDir, string pattern, int level)
        {
            if (level > 129)
            {
                return new List<string>();
            }
            List<string> list = new List<string>();
            int num = pattern.IndexOf('*');
            if (num >= 0)
            {
                int num2 = pattern.Substring(0, num).LastIndexOf(Path.DirectorySeparatorChar);
                string text = (num2 >= 0) ? Path.Combine(rootDir, pattern.Substring(0, num2 + 1)) : rootDir;
                if (text.Equals(string.Empty))
                {
                    text = Directory.GetCurrentDirectory();
                }
                int num3 = pattern.IndexOf(Path.DirectorySeparatorChar, num);
                if (num3 < 0)
                {
                    num3 = pattern.Length;
                }
                string searchPattern = pattern.Substring(num2 + 1, num3 - num2 - 1);
                try
                {
                    string[] directories = Directory.GetDirectories(text, searchPattern, SearchOption.TopDirectoryOnly);
                    if (num3 < pattern.Length - 1)
                    {
                        string pattern2 = pattern.Substring(num3 + 1);
                        string[] array = directories;
                        for (int i = 0; i < array.Length; i++)
                        {
                            string rootDir2 = array[i];
                            list.AddRange(GetMatchingDirectories(rootDir2, pattern2, level + 1));
                        }
                    }
                    else
                    {
                        list.AddRange(directories);
                    }
                    return list;
                }
                catch
                {
                    return list;
                }
            }
            string text2 = Path.Combine(rootDir, pattern);
            if (text2.Equals(string.Empty))
            {
                list.Add(Directory.GetCurrentDirectory());
            }
            else
            {
                if (Directory.Exists(text2))
                {
                    list.Add(Path.GetFullPath(text2));
                }
            }
            return list;
        }
    }
}