private BuildEventArgs ReadProjectStartedEventArgs()
{
var fields = ReadBuildEventArgsFields();
BuildEventContext parentContext = null;
if (ReadBoolean())
{
parentContext = ReadBuildEventContext();
}
var projectFile = ReadOptionalString();
var projectId = ReadInt32();
var targetNames = ReadString();
var toolsVersion = ReadOptionalString();
var propertyList = ReadPropertyList();
var itemList = ReadItems();
var e = new ProjectStartedEventArgs(
projectId,
fields.Message,
fields.HelpKeyword,
projectFile,
targetNames,
propertyList,
itemList,
parentContext,
null,
toolsVersion);
SetCommonFields(e, fields);
return(e);
}
void eventSource_ProjectStarted(object sender, ProjectStartedEventArgs e)
{
// ProjectStartedEventArgs adds ProjectFile, TargetNames
// Just the regular message string is good enough here, so just display that.
WriteLine(String.Empty, e);
indent++;
}
/// <summary>
/// Raises a "project build started" event to all registered loggers.
/// </summary>
/// <owner>SumedhK</owner>
/// <param name="sender"></param>
/// <param name="e"></param>
internal void RaiseProjectStartedEvent(object sender, ProjectStartedEventArgs e)
{
if (ProjectStarted != null)
{
try
{
ProjectStarted(sender, e);
}
catch (LoggerException)
{
// if a logger has failed politely, abort immediately
// first unregister all loggers, since other loggers may receive remaining events in unexpected orderings
// if a fellow logger is throwing in an event handler.
this.UnregisterAllLoggers();
throw;
}
catch (Exception exception)
{
// first unregister all loggers, since other loggers may receive remaining events in unexpected orderings
// if a fellow logger is throwing in an event handler.
this.UnregisterAllLoggers();
InternalLoggerException.Throw(exception, e, "FatalErrorWhileLogging", false);
}
}
RaiseStatusEvent(sender, e);
}
/// <summary>
/// Each time we encounter a new project, we want to load it, and grab the task registration information:
/// - For the default tasks for its ToolsVersion
/// - For any tasks registered in the project file or its imports
/// </summary>
private void HandleProjectStarted(object sender, ProjectStartedEventArgs e)
{
if (!ShouldIgnoreProject(e.ProjectFile))
{
try
{
// Load up a private copy of the project.
Project p = _privateCollection.LoadProject(e.ProjectFile, e.GlobalProperties, e.ToolsVersion);
// Save off task registration information for this project
GatherAndEvaluateDefaultTasksForToolsVersion(p.ToolsVersion, p);
GatherAndEvaluateTasksForProject(p, e.BuildEventContext.ProjectContextId);
// Keep a pointer to the ToolsVersion so that we'll be able to reference it
// later. Index off ContextId since it appears to be globally unique within
// the build.
_toolsVersionsByProjectContextId[e.BuildEventContext.ProjectContextId] = p.ToolsVersion;
// unload now that we're done with it.
_privateCollection.UnloadProject(p);
}
catch (Exception ex)
{
throw new LoggerException(String.Format(CultureInfo.CurrentCulture, "Failed to load and read task registration information from project '{0}'. {1}", e.ProjectFile, ex.Message));
}
}
}
/// <summary>
/// This is the delegate for ProjectStartedHandler events.
/// </summary>
private void ProjectStartedHandler(object sender, ProjectStartedEventArgs buildEvent)
{
if (LogAtImportance(MessageImportance.Low))
{
LogEvent(sender, buildEvent);
}
}
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);
}
private void ProjectStarted(object sender, ProjectStartedEventArgs e)
{
string targets = string.IsNullOrEmpty(e.TargetNames) ? "default" : e.TargetNames;
string line = string.Format(CultureInfo.InvariantCulture, "Project \"{0}\" ({1} target(s)):", e.ProjectFile, targets);
this.WriteLine(line + Environment.NewLine);
if (this.IsVerbosityAtLeast(LoggerVerbosity.Diagnostic))
{
this.WriteLine("Initial Properties:");
SortedDictionary <string, string> sortedProperties = new SortedDictionary <string, string>();
foreach (DictionaryEntry k in e.Properties.Cast <DictionaryEntry>())
{
sortedProperties.Add(k.Key.ToString(), k.Value.ToString());
}
foreach (var p in sortedProperties)
{
bool matched = this.regExRules.Select(s => new Regex(s)).Select(r => r.Match(p.Key)).Any(m => m.Success);
if (matched)
{
this.WriteLine(p.Key + "\t = " + SecureChar.Repeat(p.Value.Length));
}
else
{
this.WriteLine(p.Key + "\t = " + p.Value);
}
}
}
}
/// <summary>
/// Logs that a project build has started
/// </summary>
/// <param name="nodeBuildEventContext">The event context of the node which is spawning this project.</param>
/// <param name="submissionId">The id of the submission.</param>
/// <param name="projectInstanceId">Id of the project instance which is being started</param>
/// <param name="parentBuildEventContext">BuildEventContext of the project who is requesting "projectFile" to build</param>
/// <param name="projectFile">Project file to build</param>
/// <param name="targetNames">Target names to build</param>
/// <param name="properties">Initial property list</param>
/// <param name="items">Initial items list</param>
/// <param name="evaluationId">EvaluationId of the project instance</param>
/// <returns>The build event context for the project.</returns>
/// <exception cref="InternalErrorException">parentBuildEventContext is null</exception>
/// <exception cref="InternalErrorException">projectBuildEventContext is null</exception>
public BuildEventContext LogProjectStarted(BuildEventContext nodeBuildEventContext, int submissionId, int projectInstanceId, BuildEventContext parentBuildEventContext, string projectFile, string targetNames, IEnumerable <DictionaryEntry> properties, IEnumerable <DictionaryEntry> items, int evaluationId = BuildEventContext.InvalidEvaluationId)
{
lock (_lockObject)
{
ErrorUtilities.VerifyThrow(nodeBuildEventContext != null, "Need a nodeBuildEventContext");
BuildEventContext projectBuildEventContext = new BuildEventContext(submissionId, nodeBuildEventContext.NodeId, evaluationId, projectInstanceId, NextProjectId, BuildEventContext.InvalidTargetId, BuildEventContext.InvalidTaskId);
// PERF: Not using VerifyThrow to avoid boxing of projectBuildEventContext.ProjectContextId in the non-error case.
if (_projectFileMap.ContainsKey(projectBuildEventContext.ProjectContextId))
{
ErrorUtilities.ThrowInternalError("ContextID {0} for project {1} should not already be in the ID-to-file mapping!", projectBuildEventContext.ProjectContextId, projectFile);
}
_projectFileMap[projectBuildEventContext.ProjectContextId] = projectFile;
ErrorUtilities.VerifyThrow(parentBuildEventContext != null, "Need a parentBuildEventContext");
string message = string.Empty;
string projectFilePath = Path.GetFileName(projectFile);
// Check to see if the there are any specific target names to be built.
// If targetNames is null or empty then we will be building with the
// default targets.
if (!String.IsNullOrEmpty(targetNames))
{
message = ResourceUtilities.FormatResourceStringIgnoreCodeAndKeyword("ProjectStartedPrefixForTopLevelProjectWithTargetNames", projectFilePath, targetNames);
}
else
{
message = ResourceUtilities.FormatResourceStringIgnoreCodeAndKeyword("ProjectStartedPrefixForTopLevelProjectWithDefaultTargets", projectFilePath);
}
ErrorUtilities.VerifyThrow(_configCache.Value.HasConfiguration(projectInstanceId), "Cannot find the project configuration while injecting non-serialized data from out-of-proc node.");
var buildRequestConfiguration = _configCache.Value[projectInstanceId];
// Always log GlobalProperties on ProjectStarted
// See https://github.com/dotnet/msbuild/issues/6341 for details
IDictionary <string, string> globalProperties = buildRequestConfiguration.GlobalProperties.ToDictionary();
var buildEvent = new ProjectStartedEventArgs
(
projectInstanceId,
message,
helpKeyword: null,
projectFile,
targetNames,
properties,
items,
parentBuildEventContext,
globalProperties,
buildRequestConfiguration.ToolsVersion
);
buildEvent.BuildEventContext = projectBuildEventContext;
ProcessLoggingEvent(buildEvent);
return(projectBuildEventContext);
}
}
public void FireProjectStarted(object sender, ProjectStartedEventArgs psea)
{
if (projectStarted != null)
{
projectStarted(sender, psea);
}
FireAnyEvent(sender, psea);
}
private void EventSource_ProjectStarted(object sender, ProjectStartedEventArgs e)
{
if (TextBox != null)
{
WriteLine("", e);
m_iIndent++;
}
}
public ProjectState(ProjectStartedEventArgs args)
{
GlobalProperties = args.GlobalProperties;
ProjectFile = args.ProjectFile;
ContextId = args.BuildEventContext.ProjectContextId;
ParentContextId = args.ParentProjectBuildEventContext.ProjectContextId;
TargetPath = (string)args.Properties?.Cast <DictionaryEntry>().FirstOrDefault(p => ((string)p.Key).Equals("TargetPath")).Value;
}
private void OnProjectStarted(object sender, ProjectStartedEventArgs e)
{
_projects.Add(new BuildProjectContextEntry(
e.BuildEventContext.ProjectInstanceId,
e.BuildEventContext.ProjectContextId,
e.ProjectFile,
e.GlobalProperties));
}
/// <summary>
/// Handler for the ProjectStarted event.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void eventSource_ProjectStarted(object sender, ProjectStartedEventArgs e)
{
// Clone and store the properties so we can inspect the values later on
foreach (DictionaryEntry property in e.Properties)
{
projectStartedProperties[(string)property.Key] = (string)property.Value;
}
}
private void OnProjectStarted(object sender, ProjectStartedEventArgs projectStartedEventArgs)
{
buildLog.ProjectStartEvents.Add(new ProjectStartLog
{
Time = projectStartedEventArgs.Timestamp.ToString(),
Message = projectStartedEventArgs.Message,
ProjectFile = projectStartedEventArgs.ProjectFile
});
}
public void ProjectStartedHandler(object sender, ProjectStartedEventArgs args)
{
SetColor(eventColor);
WriteLine(String.Format("Project \"{0}\" ({1} target(s)):", args.ProjectFile,
String.IsNullOrEmpty(args.TargetNames) ? "default" : args.TargetNames));
ResetColor();
WriteLine(String.Empty);
PushEvent(args);
}
private void OnProjectStarted(object sender, ProjectStartedEventArgs e)
{
var entry = new BuildProjectContextEntry(e.ProjectFile, e.GlobalProperties);
if (!_projectsLookup.ContainsKey(entry.ProjectFile))
{
_projectsLookup.Add(entry.ProjectFile, entry);
}
}
/// <summary>
/// Try to update the project data given a project started event. This is useful if the project
/// was created (e.g. as a parent) before we saw the started event.
/// <remarks>Does nothing if the data has already been set or the new data is null.</remarks>
/// </summary>
/// <param name="args">The <see cref="ProjectStartedEventArgs"/> instance containing the event data.</param>
public void UpdateProject(Project project, ProjectStartedEventArgs args)
{
if (project.Name == null && args != null)
{
project.StartTime = args.Timestamp;
project.Name = stringTable.Intern(args.Message);
project.ProjectFile = stringTable.Intern(args.ProjectFile);
if (args.GlobalProperties != null)
{
AddGlobalProperties(project, args.GlobalProperties);
}
if (args.Properties != null)
{
var properties = project.GetOrCreateNodeWithName <Folder>("Properties");
AddProperties(properties, args
.Properties
.Cast <DictionaryEntry>()
.OrderBy(d => d.Key)
.Select(d => new KeyValuePair <string, string>(
stringTable.Intern(Convert.ToString(d.Key)),
stringTable.Intern(Convert.ToString(d.Value)))));
}
if (args.Items != null)
{
RetrieveProjectInstance(project, args);
var items = project.GetOrCreateNodeWithName <Folder>("Items");
foreach (DictionaryEntry kvp in args.Items)
{
var itemName = stringTable.Intern(Convert.ToString(kvp.Key));
var itemGroup = items.GetOrCreateNodeWithName <Folder>(itemName);
var item = new Item();
var taskItem = kvp.Value as ITaskItem;
if (taskItem != null)
{
item.Text = stringTable.Intern(taskItem.ItemSpec);
foreach (DictionaryEntry metadataName in taskItem.CloneCustomMetadata())
{
item.AddChild(new Metadata
{
Name = stringTable.Intern(Convert.ToString(metadataName.Key)),
Value = stringTable.Intern(Convert.ToString(metadataName.Value))
});
}
itemGroup.AddChild(item);
}
}
}
}
}
/// <summary>
/// Gets a project instance for the given identifier. Will create if it doesn't exist.
/// </summary>
/// <remarks>If the ProjectStartedEventArgs is not known at this time (null), a stub project is created.</remarks>
/// <param name="projectId">The project identifier.</param>
/// <param name="args">The <see cref="ProjectStartedEventArgs"/> instance containing the event data.</param>
/// <param name="parentProject">The parent project, if any.</param>
/// <returns>Project object</returns>
public Project GetOrAddProject(ProjectStartedEventArgs args, Project parentProject = null)
{
var projectId = args.BuildEventContext.ProjectContextId;
Project result = _projectIdToProjectMap.GetOrAdd(projectId,
id => CreateProject(id));
UpdateProject(result, args);
return(result);
}
private void OnProjectStarted(object sender, ProjectStartedEventArgs e)
{
string prefix = "";
string suffix = "";
string project = Path.GetFileNameWithoutExtension(e.ProjectFile);
switch (e.TargetNames)
{
case "Clean": return; // No need to show clean messages.
case "GetCopyToOutputDirectoryItems": return; // No need to show "copying to target" messages.
case "Rebuild":
if (visited.Contains(project))
{
return;
}
visited.Add(project);
prefix = "Rebuilding ";
break;
case "Build":
if (visited.Contains(project))
{
return;
}
visited.Add(project);
prefix = "Building ";
break;
case "GetNativeManifest":
prefix = " Building manifest for ";
break;
case "GetResolvedLinkLibs":
prefix = " Linking ";
break;
case "":
if (visited.Contains(project))
{
return;
}
visited.Add(project);
break;
default:
suffix = " (" + e.TargetNames + ")";
break;
}
outputManager.EndProgress();
outputManager.StartProgress(prefix + project + suffix);
}
internal PdbEntry ProjectStarted(ProjectStartedEventArgs e)
{
// Load symbol information for the project
PDB pdb = SymbolStore.Instance[e.ProjectFile];
// Create a new stack frame
projectStack.Push(new ProjectStackFrame(pdb));
// Return the symbol for the project
return(pdb.ProjectPdbEntry);
}
void ProjectStarted(object sender, ProjectStartedEventArgs e)
{
AppendLine(string.Format("##Project Started:{0}", e.ProjectFile));
AppendLine(string.Format(@"_{0}_<br/>", e.Message.EscapeMarkdownCharacters()));
AppendLine(string.Format("_{0}|targets=({1})|{2}_", e.Timestamp, e.TargetNames, e.ProjectFile));
if (IsVerbosityAtLeast(LoggerVerbosity.Detailed))
{
AppendLine(e.ToPropertyValues().ToMarkdownTable().ToMarkdown());
}
}
private void EventSource_ProjectStarted(object sender, ProjectStartedEventArgs e)
{
if (DumpEnv)
{
o.WriteLine("Initial Properties:");
foreach (DictionaryEntry kvp in e.Properties)
{
o.WriteLine($"{kvp.Key} {kvp.Value}");
}
}
}
internal ProjectStartedEventMinimumFields(int projectKey, int entryPointKey, ProjectStartedEventArgs startedEvent, ProjectStartedEventMinimumFields parentProjectStartedEvent)
{
this.targetNames = startedEvent.TargetNames;
this.projectFile = startedEvent.ProjectFile;
this.showProjectFinishedEvent = false;
this.errorInProject = false;
this.projectId = startedEvent.ProjectId;
this.buildEventContext = startedEvent.BuildEventContext;
this.parentProjectStartedEvent = parentProjectStartedEvent;
this.projectFullKey = new ProjectFullKey(projectKey, entryPointKey);
this.timeStamp = startedEvent.Timestamp;
}
private ProjectStartedEventArgs BuildProjectStartedEventArgs(long lineNumber, string line, string fullText)
{
var projectStartedEventArgs = new ProjectStartedEventArgs()
{
LineNumber = lineNumber,
RegExResult = line,
FullText = fullText,
ProjectName = line
};
return(projectStartedEventArgs);
}
private void EventSourceOnProjectStarted(object sender, ProjectStartedEventArgs projectStartedEventArgs)
{
if (projectStartedEventArgs.ProjectFile.EndsWith(".sln", StringComparison.InvariantCultureIgnoreCase))
{
return;
}
if (this.projectBuildStarted != null)
{
this.projectBuildStarted(projectStartedEventArgs.ProjectFile);
}
}
protected override void ProjectStartedHandler(object sender, ProjectStartedEventArgs buildEvent)
{
try
{
base.ProjectStartedHandler(sender, buildEvent);
mustLog = true;
}
catch (Exception e)
{
System.Diagnostics.Debug.WriteLine(e.Message);
}
}
public void ProjectStartedHandler(ProjectStartedEventArgs args)
{
if (IsVerbosityGreaterOrEqual(LoggerVerbosity.Normal))
{
SetColor(eventColor);
WriteLine(String.Format("Project \"{0}\" ({1} target(s)):", args.ProjectFile,
String.IsNullOrEmpty(args.TargetNames) ? "default" : args.TargetNames));
ResetColor();
DumpProperties(args.Properties);
DumpItems(args.Items);
}
}
public BuildMessage(ProjectStartedEventArgs args)
{
EventType = args.GetType().Name.Replace("EventArgs", "");
Message = args.Message;
ProjectFile = args.ProjectFile;
ProjectId = args.ProjectId;
TargetNames = args.TargetNames;
HelpKeyword = args.HelpKeyword;
SenderName = args.SenderName;
Timestamp = args.Timestamp;
ThreadId = args.ThreadId;
}
/// <summary>
/// Gets a project instance for the given identifier. Will create if it doesn't exist.
/// </summary>
/// <remarks>If the ProjectStartedEventArgs is not known at this time (null), a stub project is created.</remarks>
/// <param name="projectId">The project identifier.</param>
/// <param name="args">The <see cref="ProjectStartedEventArgs"/> instance containing the event data.</param>
/// <param name="parentProject">The parent project, if any.</param>
/// <returns>Project object</returns>
public Project GetOrAddProject(int projectId, ProjectStartedEventArgs args = null, Project parentProject = null)
{
Project result = _projectIdToProjectMap.GetOrAdd(projectId,
id => CreateProject(id));
if (args != null)
{
UpdateProject(result, args);
}
return(result);
}
public void ExerciseBuildEventContext()
{
BuildEventContext parentBuildEventContext = new BuildEventContext(0, 0, 0, 0);
BuildEventContext currentBuildEventContext = new BuildEventContext(0, 2, 1, 1);
BuildEventContext currentBuildEventContextNode = new BuildEventContext(1, 0, 0, 0);
BuildEventContext currentBuildEventContextTarget = new BuildEventContext(0, 1, 0, 0);
BuildEventContext currentBuildEventContextPci = new BuildEventContext(0, 0, 1, 0);
BuildEventContext currentBuildEventContextTask = new BuildEventContext(0, 0, 0, 1);
BuildEventContext allDifferent = new BuildEventContext(1, 1, 1, 1);
BuildEventContext allSame = new BuildEventContext(0, 0, 0, 0);
ProjectStartedEventArgs startedEvent = new ProjectStartedEventArgs(-1, "Message", "HELP", "File", "Targets", null, null, parentBuildEventContext);
startedEvent.BuildEventContext = currentBuildEventContext;
Assert.IsTrue(parentBuildEventContext.GetHashCode() == 0);
// Node is different
Assert.IsFalse(parentBuildEventContext.Equals(currentBuildEventContextNode));
// Target is different
Assert.IsFalse(parentBuildEventContext.Equals(currentBuildEventContextTarget));
// PCI is different
Assert.IsFalse(parentBuildEventContext.Equals(currentBuildEventContextPci));
// Task is different
Assert.IsFalse(parentBuildEventContext.Equals(currentBuildEventContextTask));
// All fields are different
Assert.IsFalse(parentBuildEventContext.Equals(allDifferent));
// All fields are same
Assert.IsTrue(parentBuildEventContext.Equals(allSame));
// Compare with null
Assert.IsFalse(parentBuildEventContext.Equals(null));
// Compare with self
Assert.IsTrue(currentBuildEventContext.Equals(currentBuildEventContext));
Assert.IsFalse(currentBuildEventContext.Equals(new object()));
Assert.IsNotNull(startedEvent.BuildEventContext);
Assert.AreEqual(0, startedEvent.ParentProjectBuildEventContext.NodeId);
Assert.AreEqual(0, startedEvent.ParentProjectBuildEventContext.TargetId);
Assert.AreEqual(0, startedEvent.ParentProjectBuildEventContext.ProjectContextId);
Assert.AreEqual(0, startedEvent.ParentProjectBuildEventContext.TaskId);
Assert.AreEqual(0, startedEvent.BuildEventContext.NodeId);
Assert.AreEqual(2, startedEvent.BuildEventContext.TargetId);
Assert.AreEqual(1, startedEvent.BuildEventContext.ProjectContextId);
Assert.AreEqual(1, startedEvent.BuildEventContext.TaskId);
}
private void eventSource_ProjectStartedHandler(object sender, ProjectStartedEventArgs e)
{
LogStageStarted(XmlLoggerElements.Project, e.TargetNames, e.ProjectFile, e.Timestamp);
}
void eventSource_ProjectStarted(object sender, ProjectStartedEventArgs e)
{
BuildDetails.Add(e.Message);
}
private void ProjectStarted(object sender, ProjectStartedEventArgs e)
{
SendMessage(FormatMessage(e));
}
