C# ProjectInstance.GetItems方法代码示例

            private static string[] GetTargetFrameworkSubsets(ProjectInstance projectInstance)
            {
                IEnumerable<ITaskItem> taskItems = projectInstance.GetItems(ReferenceInstalledAssemblySubsets);

                string[] targetFrameworkSubsets = (taskItems.Select((Func<ITaskItem, string>)((item) => { return item.ItemSpec.Trim(); }))).ToArray();

                return targetFrameworkSubsets;
            }

        /// <summary>
        /// Get all items of type 'i'
        /// </summary>
        private static IList<ProjectItemInstance> GetItems(string content)
        {
            ProjectRootElement xml = ProjectRootElement.Create(XmlReader.Create(new StringReader(content)));
            ProjectInstance project = new ProjectInstance(xml);

            return Helpers.MakeList(project.GetItems("i"));
        }

 private static ITaskItem[] GetInstalledAssemblySubsetTables(ProjectInstance projectInstance)
 {
     return projectInstance.GetItems(InstalledAssemblySubsetTablesName).ToArray();
 }

            private static string[] GetLatestTargetFrameworkDirectories(ProjectInstance projectInstance)
            {
                IEnumerable<ITaskItem> taskItems = projectInstance.GetItems(LatestTargetFrameworkDirectoriesName);

                string[] latestTargetFrameworkDirectory = (taskItems.Select((Func<ITaskItem, string>)((item) => { return item.ItemSpec.Trim(); }))).ToArray();

                return latestTargetFrameworkDirectory;
            }

            private static string[] GetCandidateAssemblyFiles(ProjectInstance projectInstance)
            {
                var candidateAssemblyFilesList = new List<ProjectItemInstance>();

                candidateAssemblyFilesList.AddRange(projectInstance.GetItems(Content));
                candidateAssemblyFilesList.AddRange(projectInstance.GetItems(None));
                candidateAssemblyFilesList.AddRange(projectInstance.GetItems(RARResolvedReferencePath));

                string[] candidateAssemblyFiles = candidateAssemblyFilesList.Select((Func<ProjectItemInstance, string>)((item) => { return item.GetMetadataValue("FullPath").Trim(); })).ToArray();

                return candidateAssemblyFiles;
            }

 private static ITaskItem[] GetFullFrameworkAssemblyTables(ProjectInstance projectInstance)
 {
     return projectInstance.GetItems(FullFrameworkAssemblyTablesName).ToArray();
 }

        public void TransformsUseCorrectDirectory_Basic_NotSaved()
        {
            string projectFileContent = ObjectModelHelpers.CleanupFileContents(@"
                    <Project xmlns='msbuildnamespace'>
                        <ItemGroup>
                            <IntermediateAssembly Include='obj\i386\foo.dll'/>
                            <BuiltProjectOutputGroupKeyOutput Include=""@(IntermediateAssembly->'%(FullPath)')""/>
                        </ItemGroup>
                    </Project>");

            ProjectRootElement xml = ProjectRootElement.Create(XmlReader.Create(new StringReader(projectFileContent)));

            Project project = new Project(xml);
            ProjectInstance projectInstance = new ProjectInstance(xml);

            Assert.Equal(Path.Combine(Environment.CurrentDirectory, @"obj\i386\foo.dll"), project.GetItems("BuiltProjectOutputGroupKeyOutput").First().EvaluatedInclude);
            Assert.Equal(Path.Combine(Environment.CurrentDirectory, @"obj\i386\foo.dll"), projectInstance.GetItems("BuiltProjectOutputGroupKeyOutput").First().EvaluatedInclude);
        }

        public void TransformsUseCorrectDirectory_DirectoryNameItemFunction()
        {
            string file = null;

            string projectFileContent = ObjectModelHelpers.CleanupFileContents(@"
                    <Project xmlns='msbuildnamespace'>
                        <ItemGroup>
                            <IntermediateAssembly Include='obj\i386\foo.dll'/>
                            <BuiltProjectOutputGroupKeyOutput Include=""@(IntermediateAssembly->DirectoryName())""/>
                        </ItemGroup>
                    </Project>");

            ProjectRootElement xml = ProjectRootElement.Create(XmlReader.Create(new StringReader(projectFileContent)));

            try
            {
                file = Microsoft.Build.Shared.FileUtilities.GetTemporaryFile();
                xml.FullPath = file;

                Project project = new Project(xml);
                ProjectInstance projectInstance = new ProjectInstance(xml);

                // Should be the full path to the directory
                Assert.Equal(Path.Combine(Path.GetTempPath() /* remove c:\ */, @"obj\i386"), project.GetItems("BuiltProjectOutputGroupKeyOutput").First().EvaluatedInclude);
                Assert.Equal(Path.Combine(Path.GetTempPath() /* remove c:\ */, @"obj\i386"), projectInstance.GetItems("BuiltProjectOutputGroupKeyOutput").First().EvaluatedInclude);
            }
            finally
            {
                File.Delete(file);
            }
        }

        /// <summary>
        /// Checks the provided project for a matching itemtype and include value.  If it
        /// does not exist, asserts. 
        /// </summary>
        private void AssertProjectContainsItem(ProjectInstance msbuildProject, string itemType, string include)
        {
            IEnumerable<ProjectItemInstance> itemGroup = msbuildProject.GetItems(itemType);
            Assert.IsNotNull(itemGroup);

            foreach (ProjectItemInstance item in itemGroup)
            {
                if (item.ItemType == itemType && item.EvaluatedInclude == include)
                {
                    return;
                }
            }

            Assert.IsTrue(false);
        }

 /// <summary>
 /// Counts the number of items with a particular itemtype in the provided project, and 
 /// asserts if it doesn't match the provided count.
 /// </summary>
 private void AssertProjectItemNameCount(ProjectInstance msbuildProject, string itemType, int count)
 {
     IEnumerable<ProjectItemInstance> itemGroup = msbuildProject.GetItems(itemType);
     Assert.IsNotNull(itemGroup);
     Assert.AreEqual(count, itemGroup.Count());
 }

		static Guid[] getDependentProjectGuids(ProjectInstance instance)
		{
			var refs = instance.GetItems("ProjectReference").Select(item => Guid.Parse(item.GetMetadataValue("Project"))).ToArray();
			return refs;
		}

        public void PhoenixBatchingIssue()
        {
            ProjectRootElement xml = ProjectRootElement.Create(XmlReader.Create(new StringReader(ObjectModelHelpers.CleanupFileContents(@"
            <Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
                <ItemGroup>
                    <CppCompile Include='gen.cpp'/>
                    <CppCompile Include='def.cpp'>
                        <ObjectFile>def.obj</ObjectFile>
                    </CppCompile>
                </ItemGroup>
                
                <Target Name='t'>
                    <ItemGroup>
                        <CppCompile>
                            <IncludeInLib Condition=""'%(CppCompile.IncludeInLib)' == ''"">true</IncludeInLib>
                        </CppCompile>
                        <CppCompile>
                            <ObjectFile>%(Filename).obj</ObjectFile>
                        </CppCompile>
                    </ItemGroup>
                </Target>
            </Project>
            "))));
            ProjectInstance instance = new ProjectInstance(xml);
            instance.Build();

            Assert.AreEqual(2, instance.Items.Count());
            Assert.AreEqual("gen.obj", instance.GetItems("CppCompile").First().GetMetadataValue("ObjectFile"));
            Assert.AreEqual("def.obj", instance.GetItems("CppCompile").Last().GetMetadataValue("ObjectFile"));
        }

		public void ExpandPropertyThenTrim ()
		{
			string test = @"A
B
C
    ";
			string project_xml = string.Format (@"<Project xmlns='http://schemas.microsoft.com/developer/msbuild/2003'>
  <PropertyGroup>
    <Test>{0}</Test>
    <Test2>$(TEST)</Test2>
  </PropertyGroup>
  <ItemGroup>
    <X Include='$(TEST)' />
    <X2 Include='$(TEST)z' />
  </ItemGroup>
</Project>", test);
			var xml = XmlReader.Create (new StringReader (project_xml));
			var root = ProjectRootElement.Create (xml);
			root.FullPath = "ProjectItemTest.ExpandPropertyThenTrim.proj";
			var proj = new ProjectInstance (root);
			Assert.AreEqual (test, proj.GetPropertyValue ("TEST"), "#1");
			Assert.AreEqual (test, proj.GetPropertyValue ("TEST2"), "#2");
			Assert.AreEqual (test.Trim (), proj.GetItems ("X").First ().EvaluatedInclude, "#3");			
			Assert.AreEqual (test + "z", proj.GetItems ("X2").First ().EvaluatedInclude, "#4");
		}

		[Category ("NotWorking")] // until we figure out why it fails on wrench.
		public void ItemsInTargets ()
		{
			string project_xml = @"<Project DefaultTargets='Default' xmlns='http://schemas.microsoft.com/developer/msbuild/2003'>
	<Target Name='Default'>
		<PropertyGroup>
			<_ExplicitMSCorlibPath>$([Microsoft.Build.Utilities.ToolLocationHelper]::GetPathToStandardLibraries ('$(TargetFrameworkIdentifier)', '$(TargetFrameworkVersion)', '$(TargetFrameworkProfile)'))\mscorlib.dll</_ExplicitMSCorlibPath>
		</PropertyGroup>
		<ItemGroup>
			<_ExplicitReference
				Include='$(_ExplicitMSCorlibPath)'
				Condition='Exists($(_ExplicitMSCorlibPath))'>
				<Private>false</Private>
			</_ExplicitReference>
		</ItemGroup>
	</Target>
	<Import Project='$(MSBuildBinPath)\\Microsoft.CSharp.targets' />
</Project>";
			var xml = XmlReader.Create (new StringReader (project_xml));
			var root = ProjectRootElement.Create (xml);
			root.FullPath = "ProjectInstanceTest.ConditionalExpression.proj";
			var proj = new ProjectInstance (root, null, "4.0", ProjectCollection.GlobalProjectCollection);
			proj.Build ();
			// make sure the property value expansion is done successfully.
			Assert.IsTrue (!string.IsNullOrEmpty (proj.GetPropertyValue ("_ExplicitMSCorlibPath")), "premise: propertyValue by ToolLocationHelper func call");
			var items = proj.GetItems ("_ExplicitReference");
			// make sure items are stored after build.
			Assert.IsTrue (items.Any (), "items.Any");
			Assert.IsTrue (!string.IsNullOrEmpty (items.First ().EvaluatedInclude), "item.EvaluatedInclude");
		}

		public void BuildCommonResolveAssemblyReferences ()
		{
			string project_xml = @"<Project xmlns='http://schemas.microsoft.com/developer/msbuild/2003'>
  <Import Project='$(MSBuildToolsPath)\Microsoft.Common.targets' />
  <ItemGroup>
    <Reference Include='System.Core' />
    <Reference Include='System.Xml' />
  </ItemGroup>
</Project>";
			var xml = XmlReader.Create (new StringReader (project_xml));
			var root = ProjectRootElement.Create (xml);
			root.FullPath = "BuildManagerTest.BuildCommonResolveAssemblyReferences.proj";
			var proj = new ProjectInstance (root);
			var manager = new BuildManager ();
			var parameters = new BuildParameters () { Loggers = new ILogger [] {new ConsoleLogger (LoggerVerbosity.Diagnostic)} };
			var request = new BuildRequestData (proj, new string [] {"ResolveAssemblyReferences"});
			Assert.AreEqual (string.Empty, proj.GetPropertyValue ("TargetFrameworkDirectory"), "#1-1");
			var result = manager.Build (parameters, request);
			Assert.AreNotEqual (string.Empty, proj.GetPropertyValue ("TargetFrameworkDirectory"), "#1-2"); // filled during build.
			Assert.IsTrue (result.ResultsByTarget.ContainsKey ("GetFrameworkPaths"), "#2-1");
			Assert.IsTrue (result.ResultsByTarget.ContainsKey ("PrepareForBuild"), "#2-2");
			Assert.IsTrue (result.ResultsByTarget.ContainsKey ("ResolveAssemblyReferences"), "#2-3");
			var items = proj.GetItems ("ReferencePath");
			Assert.AreEqual (2, items.Count (), "#3");
			var syscore = items.FirstOrDefault (i => Path.GetFileName (i.EvaluatedInclude) == "System.Core.dll");
			var sysxml = items.FirstOrDefault (i => Path.GetFileName (i.EvaluatedInclude) == "System.Xml.dll");
			Assert.IsNotNull (syscore, "#4-1");
			Assert.IsNotNull (sysxml, "#4-2");
			Assert.IsTrue (File.Exists (syscore.EvaluatedInclude), "#5-1");
			Assert.IsTrue (File.Exists (sysxml.EvaluatedInclude), "#5-1");
			Assert.AreEqual (BuildResultCode.Success, result.OverallResult, "#6");
		}