/// <summary>
        /// Find projects that depend on a given project, and it's own project dependencies.
        /// </summary>
        /// <param name="args"></param>
        /// <param name="/project">The name of the project</param>
        /// <param name="/folder">Root folder where projects that depend on the given project are searched for</param>
        /// <param name="/out">Optional. File to dump results to. If null then results will be dumped to Console.</param>
        /// <returns></returns>
        public static int Main(string[] args)
        {
            string        projFile;
            string        outFile;
            List <string> topFolders = new List <string>();

            if (!ParseCommandLine(topFolders, out projFile, out outFile))
            {
                Usage();
                return(-1);
            }

            // Setup search folders and project pattern
            projFile = ParseProject.NormalizeReferenceName(projFile);
            SearchFolders folders = new SearchFolders();

            folders.AddFolders(topFolders);
            folders.AddPattern(projFile + ".*proj");
            ParseProject.SetSearchFolders(folders);

            // List the projects the target project depends on
            List <string> dependentProjects = new List <string>();

            foreach (string proj in folders.Search())
            {
                dependentProjects.Add(proj);
                using (ParseProject po = new ParseProject(proj))
                {
                    dependentProjects.AddRange(po.ProjectReferences);
                }
            }

            // List the projects that depend on the target project:
            // Find all project files in the folders.
            IEnumerable <string> projFiles = folders.Search("*.*proj");

            foreach (string p in projFiles)
            {
                using (ParseProject po = new ParseProject(p))
                {
                    // Test if this project depends on the target project
                    if (po.ProjectReferences.Contains(projFile, StringComparer.OrdinalIgnoreCase))
                    {
                        dependentProjects.Add(p);
                    }
                }
            }

            // Unique, sorted list
            if (ErrorManager.Good)
            {
                dependentProjects = new List <string>(dependentProjects.Distinct(StringComparer.OrdinalIgnoreCase));
                ParseProject.SetBuildOrder(dependentProjects);
            }

            // Dump project file, even if error(s) occured.
            if (!string.IsNullOrWhiteSpace(outFile))
            {
                ParseProject.CreateBuildFile(outFile, dependentProjects);
            }
            else
            {
                foreach (string s in dependentProjects)
                {
                    Console.WriteLine(s);
                }
            }

            return(ErrorManager.ExitCode);
        }
Beispiel #2
0
 /// <summary>
 // Set of folders to search for dependencies.
 /// </summary>
 /// <param name="folders"></param>
 public static void SetSearchFolders(SearchFolders folders)
 {
     _searchFolders = folders;
 }