C# Engine.AddToolset方法代码示例

        public void AddingAnExistingToolsVersionDirtiesLoadedProjects()
        {
            try
            {
                Engine e = new Engine(ToolsetDefinitionLocations.None);
                e.AddToolset(new Toolset("2.0", "someToolsPath"));
                e.AddToolset(new Toolset("3.0", "anotherToolsPath"));

                string p1Path = ObjectModelHelpers.CreateFileInTempProjectDirectory("p1.csproj", @"<Project DefaultTargets=`Build` ToolsVersion=`msbuilddefaulttoolsversion` xmlns=`msbuildnamespace`/>");
                string p2Path = ObjectModelHelpers.CreateFileInTempProjectDirectory("p2.csproj", @"<Project DefaultTargets=`Build` ToolsVersion=`msbuilddefaulttoolsversion` xmlns=`msbuildnamespace`/>");

                Project p1 = new Project(e, "2.0");
                p1.Load(p1Path);
                Project p2 = new Project(e, "3.0");
                p2.Load(p2Path);

                Assertion.Assert("Expected p1.IsDirty to be false", !p1.IsDirty);
                Assertion.Assert("Expected p2.IsDirty to be false", !p2.IsDirty);

                e.AddToolset(new Toolset("2.0", "someTotallyDifferentToolsPath"));

                Assertion.Assert("Expected p1.IsDirty to be true", p1.IsDirty);
                Assertion.Assert("Expected p2.IsDirty to be false", !p2.IsDirty);

            }
            finally
            {
                ObjectModelHelpers.DeleteTempProjectDirectory();
            }
        }

 public void BinPathAfterDefaultToolsVersionChange()
 {
     Engine e = new Engine(ToolsetDefinitionLocations.None);
     e.AddToolset(new Toolset("orcas", @"C:\OrcasBinPath"));
     e.DefaultToolsVersion = "Orcas";
     Assertion.AssertEquals(@"C:\OrcasBinPath", e.BinPath);
     Assertion.AssertEquals("Orcas", e.DefaultToolsVersion);
 }

        public void ToolsVersionAttributeNotSpecifiedOnProjectElementAndDefaultVersionSpecifiedInRegistry()
        {
            Engine e = new Engine();
            e.AddToolset(new Toolset("2.0", "20toolsPath"));
            e.AddToolset(new Toolset("4.0", "40toolsPath"));

            string projectPath = ObjectModelHelpers.CreateFileInTempProjectDirectory("x.proj", @"<Project xmlns=""http://schemas.microsoft.com/developer/msbuild/2003"" />");

            Project project = e.CreateNewProject();
            project.Load(projectPath);

            Assertion.AssertEquals("2.0", project.ToolsVersion);
            Assertion.AssertEquals("2.0", project.DefaultToolsVersion);
        }

        public void SettingDefaultToolsVersionThrowsIfProjectsAlreadyLoaded()
        {
            Engine e = new Engine(ToolsetDefinitionLocations.None);
            
            try
            {
                e.AddToolset(new Toolset("1.0", "someToolsPath"));
                e.AddToolset(new Toolset("2.0", "someToolsPath"));
                e.DefaultToolsVersion = "1.0"; // OK
            }
            catch(InvalidOperationException)
            {
                // Make sure the first one doesn't throw
                Assertion.Assert(false); 
            }

            try
            {
                string p1Path = ObjectModelHelpers.CreateFileInTempProjectDirectory("p1.csproj", @"<Project DefaultTargets=`Build` xmlns=`msbuildnamespace`/>");
                Project p1 = new Project(e);
                p1.Load(p1Path);

                e.DefaultToolsVersion = "2.0"; // Throws
            }
            finally
            {
                ObjectModelHelpers.DeleteTempProjectDirectory();
            }
        }

        public void SetEffectiveToolsVersionAttribute()
        {
            Engine e = new Engine("www.msbuild.org");
            e.AddToolset(new Toolset("myValidToolsVersion", "myValidToolsVersion's path"));
            e.AddToolset(new Toolset("myOtherToolsVersion", "myOtherToolsVersion's path"));

            MockLogger logger = new MockLogger();

            Project project = ObjectModelHelpers.CreateInMemoryProject(e, ObjectModelHelpers.CleanupFileContents(@"
                <Project ToolsVersion=`myValidToolsVersion` DefaultTargets=`Build` xmlns=`msbuildnamespace`>
                    <UsingTask TaskName='Message' AssemblyName='Microsoft.Build.Tasks.Core, Version=msbuildassemblyversion, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a'/>    
                    <PropertyGroup>
                       <TheToolsVersion>$(MSBuildToolsVersion)</TheToolsVersion>
                    </PropertyGroup>
                    <Target Name=`Build`>
                       <Message Text=`### $(TheToolsVersion) ###` />
                    </Target>
                </Project>"), logger, "myValidToolsVersion");

            project.ToolsVersion = "myOtherToolsVersion";

            project.Build();

            Assertion.Assert("We should be using a ToolsVersion override", project.OverridingToolsVersion);
            Assertion.AssertEquals("We should have ToolsVersion equal to myOtherToolsVersion",
                "myOtherToolsVersion", project.ToolsVersion);
            Assertion.AssertEquals("We should have ToolsVersionAttribute equal to myValidToolsVersion",
                "myValidToolsVersion", project.DefaultToolsVersion);
            logger.AssertLogContains("### myOtherToolsVersion ###");
        }

        public void PropertiesFromToolsetAppliedToProjectWhenToolsVersionOverridden()
        {
            Engine e = new Engine("www.msbuild.org");
            BuildPropertyGroup properties1 = new BuildPropertyGroup();
            properties1.SetProperty("foo1", "bar1");
            properties1.SetProperty("foo2", "bar2");
            BuildPropertyGroup properties2 = new BuildPropertyGroup();
            properties2.SetProperty("foo3", "bar3");
            properties2.SetProperty("foo1", "bar4");
            e.AddToolset(new Toolset("myValidToolsVersion", "myValidToolsVersion's path", properties1));
            e.AddToolset(new Toolset("myOtherToolsVersion", "myOtherToolsVersion's path", properties2));

            MockLogger logger = new MockLogger();

            Project project = ObjectModelHelpers.CreateInMemoryProject(e, @"
                <Project ToolsVersion=`myValidToolsVersion` xmlns=`msbuildnamespace`/>", logger, "myOtherToolsVersion");

            Assertion.AssertEquals("bar4", project.EvaluatedProperties["foo1"].Value);  // Updated
            Assertion.AssertEquals(null, project.EvaluatedProperties["foo2"]);      // Reset
            Assertion.AssertEquals("bar3", project.EvaluatedProperties["foo3"].Value);  // New
        }

        public void SettingToolsVersionAttributeAfterToolsVersionSetInProjectConstructor()
        {
            Engine e = new Engine("www.msbuild.org");
            e.AddToolset(new Toolset("myValidToolsVersion", "myValidToolsVersion's path"));
            e.AddToolset(new Toolset("myOtherToolsVersion", "myOtherToolsVersion's path"));

            Project project = ObjectModelHelpers.CreateInMemoryProject(e, @"
                <Project DefaultTargets=`Build` xmlns=`msbuildnamespace`>
                    <Target Name=`Build`/>
                </Project>", null, "myValidToolsVersion");

            project.DefaultToolsVersion = "myOtherToolsVersion";

            Assertion.AssertEquals("We should have Override equal to true",
                true, project.OverridingToolsVersion);
            Assertion.AssertEquals("We should have ToolsVersion equal to myOtherToolsVersion",
                "myValidToolsVersion", project.ToolsVersion);
            Assertion.AssertEquals("We should have ToolsVersionAttribute equal to myOtherToolsVersion",
                "myOtherToolsVersion", project.DefaultToolsVersion);
        }

        public void MSBuildToolsVersionProperty2()
        {
            Engine e = new Engine("www.msbuild.org");
            e.AddToolset(new Toolset("myValidToolsVersion", "myValidToolsVersion's path"));

            MockLogger logger = new MockLogger();

            Project project = ObjectModelHelpers.CreateInMemoryProject(e, ObjectModelHelpers.CleanupFileContents(@"
                <Project DefaultTargets=`Build` xmlns=`msbuildnamespace`>
                    <UsingTask TaskName='Message' AssemblyName='Microsoft.Build.Tasks.Core, Version=msbuildassemblyversion, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a'/>    
                    <Target Name=`Build`>
                        <Message Text=`##$(MSBuildToolsVersion)##`/>
                    </Target>
                </Project>"), logger);
            project.DefaultToolsVersion = "myValidToolsVersion";

            project.Build();

            logger.AssertLogContains("##myValidToolsVersion##");
        }

        public void ChangingToolsVersionAttributeToUnrecognizedValue()
        {
            Engine e = new Engine("www.msbuild.org");
            e.AddToolset(new Toolset("myValidToolsVersion", "myValidToolsVersion's path"));

            Project project = ObjectModelHelpers.CreateInMemoryProject(e, @"
                <Project ToolsVersion=`myValidToolsVersion` DefaultTargets=`Build` xmlns=`msbuildnamespace`>
                    <Target Name=`Build`/>
                </Project>", null);

            Assertion.AssertEquals("We should have toolsVersion equal to myValidToolsVersion",
                "myValidToolsVersion", project.DefaultToolsVersion);

            // Build should succeed at this point
            Assertion.Assert(project.Build());

            project.DefaultToolsVersion = "UnknownToolsVersion";

            // When an unknown toolsversion is used, MSBuild treats it as TV4.0.
            Assertion.AssertEquals("Because a bogus ToolsVersion was set, the ToolsVersion gets treated as v4.0", "4.0", project.ToolsVersion);

            Assertion.AssertEquals("ToolsVersionAttribute has the new value", "4.0", project.DefaultToolsVersion);

            // It's a valid ToolsVersion, so the build should succeed
            Assertion.Assert(project.Build());
        }

        public void ChangingToolsVersion()
        {
            Engine e = new Engine("www.msbuild.org");
            e.AddToolset(new Toolset("myValidToolsVersion", "myValidToolsVersion's path"));

            Project project = ObjectModelHelpers.CreateInMemoryProject(e, @"
                <Project DefaultTargets=`Build` xmlns=`msbuildnamespace`>
                    <Target Name=`Build`/>
                </Project>", null);

            Assertion.AssertEquals("Nonexistent ToolsVersion should evaluate to the default version",
                Constants.defaultToolsVersion, project.ToolsVersion);

            Assertion.AssertEquals("BinPath is the MSBuildBinPath for the default version",
                "www.msbuild.org", project.EvaluatedProperties[ReservedPropertyNames.binPath].FinalValue);

            Assertion.AssertEquals("BinPath is the MSBuildToolsPath for the default version",
                "www.msbuild.org", project.EvaluatedProperties[ReservedPropertyNames.toolsPath].FinalValue);

            project.DefaultToolsVersion = "myValidToolsVersion";

            Assertion.AssertEquals("ToolsVersion should have been changed by the project attribute (because it wasn't overridden)",
                "myValidToolsVersion", project.ToolsVersion);

            Assertion.AssertEquals("ToolsVersionAttribute should have been picked up from the project attribute",
                "myValidToolsVersion", project.DefaultToolsVersion);

            Assertion.AssertEquals("OverridingToolsVersion should be false",
                false, project.OverridingToolsVersion);

            Assertion.AssertEquals("BinPath is the MSBuildBinPath for the default version",
                "myValidToolsVersion's path", project.EvaluatedProperties[ReservedPropertyNames.binPath].FinalValue);

            Assertion.AssertEquals("BinPath is the MSBuildToolsPath for the default version",
                "myValidToolsVersion's path", project.EvaluatedProperties[ReservedPropertyNames.toolsPath].FinalValue);
        }

        public void VersionBasedMSBuildBinPathExplicit()
        {
            Engine e = new Engine("www.msbuild.org");
            e.AddToolset(new Toolset("myValidToolsVersion", "myValidToolsVersion's path"));

            Project project = ObjectModelHelpers.CreateInMemoryProject(e, @"
                <Project ToolsVersion=`myValidToolsVersion` DefaultTargets=`Build` xmlns=`msbuildnamespace`>
                    <Target Name=`Build`/>
                </Project>", null);

            Assertion.AssertEquals("ToolsVersion should have been picked up from the project attribute", 
                "myValidToolsVersion", project.ToolsVersion);

            Assertion.AssertEquals("ToolsVersionAttribute should have been picked up from the project attribute",
                "myValidToolsVersion", project.DefaultToolsVersion);

            Assertion.AssertEquals("BinPath is the MSBuildBinPath for the default version",
                "myValidToolsVersion's path", project.EvaluatedProperties[ReservedPropertyNames.binPath].FinalValue);

            Assertion.AssertEquals("BinPath is the MSBuildToolsPath for the default version",
                "myValidToolsVersion's path", project.EvaluatedProperties[ReservedPropertyNames.toolsPath].FinalValue);
        }

        public void ToolsVersionRespectedWhenBuildingASolution()
        {
            ObjectModelHelpers.DeleteTempProjectDirectory();

            Engine engine = new Engine(Path.GetDirectoryName(new Uri(Assembly.GetExecutingAssembly().EscapedCodeBase).LocalPath));

            // We've intentionally assigned the correct BinPath value to the tools version '3.5' since later
            // we will request the engine build the solution with that tools version, and the engine will
            // need to locate the default tasks. If the override we're going to specify isn't in fact applied,
            // the engine will try to load the tasks from the bogus toolpath, and that will fail the solution build,
            // so this test will fail.
            engine.AddToolset(new Toolset("3.5", engine.BinPath));
            engine.AddToolset(new Toolset("2.0", "anotherToolsPath"));

            string solutionFileContents =
                @"
                Microsoft Visual Studio Solution File, Format Version 9.00
                # Visual Studio 2005
                Global
                    GlobalSection(SolutionConfigurationPlatforms) = preSolution
                        Debug|AnyCPU = Debug|AnyCPU
                        Release|AnyCPU = Release|AnyCPU
                    EndGlobalSection
                    GlobalSection(SolutionProperties) = preSolution
                        HideSolutionNode = FALSE
                    EndGlobalSection
                EndGlobal
                ";

            string solutionFullPath = ObjectModelHelpers.CreateFileInTempProjectDirectory("ConsoleApplication1.sln", solutionFileContents);

            // The parent project doesn't declare its ToolsVersion, and its ToolsVersion is not overridden
            string parentProjectContent = @"<Project xmlns='http://schemas.microsoft.com/developer/msbuild/2003' />";
            Project parentProject =
                ObjectModelHelpers.CreateInMemoryProject(engine, parentProjectContent, null);

            EngineProxy engineProxy = CreateEngineProxyWithDummyTaskEngine(engine, parentProject);
            bool success = engineProxy.BuildProjectFile
                (solutionFullPath, null, null, null, "3.5");

            Assertion.Assert("Expected a successful build!", success);
        }

        private ITaskItem ToolsVersionTestHelper(string parentProjectToolsVersionInProject,
                                                 string parentProjectToolsVersionOverride,
                                                 string toolsVersionPassedToEngineProxy)
        {
            Engine engine = new Engine(Path.GetDirectoryName(new Uri(Assembly.GetExecutingAssembly().EscapedCodeBase).LocalPath));
            engine.AddToolset(new Toolset("44.0", "someToolsPath"));
            engine.AddToolset(new Toolset("55.0", "anotherToolsPath"));
            engine.AddToolset(new Toolset("66.0", "yetanotherToolsPath"));

            // The child project declares its ToolsVersion
            string childProjectFullPath = ObjectModelHelpers.CreateFileInTempProjectDirectory("child.proj", @"
                      <Project ToolsVersion='44.0' xmlns='http://schemas.microsoft.com/developer/msbuild/2003'>
                          <ItemGroup>
                              <ToolsVersionItem Include='$(MSBuildToolsVersion)'>
                                  <ToolsPath>$(MSBuildToolsPath)</ToolsPath>
                                  <BinPath>$(MSBuildBinPath)</BinPath>
                              </ToolsVersionItem>
                          </ItemGroup>
                          <Target Name='Build' Outputs='@(ToolsVersionItem)' />
                      </Project>
                      ");

            // The parent project doesn't declare its ToolsVersion, and its ToolsVersion is not overridden
            string parentProjectContent = @"<Project xmlns='http://schemas.microsoft.com/developer/msbuild/2003'";
            if (parentProjectToolsVersionInProject != null)
            {
                parentProjectContent += String.Format(" ToolsVersion=\"{0}\"", parentProjectToolsVersionInProject);
            }
            parentProjectContent += "/>";

            Project parentProject =
                ObjectModelHelpers.CreateInMemoryProject(engine, parentProjectContent, null);

            if (parentProjectToolsVersionOverride != null)
            {
                parentProject.ToolsVersion = parentProjectToolsVersionOverride;
            }

            Dictionary<string, ITaskItem[]> targetOutputs =
                new Dictionary<string, ITaskItem[]>(StringComparer.OrdinalIgnoreCase);

            EngineProxy engineProxy = CreateEngineProxyWithDummyTaskEngine(engine, parentProject);
            bool success = engineProxy.BuildProjectFile
                (childProjectFullPath, null, null, targetOutputs, toolsVersionPassedToEngineProxy);

            ITaskItem toolsVersionItem = targetOutputs["Build"][0];

            Assertion.Assert("Expected a successful build!", success);

            return toolsVersionItem;
        }