C# ProjectCollection.GetLoadedProjects方法代码示例

        internal static MSBuildFile GetFile(FileInfo file)
        {
            using (ProjectCollection loadedProjects = new ProjectCollection())
            {
                Project currentProject = loadedProjects.GetLoadedProjects(file.FullName).FirstOrDefault();

                if (currentProject != null)
                {
                    loadedProjects.UnloadProject(currentProject);
                }

                loadedProjects.LoadProject(file.FullName);
                currentProject = loadedProjects.GetLoadedProjects(file.FullName).FirstOrDefault();

                MSBuildFile m = new MSBuildFile(currentProject);
                if (currentProject.Targets != null)
                {
                    SortedDictionary<string, ProjectTargetInstance> sortedTargets = new SortedDictionary<string, ProjectTargetInstance>(currentProject.Targets);
                    foreach (var t in sortedTargets)
                    {
                        ProjectTargetInstance pti = t.Value;
                        m.Targets.Add(new MSBuildTarget(pti, currentProject, m));
                    }
                }

                foreach (var us in currentProject.Xml.UsingTasks)
                {
                    m.Usings.Add(new MSBuildUsing(currentProject, us));
                }

                foreach (ResolvedImport import in currentProject.Imports)
                {
                    m.Imports.Add(new MSBuildImport(import));
                }

                foreach (var property in currentProject.Properties)
                {
                    m.Properties.Add(new MSBuildProperties(property));
                }

                if (currentProject.AllEvaluatedItems != null)
                {
                    foreach (var item in currentProject.AllEvaluatedItems)
                    {
                        m.Items.Add(new MSBuildItems(item.ItemType, item.UnevaluatedInclude, item.EvaluatedInclude, item.IsImported));
                    }
                }

                return m;
            }
        }

		public ProjectProcessor(string path)
		{
			using (ProjectCollection pc = new ProjectCollection())
			{
				this.Project = pc.GetLoadedProjects(path).FirstOrDefault();
			}
		}

		public void GetLoadedProjectsWithoutFullPath ()
		{
			string project_xml = @"<Project xmlns='http://schemas.microsoft.com/developer/msbuild/2003' />";
			var xml = XmlReader.Create (new StringReader (project_xml));
			var root = ProjectRootElement.Create (xml);
			string path = Path.GetFullPath ("foo.xml");
			var pc = new ProjectCollection ();
			
			pc.LoadProject (XmlReader.Create (new StringReader (project_xml), null, path));
			Assert.AreEqual (0, pc.GetLoadedProjects (path).Count, "#1"); // huh?
			Assert.AreEqual (0, pc.LoadedProjects.Count, "#1.1");
			
			new Project (root, null, null, pc);
			Assert.AreEqual (0, pc.GetLoadedProjects (path).Count, "#2"); // huh?
		}

		public void GetLoadedProjectsForProjectInstance ()
		{
			string project_xml = @"<Project xmlns='http://schemas.microsoft.com/developer/msbuild/2003' />";
			var xml = XmlReader.Create (new StringReader (project_xml));
			var root = ProjectRootElement.Create (xml);
			string path = Path.GetFullPath ("foo.xml");
			var pc = new ProjectCollection ();
			root.FullPath = "foo.xml";
			
			new ProjectInstance (root, null, null, pc);			
			Assert.AreEqual (0, pc.GetLoadedProjects (path).Count, "#1"); // so, ProjectInstance does not actually load Project...
		}

		public void GetLoadedProjectsSuccess2 ()
		{
			string project_xml = @"<Project xmlns='http://schemas.microsoft.com/developer/msbuild/2003' />";
			string path = Path.GetFullPath ("GetLoadedProjectsSuccess2.xml");
			var pc = new ProjectCollection ();
			
			using (var fs = File.CreateText (path))
				fs.Write (project_xml);
			try {
				var proj = pc.LoadProject (path);
				
				Assert.AreEqual (1, pc.GetLoadedProjects (path).Count, "#1"); // ok... LoadProject (with filename) adds it to the collection.
				Assert.AreEqual (proj, pc.GetLoadedProjects (path).First (), "#2");
			} finally {
				File.Delete (path);
			}
		}

		public void GetLoadedProjectsSuccess ()
		{
			string project_xml = @"<Project xmlns='http://schemas.microsoft.com/developer/msbuild/2003' />";
			var xml = XmlReader.Create (new StringReader (project_xml));
			var root = ProjectRootElement.Create (xml);
			string path = Path.GetFullPath ("foo.xml");
			var pc = new ProjectCollection ();
			
			var proj = new Project (root, null, null, pc);
			// this order also matters for test; It sets FullPath after Project.ctor(), and should still work.
			root.FullPath = "foo.xml";
			
			Assert.AreEqual (1, pc.GetLoadedProjects (path).Count, "#1"); // wow ok...
			Assert.AreEqual (proj, pc.GetLoadedProjects (path).First (), "#2");
		}

        /// <summary>
        /// Adds referenced projects that have corresponding nuspec files as dependencies.
        /// </summary>
        /// <param name="dependencies">The dependencies collection where the new dependencies
        /// are added into.</param>
        private void AddProjectReferenceDependencies(Dictionary<string, PackageDependency> dependencies)
        {
            var processedProjects = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
            var projectsToProcess = new Queue<Project>();

            using (var projectCollection = new ProjectCollection())
            {
                projectsToProcess.Enqueue(_project);
                while (projectsToProcess.Count > 0)
                {
                    var project = projectsToProcess.Dequeue();
                    processedProjects.Add(project.FullPath);

                    foreach (var projectReference in project.GetItems(ProjectReferenceItemType))
                    {
                        string fullPath = projectReference.GetMetadataValue("FullPath");
                        if (string.IsNullOrEmpty(fullPath) ||
                            processedProjects.Contains(fullPath))
                        {
                            continue;
                        }

                        var loadedProjects = projectCollection.GetLoadedProjects(fullPath);
                        var referencedProject = loadedProjects.Count > 0 ?
                            loadedProjects.First() :
                            new Project(
                                fullPath,
                                globalProperties: project.GlobalProperties,
                                toolsVersion: null,
                                projectCollection: projectCollection);

                        if (NuspecFileExists(fullPath))
                        {
                            var dependency = CreateDependencyFromProject(referencedProject);
                            dependencies[dependency.Id] = dependency;
                        }
                        else
                        {
                            projectsToProcess.Enqueue(referencedProject);
                        }
                    }
                }
            }
        }

 /// <summary>
 /// Recursively execute the specified action on the current project and
 /// projects referenced by the current project.
 /// </summary>
 /// <param name="action">The action to be executed.</param>
 /// <param name="alreadyAppliedProjects">The collection of projects that have been processed.
 /// It is used to avoid processing the same project more than once.</param>
 private void RecursivelyApply(Action<ProjectFactory> action, ProjectCollection alreadyAppliedProjects)
 {
     action(this);
     foreach (var item in _project.GetItems(ProjectReferenceItemType))
     {
         string fullPath = item.GetMetadataValue("FullPath");
         if (!string.IsNullOrEmpty(fullPath) && 
             !NuspecFileExists(fullPath) &&
             alreadyAppliedProjects.GetLoadedProjects(fullPath).IsEmpty())
         {
             var project = new Project(
                 fullPath, 
                 globalProperties: null, 
                 toolsVersion: null, 
                 projectCollection: alreadyAppliedProjects);
             var referencedProject = new ProjectFactory(project);
             referencedProject.Logger = _logger;
             referencedProject.IncludeSymbols = IncludeSymbols;
             referencedProject.Build = Build;
             referencedProject.IncludeReferencedProjects = IncludeReferencedProjects;
             referencedProject.ProjectProperties = ProjectProperties;
             referencedProject.TargetFramework = TargetFramework;
             referencedProject.BaseTargetPath = BaseTargetPath;
             referencedProject.SolutionName = SolutionName;
             referencedProject.BuildProject();
             referencedProject.RecursivelyApply(action, alreadyAppliedProjects);
         }
     }
 }

        private void LoadFile(FileInfo file)
        {
            try
            {
                using (ProjectCollection loadedProjects = new ProjectCollection())
                {
                    this.proj = loadedProjects.GetLoadedProjects(file.FullName).FirstOrDefault();

                    if (this.proj != null)
                    {
                        loadedProjects.UnloadProject(this.proj);
                    }

                    loadedProjects.LoadProject(file.FullName);
                    this.proj = loadedProjects.GetLoadedProjects(file.FullName).FirstOrDefault();
                }
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message, "Error Parsing Text", MessageBoxButton.OK, MessageBoxImage.Error);
            }
        }

        /// <summary>
        ///     Initializes the in memory project. Sets BuildEnabled on the project to true.
        /// </summary>
        /// <param name="engine">The build engine to use to create a build project.</param>
        /// <param name="fullProjectPath">The full path of the project.</param>
        /// <returns>A loaded msbuild project.</returns>
        internal static Microsoft.Build.Evaluation.Project InitializeMsBuildProject(ProjectCollection buildEngine, string fullProjectPath)
        {
            ArgumentNotNullOrEmpty("fullProjectPath", fullProjectPath);

            // Call GetFullPath to expand any relative path passed into this method.
            fullProjectPath = CommonUtils.NormalizePath(fullProjectPath);

            // Check if the project already has been loaded with the fullProjectPath. If yes return the build project associated to it.
            var loadedProject = new List<Microsoft.Build.Evaluation.Project>(buildEngine.GetLoadedProjects(fullProjectPath));
            Microsoft.Build.Evaluation.Project buildProject = loadedProject != null && loadedProject.Count > 0 && loadedProject[0] != null ? loadedProject[0] : null;

            if (buildProject == null)
            {
                buildProject = buildEngine.LoadProject(fullProjectPath);
            }

            return buildProject;
        }