C# IBuildEngine类代码示例

 public static void deleteTestDirectory(IBuildEngine buildEngine)
 {
     RemoveDir removeDirTask = new RemoveDir();
     removeDirTask.BuildEngine = buildEngine;
     removeDirTask.Directories = StringArrayToItemArray(new string[] { TestDirectory });
     removeDirTask.Execute();
 }

		public RemoteBuildEngine (Process proc, IBuildEngine engine)
		{
			this.proc = proc;
			this.engine = engine;

			Interlocked.Increment (ref count);
		}

        public bool Initialize(string taskName, IDictionary<string, TaskPropertyInfo> parameterGroup, string taskBody, IBuildEngine taskFactoryLoggingHost)
        {
            var projectFileDirectory = Path.GetDirectoryName(taskFactoryLoggingHost.ProjectFileOfTaskNode);
            var thisAssemblyDirectory = Path.GetDirectoryName(this.GetType().Assembly.Location);
            _assemblyResolver.BeginResolving(thisAssemblyDirectory, projectFileDirectory);

            try
            {
                var engine = Ruby.CreateEngine();
                _taskScriptScope = engine.CreateScope();
                _taskScriptScope.ExecuteEmbeddedScript(RubyTaskScript);
                var rubyTaskBody = TaskBodyParser.Parse(taskBody);
                var scriptFile = projectFileDirectory.CombinePath(rubyTaskBody.Script).ToFullPath();
                var scriptContents = _fileSystem.GetFileContent(scriptFile);
                _taskScriptScope.Execute(scriptContents);
                _taskClass = engine.Runtime.Globals.GetVariable(taskName);
            }
            catch(Exception)
            {
                _assemblyResolver.Dispose();
                throw;
            }

            return true;
        }

 	public void Setup()
 	{
 		_mocks = new MockRepository();
     _task = _mocks.DynamicMock<ITask>();
     _engine = _mocks.DynamicMock<IBuildEngine>();
     _logger = new MsBuildLogger(new TaskLoggingHelper(_task));
 	}

        private static bool CheckForError(IBuildEngine engine, string error, bool exists)
        {
            var buildEngine = engine as BuildEngineStub;
            if (buildEngine == null)
            {
                Assert.Fail("Not a BuildEngineStub, cannot test with this");
            }
            if (buildEngine.Errors != null && buildEngine.Errors.Count > 0)
            {
                foreach (var anError in buildEngine.Errors)
                {
                    if (anError.StartsWith(error))
                    {
                        return exists;
                    }
                }
            }

            if (!exists) 
            {
                return true;
            }

            var sb = new StringBuilder();
            sb.AppendLine(error + " not found.  Actual errors: ");
            foreach (var anError in buildEngine.Errors)
            {
                sb.AppendLine(anError);
            }
            Assert.Fail(sb.ToString());

            // ReSharper disable HeuristicUnreachableCode
            return !exists;
            // ReSharper restore HeuristicUnreachableCode
        }

 /// <summary>
 /// Public constructor which can be used by task factories to assist them in logging messages.
 /// </summary>
 /// <param name="taskInstance">task containing an instance of this class</param>
 public TaskLoggingHelper(IBuildEngine buildEngine, string taskName)
 {
     ErrorUtilities.VerifyThrowArgumentNull(buildEngine, "buildEngine");
     ErrorUtilities.VerifyThrowArgumentLength(taskName, "taskName");
     _taskName = taskName;
     _buildEngine = buildEngine;
 }

 internal TlbReference(TaskLoggingHelper taskLoggingHelper, IComReferenceResolver resolverCallback, IEnumerable<string> referenceFiles, ComReferenceInfo referenceInfo, string itemName, string outputDirectory, bool hasTemporaryWrapper, bool delaySign, string keyFile, string keyContainer, bool noClassMembers, string targetProcessorArchitecture, bool includeTypeLibVersionInName, bool executeAsTool, string sdkToolsPath, IBuildEngine buildEngine, string[] environmentVariables) : base(taskLoggingHelper, resolverCallback, referenceInfo, itemName, outputDirectory, delaySign, keyFile, keyContainer, includeTypeLibVersionInName, executeAsTool, sdkToolsPath, buildEngine, environmentVariables)
 {
     this.hasTemporaryWrapper = hasTemporaryWrapper;
     this.noClassMembers = noClassMembers;
     this.targetProcessorArchitecture = targetProcessorArchitecture;
     this.referenceFiles = referenceFiles;
 }

		public void Setup()
		{
			task = MockRepository.GenerateStub<ITask>();
			engine = MockRepository.GenerateMock<IBuildEngine>();
			logger = new MsBuildLogger(new TaskLoggingHelper(task));

			task.Expect(t => t.BuildEngine).Return(engine).Repeat.Any();
		}

        /// <summary>
        /// Initialize the factory.
        /// </summary>
        public bool Initialize(string taskName, IDictionary<string, TaskPropertyInfo> parameterGroup, string taskBody, IBuildEngine taskFactoryLoggingHost)
        {
            if (!String.Equals(taskName, TaskType.Name, StringComparison.OrdinalIgnoreCase))
            {
                ErrorUtilities.ThrowInternalError("Unexpected task name {0}.  Expected {1}", taskName, TaskType.Name);
            }

            return true;
        }

        protected void CheckoutProject(IBuildEngine engine, string path)
        {
            SvnCheckout task = new SvnCheckout();
            task.RepositoryPath = path;
            task.RepositoryUrl = RepositoryURL;
            task.BuildEngine = engine;

            task.Execute();
        }

        private void AssertFilesSubmitted(IBuildEngine engine)
        {
            string path = string.Format(RepositoryPathTemplate, DateTime.Now.Ticks);
            CheckoutProject(engine, path);

            string filePath = Path.Combine(path, "trunk\\DocumentA.txt");

            string contents = File.ReadAllText(filePath);
            Assert.That(contents, Is.EqualTo(ModifyString));
        }

 private SpyLogger(IBuildEngine buildEngine, string taskName)
     : base(buildEngine, taskName)
 {
     buildEngine.WhenAny(e => e.LogMessageEvent(null))
                .Do<BuildMessageEventArgs>(Log);
     buildEngine.WhenAny(e => e.LogWarningEvent(null))
                .Do<BuildWarningEventArgs>(Log);
     buildEngine.WhenAny(e => e.LogErrorEvent(null))
                .Do<BuildErrorEventArgs>(Log);
 }

 /// <summary>
 /// Construct.
 /// </summary>
 public AssemblyFoldersFromConfigResolver(string searchPathElement, GetAssemblyName getAssemblyName,
     FileExists fileExists, GetAssemblyRuntimeVersion getRuntimeVersion, Version targetedRuntimeVesion,
     ProcessorArchitecture targetProcessorArchitecture, bool compareProcessorArchitecture,
     IBuildEngine buildEngine, TaskLoggingHelper log)
     : base(
         searchPathElement, getAssemblyName, fileExists, getRuntimeVersion, targetedRuntimeVesion,
         targetProcessorArchitecture, compareProcessorArchitecture)
 {
     _buildEngine = buildEngine as IBuildEngine4;
     _taskLogger = log;
 }

    private SpyLogger(IBuildEngine buildEngine, string taskName, bool includeSourceInformation)
        : base(buildEngine, taskName)
    {
        this.includeSourceInformation = includeSourceInformation;

        buildEngine.WhenAny(e => e.LogMessageEvent(null))
                   .Do<BuildMessageEventArgs>(Log);
        buildEngine.WhenAny(e => e.LogWarningEvent(null))
                   .Do<BuildWarningEventArgs>(Log);
        buildEngine.WhenAny(e => e.LogErrorEvent(null))
                   .Do<BuildErrorEventArgs>(Log);
    }

 internal AxTlbBaseReference(TaskLoggingHelper taskLoggingHelper, IComReferenceResolver resolverCallback, ComReferenceInfo referenceInfo, string itemName, string outputDirectory, bool delaySign, string keyFile, string keyContainer, bool includeTypeLibVersionInName, bool executeAsTool, string toolPath, IBuildEngine buildEngine, string[] environmentVariables) : base(taskLoggingHelper, referenceInfo, itemName)
 {
     this.resolverCallback = resolverCallback;
     this.outputDirectory = outputDirectory;
     this.includeTypeLibVersionInName = includeTypeLibVersionInName;
     this.BuildEngine = buildEngine;
     this.EnvironmentVariables = environmentVariables;
     this.DelaySign = delaySign;
     this.ExecuteAsTool = executeAsTool;
     this.KeyFile = keyFile;
     this.KeyContainer = keyContainer;
     this.ToolPath = toolPath;
 }