C# Framework.TargetStartedEventArgs類代碼示例

 void eventSource_TargetStarted(object sender, TargetStartedEventArgs e)
 {
     if (Verbosity == LoggerVerbosity.Detailed)
     {
         Console.WriteLine("Target Started: " + e.TargetName);
     }
 }

        public void VerifyEventType()
        {
            BuildFinishedEventArgs buildFinished = new BuildFinishedEventArgs("Message", "Keyword", true);
            BuildStartedEventArgs buildStarted = new BuildStartedEventArgs("Message", "Help");
            BuildMessageEventArgs lowMessage = new BuildMessageEventArgs("Message", "help", "sender", MessageImportance.Low);
            TaskStartedEventArgs taskStarted = new TaskStartedEventArgs("message", "help", "projectFile", "taskFile", "taskName");
            TaskFinishedEventArgs taskFinished = new TaskFinishedEventArgs("message", "help", "projectFile", "taskFile", "taskName", true);
            TaskCommandLineEventArgs commandLine = new TaskCommandLineEventArgs("commandLine", "taskName", MessageImportance.Low);
            BuildWarningEventArgs warning = new BuildWarningEventArgs("SubCategoryForSchemaValidationErrors", "MSB4000", "file", 1, 2, 3, 4, "message", "help", "sender");
            BuildErrorEventArgs error = new BuildErrorEventArgs("SubCategoryForSchemaValidationErrors", "MSB4000", "file", 1, 2, 3, 4, "message", "help", "sender");
            TargetStartedEventArgs targetStarted = new TargetStartedEventArgs("message", "help", "targetName", "ProjectFile", "targetFile");
            TargetFinishedEventArgs targetFinished = new TargetFinishedEventArgs("message", "help", "targetName", "ProjectFile", "targetFile", true);
            ProjectStartedEventArgs projectStarted = new ProjectStartedEventArgs(-1, "message", "help", "ProjectFile", "targetNames", null, null, null);
            ProjectFinishedEventArgs projectFinished = new ProjectFinishedEventArgs("message", "help", "ProjectFile", true);
            ExternalProjectStartedEventArgs externalStartedEvent = new ExternalProjectStartedEventArgs("message", "help", "senderName", "projectFile", "targetNames");

            VerifyLoggingPacket(buildFinished, LoggingEventType.BuildFinishedEvent);
            VerifyLoggingPacket(buildStarted, LoggingEventType.BuildStartedEvent);
            VerifyLoggingPacket(lowMessage, LoggingEventType.BuildMessageEvent);
            VerifyLoggingPacket(taskStarted, LoggingEventType.TaskStartedEvent);
            VerifyLoggingPacket(taskFinished, LoggingEventType.TaskFinishedEvent);
            VerifyLoggingPacket(commandLine, LoggingEventType.TaskCommandLineEvent);
            VerifyLoggingPacket(warning, LoggingEventType.BuildWarningEvent);
            VerifyLoggingPacket(error, LoggingEventType.BuildErrorEvent);
            VerifyLoggingPacket(targetStarted, LoggingEventType.TargetStartedEvent);
            VerifyLoggingPacket(targetFinished, LoggingEventType.TargetFinishedEvent);
            VerifyLoggingPacket(projectStarted, LoggingEventType.ProjectStartedEvent);
            VerifyLoggingPacket(projectFinished, LoggingEventType.ProjectFinishedEvent);
            VerifyLoggingPacket(externalStartedEvent, LoggingEventType.CustomEvent);
        }

 public void EventArgsCtors()
 {
     TargetStartedEventArgs targetStartedEvent = new TargetStartedEventArgs2();
     targetStartedEvent = new TargetStartedEventArgs("Message", "HelpKeyword", "TargetName", "ProjectFile", "TargetFile");
     targetStartedEvent = new TargetStartedEventArgs("Message", "HelpKeyword", "TargetName", "ProjectFile", "TargetFile", "ParentTarget", DateTime.Now);
     targetStartedEvent = new TargetStartedEventArgs(null, null, null, null, null);
     targetStartedEvent = new TargetStartedEventArgs(null, null, null, null, null, null, DateTime.Now);
 }

 public void eventSource_TargetStarted(object sender, TargetStartedEventArgs e)
 {
     if(e.TargetName.Equals("IceBuilder_Compile") ||IsVerbosityAtLeast(LoggerVerbosity.Detailed))
     {
         WriteMessage(String.Format("{0}:", e.TargetName));
     }
     Indent += IndentLevel;
 }

        /// <summary>
        /// Adds a new target node to the project.
        /// </summary>
        /// <param name="targetStartedEventArgs">The <see cref="TargetStartedEventArgs"/> instance containing the event data.</param>
        public void AddTarget(TargetStartedEventArgs targetStartedEventArgs)
        {
            var target = GetOrAddTargetByName(targetStartedEventArgs.TargetName, targetStartedEventArgs);

            if (!string.IsNullOrEmpty(targetStartedEventArgs.ParentTarget))
            {
                var parentTarget = GetOrAddTargetByName(targetStartedEventArgs.ParentTarget);
                parentTarget.AddChildTarget(target);
            }
            else
            {
                AddChildNode(target);
            }
        }

		public void AssignmentTest ()
		{
			TargetStartedEventArgs tsea;
			string message = "message";
			string helpKeyword = "helpKeyword";
			string targetName = "targetName";
			string projectFile = "projectFile";
			string targetFile = "targetFile";
			
			tsea = new TargetStartedEventArgs (message, helpKeyword, targetName, projectFile, targetFile);
			
			Assert.AreEqual (message, tsea.Message, "Message");
			Assert.AreEqual (helpKeyword, tsea.HelpKeyword, "HelpKeyword");
			Assert.AreEqual (targetName, tsea.TargetName, "TargetName");
			Assert.AreEqual (projectFile, tsea.ProjectFile, "ProjectFile");
			Assert.AreEqual (targetFile, tsea.TargetFile, "TargetFile");
		}

		void eventSource_TargetStarted(object sender, TargetStartedEventArgs e)
		{
			if (_output == null || String.IsNullOrEmpty(e.ProjectFile) || e.ProjectFile == _current) 
				return;

			CloseTarget();

			_current = e.ProjectFile;
			_output.WriteStartElement("project");

			string filename = e.ProjectFile;
			_output.WriteAttributeString("file", Path.GetFileName(filename));
			_output.WriteAttributeString("location", Path.GetDirectoryName(filename));
			
			if(!String.IsNullOrEmpty(e.TargetFile) )
				_output.WriteAttributeString("target", e.TargetFile);
		}

 public BuildMessage(TargetStartedEventArgs args)
 {
     EventType = args.GetType().Name.Replace("EventArgs", "");
     Message = args.Message;
     ParentTarget = args.ParentTarget;
     ProjectFile = args.ProjectFile;
     TargetFile = args.TargetFile;
     TargetName = args.TargetName;
     HelpKeyword = args.HelpKeyword;
     SenderName = args.SenderName;
     Timestamp = args.Timestamp;
     ThreadId = args.ThreadId;
 }

        /// <summary>
        /// Compare this build event context with another object to determine 
        /// equality. This means the values inside the object are identical.
        /// </summary>
        /// <param name="obj">Object to compare to this object</param>
        /// <returns>True if the object values are identical, false if they are not identical</returns>
        public static bool IsEquivalent(TargetStartedEventArgs args, TargetStartedEventArgs other)
        {
            if (!String.Equals(args.ProjectFile, other.ProjectFile, StringComparison.OrdinalIgnoreCase))
            {
                return false;
            }

            if (!String.Equals(args.TargetFile, other.TargetFile, StringComparison.OrdinalIgnoreCase))
            {
                return false;
            }

            if (!String.Equals(args.TargetName, other.TargetName, StringComparison.OrdinalIgnoreCase))
            {
                return false;
            }

            if (!String.Equals(args.ParentTarget, other.ParentTarget, StringComparison.OrdinalIgnoreCase))
            {
                return false;
            }
            return ((BuildEventArgs)args).IsEquivalent(other);
        }

 private void eventSource_TargetStarted(object sender, TargetStartedEventArgs e)
 {
     if (stop) {
         return;
     }
     Execute(new BuildMessage(e));
     if (stop) {
         KillThyself();
     }
 }

 /// <summary>
 /// Try to update the target data given a target started event. This is useful if the project
 /// was created (e.g. as a parent) before we saw the started event.
 /// </summary>
 /// <remarks>Does nothing if the data has already been set or the new data is null.</remarks>
 /// <param name="e">The <see cref="TargetStartedEventArgs"/> instance containing the event data.</param>
 public void TryUpdate(TargetStartedEventArgs e)
 {
     if (Id < 0 && e != null)
     {
         // = e.Timestamp;
         Id = e.BuildEventContext.TargetId;
     }
 }

		void LogTargetStarted (Target target)
		{
			TargetStartedEventArgs tsea;
			string projectFile = project.FullFileName;
			tsea = new TargetStartedEventArgs (String.Format ("Target {0} started.", target.Name), null,
					target.Name, projectFile, target.TargetFile);
			target.Engine.EventSource.FireTargetStarted (this, tsea);
		}

		private void eventSource_TargetStartedHandler(object sender, TargetStartedEventArgs e)
		{
            LogStageStarted(XmlLoggerElements.Target, e.TargetName, "", e.Timestamp);
		}

 /// <summary>
 /// This is the delegate for TargetStartedHandler events.
 /// </summary>
 private void TargetStartedHandler(object sender, TargetStartedEventArgs buildEvent)
 {
     if (LogAtImportance(MessageImportance.Normal))
     {
         LogEvent(sender, buildEvent);
     }
     ++this.currentIndent;
 }

        protected void onTargetStarted(object sender, TargetStartedEventArgs e)
        {
            if(!projects.ContainsKey(e.BuildEventContext.ProjectInstanceId)) {
                return;
            }

            switch(e.TargetName) {
                case "PreBuildEvent": {
                    library.Event.onProjectPre(projects[e.BuildEventContext.ProjectInstanceId].Name);
                    break;
                }
                case "PostBuildEvent": {
                    Project p = projects[e.BuildEventContext.ProjectInstanceId];
                    library.Event.onProjectPost(p.Name, p.HasErrors ? 0 : 1);
                    break;
                }
            }
        }