public void BuildFinished(object sender, BuildEventArgs e)
 {
     if (e.Exception == null && e.Project == Project)
     {
         GenerateSolutionFile(Project);
     }
 }

        public void TaskFinished(object sender, BuildEventArgs e)
        {
            var task = (CscTask)e.Task;
            var generator = (GenerateMsBuildTask)sender;
            var projectFileName = String.Format(
                    "{0}{1}{2}.csproj",
                    task.Sources.BaseDirectory.FullName,
                    Path.DirectorySeparatorChar,
                    Path.GetFileNameWithoutExtension(task.OutputFile.Name));

            ProjectRootElement project = null;
            if (!File.Exists(projectFileName))
                project = ProjectRootElement.Create(projectFileName);
            else
                project = ProjectRootElement.Open(projectFileName);
            var projectManipulator = new MB.Project(project);

            project.DefaultTargets = "Build";
            SetKnownProperties(project, task);
            GenerateReferences(project, projectManipulator, task, generator);
            GenerateCompileIncludes(project, projectManipulator, task);
            project.EnsureImportExists("$(MSBuildToolsPath)\\Microsoft.CSharp.targets");

            generator.RegisterProjectInSolution(project);
            project.Save();
        }

        private static void OnMessageLogged(object sender, BuildEventArgs e)
        {
            if (Loggers.IsEmpty)
            {
                // tiny race.
                ((Project)sender).MessageLogged -= OnMessageLogged;
                return;
            }

            var msg = FormatMessage(e);
            
            if (msg == null)
                return;
            
            foreach (var log in Loggers)
            {
                try
                {
                    log.Value.WriteLine(msg);
                    log.Value.Flush();
                }
                catch (Exception)
                {
                }
                
            }
        }

 public void TaskFinished(object sender, BuildEventArgs e)
 {
     // resources embedded in csc tasks are already handled
     if (typeof(CscTask) != e.Task.Parent.GetType())
     {
         throw new NotImplementedException();
     }
 }

 public LogEvent(String sourceName, Object sender, BuildEventArgs args, LogEventType eventType)
 {
     _sourceName = sourceName;
     _sender = sender;
     _args = args;
     _eventType = eventType;
     _exception = null;
 }

        public void BuildStarted(Object sender, BuildEventArgs be)
        {
            autoTrace = be.Project.Properties.Contains("trace.ant.disableAutoTrace") && be.Project.Properties["trace.ant.disableAutoTrace"].Equals("true", StringComparison.InvariantCultureIgnoreCase);

            TraceManager.BeginTrace();
            if (autoTrace)
                TraceManager.Trace.BeginEntry(String.Format("Start build '{0}'.", be.Project.ProjectName), severityType.INFO);
        }

 public void TaskFinished(object sender, BuildEventArgs e)
 {
     if (e.Exception == null && !string.IsNullOrEmpty(e.Task.Name))
     {
         if (taskTranslators.ContainsKey(e.Task.Name))
         {
             taskTranslators[e.Task.Name].TaskFinished(this, e);
         }
     }
 }

        public void TaskStarted(object sender, BuildEventArgs e) {
            _taskStartedFired = true;

            if (e.Task != null) {
                if (_executedTasks.ContainsKey(e.Task.Name)) {
                    _executedTasks[e.Task.Name] = ((int) _executedTasks[e.Task.Name]) + 1;
                } else {
                    _executedTasks.Add(e.Task.Name, 1);
                }
            }
        }

        public void TargetStarted(object sender, BuildEventArgs e) {
            _targetStartedFired = true;

            if (e.Target != null) {
                if (_executedTargets.ContainsKey(e.Target.Name)) {
                    _executedTargets[e.Target.Name] = ((int) _executedTargets[e.Target.Name]) + 1;
                } else {
                    _executedTargets.Add(e.Target.Name, 1);
                }
                _targetStartTimes[e.Target.Name] = DateTime.UtcNow;
            }
        }

        public void BuildStarted(object sender, BuildEventArgs e)
        {
            string host = e.Project.Properties[PROP_HOST];

            if (host == null) {
                host = DEFAULT_HOST;
            }

            string port = e.Project.Properties[PROP_PORT];

            if (port == null) {
                port = DEFAULT_PORT;
            }

            int portInt = int.Parse(port);

            reporter = new UdpBuildReporter(host, portInt);

            report("BUILD_STARTED", e);
        }

        public void ParseMessage(BuildEventArgs e, out MessagePriority priority, out string file, out int lineNumber, out string code, out string message)
        {
            switch(e.MessageLevel) {
                case Level.Warning: priority = MessagePriority.WARNING; break;
                case Level.Error: priority = MessagePriority.ERROR; break;
                default: priority = MessagePriority.INFO; break;
            }

            file = null;
            code = null;
            lineNumber = 0;
            message = e.Message;

            Match match = messageRegex.Match(message);
            if (match.Success)
            {
                if (match.Groups["category"].Value == "warning")
                {
                    priority = MessagePriority.WARNING;
                }
                else
                {
                    priority = MessagePriority.ERROR;
                }

                file = match.Groups["file"].Value;

                string lineString = match.Groups["line"].Value;
                if (lineString != "")
                {
                    lineNumber = int.Parse(lineString);
                }

                code = match.Groups["code"].Value;
                message = match.Groups["message"].Value;
            }
        }

        /// <summary>
        /// Outputs an indented message to the build log if its priority is 
        /// greather than or equal to the <see cref="Threshold" /> of the 
        /// logger.
        /// </summary>
        /// <param name="e">The event to output.</param>
        private void OutputMessage(BuildEventArgs e)
        {
            int indentationLength = 0;

            if (e.Project != null) {
                indentationLength = e.Project.IndentationLevel * e.Project.IndentationSize;
            }

            OutputMessage(e, indentationLength);
        }

 private static BuildEventArgs CreateBuildEvent(Level messageLevel, string message)
 {
     BuildEventArgs buildEvent = new BuildEventArgs();
     buildEvent.MessageLevel = messageLevel;
     buildEvent.Message = message;
     return buildEvent;
 }

 /// <summary>
 /// Signals that a task has started.
 /// </summary>
 /// <param name="sender">The source of the event.</param>
 /// <param name="e">A <see cref="BuildEventArgs" /> object that contains the event data.</param>
 public virtual void TaskStarted(object sender, BuildEventArgs e)
 {
 }

 /// <summary>
 /// Signals that a task has finished.
 /// </summary>
 /// <param name="sender">The source of the event.</param>
 /// <param name="e">A <see cref="BuildEventArgs" /> object that contains the event data.</param>
 /// <remarks>
 /// This event will still be fired if an error occurred during the build.
 /// </remarks>
 public virtual void TaskFinished(object sender, BuildEventArgs e)
 {
 }

 /// <summary>
 /// Signals that a task has finished.
 /// </summary>
 /// <param name="sender">The source of the event.</param>
 /// <param name="e">A <see cref="BuildEventArgs" /> object that contains the event data.</param>
 /// <remarks>
 /// This event will still be fired if an error occurred during the build.
 /// </remarks>
 public void TaskFinished(object sender, BuildEventArgs e)
 {
     lock (_xmlWriter) {
         // output total target duration
         WriteDuration();
         // close task element
         _xmlWriter.WriteEndElement();
         _xmlWriter.Flush();
     }
 }

 /// <summary>
 /// Signals that a build has started.
 /// </summary>
 /// <param name="sender">The source of the event.</param>
 /// <param name="e">A <see cref="BuildEventArgs" /> object that contains the event data.</param>
 /// <remarks>
 /// This event is fired before any targets have started.
 /// </remarks>
 public void BuildStarted(object sender, BuildEventArgs e)
 {
     lock (_xmlWriter) {
         _stopWatchStack.PushStart();
         _xmlWriter.WriteStartElement(Elements.BuildResults);
         _xmlWriter.WriteAttributeString(Attributes.Project, e.Project.ProjectName);
     }
     // add an item to the project stack
     _projectStack.Push(null);
 }

 public void MessageLogged(object sender, BuildEventArgs e)
 {
     Enqueue(new LogEvent(_src, sender, e, LogEventType.MessageLogged));
 }

 public void TaskFinished(object sender, BuildEventArgs e)
 {
     Enqueue(new LogEvent(_src, sender, e, LogEventType.TaskFinished));
 }

 public void TargetStarted(object sender, BuildEventArgs e)
 {
     if (e.Target != null && e.Target.Name == _hideTarget) {
         return;
     }
     Enqueue(new LogEvent(_src, sender, e, LogEventType.TargetStarted));
 }