internal static void WriteMessage(string message)
{
ThreadHelper.ThrowIfNotOnUIThread();
if (GeneralOutputWindowPane == null)
{
GeneralOutputWindowPane = ProjectPackage?.GetOutputPane(VSConstants.OutputWindowPaneGuid.GeneralPane_guid, "Add referenced projects to solution");
}
GeneralOutputWindowPane?.Activate();
GeneralOutputWindowPane?.OutputStringThreadSafe(message + System.Environment.NewLine);
}
/// <summary>
/// Log the error to the Output Window asyncronously.
/// </summary>
/// <remarks>
/// It creates a new Output Window pane called "Extensions" where it logs to. This is to no polute
/// the existing "Build" pane with errors coming from extensions.
/// </remarks>
/// <example>
/// <code>
/// try
/// {
/// // Do work;
/// }
/// catch (Exception ex)
/// {
/// await ex.LogAsync();
/// }
/// </code>
/// </example>
public static async Task LogAsync(this Exception exception)
{
try
{
await ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync();
if (await EnsurePaneAsync())
{
_pane?.OutputStringThreadSafe(exception + Environment.NewLine);
}
}
catch (Exception ex)
{
Diagnostics.Debug.WriteLine(ex);
}
}
private void Build(uint options, IVsOutputWindowPane output, string target)
{
if (!this.NotifyBuildBegin())
{
return;
}
try {
config.ProjectMgr.BuildAsync(options, this.config.ConfigName, output, target, (result, buildTarget) => this.NotifyBuildEnd(result, buildTarget));
} catch (Exception e) {
Trace.WriteLine("Exception : " + e.Message);
ErrorHandler.ThrowOnFailure(output.OutputStringThreadSafe("Unhandled Exception:" + e.Message + "\n"));
this.NotifyBuildEnd(MSBuildResult.Failed, target);
throw;
} finally {
ErrorHandler.ThrowOnFailure(output.FlushToTaskList());
}
}
public async Task PrintMessageAsync(string title, string contents = null)
{
if (_pane == null)
{
await VSPackage.TaskFactory.SwitchToMainThreadAsync();
var outputWindow = _serviceProvider.GetService(typeof(SVsOutputWindow)) as IVsOutputWindow;
Assumes.Present(outputWindow);
outputWindow.CreatePane(_paneGuid, _paneTitle, fInitVisible: 1, fClearWithSolution: 1);
outputWindow.GetPane(_paneGuid, out _pane);
}
var message = contents == null
? "=== " + title + Environment.NewLine + Environment.NewLine
: "=== " + title + Environment.NewLine + contents + Environment.NewLine + Environment.NewLine;
_pane.OutputStringThreadSafe(message);
}
protected async void OnExecute(object send, EventArgs e)
{
try
{
string result = await RunExecuteAsync(send, e);
if (false == string.IsNullOrEmpty(result))
{
VSOutput(result);
}
}
catch (Exception ex)
{
await ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync();
outputWindowPane.Activate();
outputWindowPane.OutputStringThreadSafe(ex.ToString());
}
}
public void MenuItemCallback(object sender, EventArgs e)
{
if (ShowErrorMessageAndReturnTrueIfNoSolutionOpen())
{
return;
}
var componentModel = Package.GetGlobalService(typeof(SComponentModel)) as IComponentModel;
var dte = Package.GetGlobalService(typeof(DTE)) as DTE;
var slnPath = dte.Solution.FileName;
IVsOutputWindowPane customPane = DteUtil.GetThisExtensionOutputPane();
customPane.OutputStringThreadSafe($"Starting full compilation of {slnPath}\r\n");
IRoslynSolutionAnalysis roslyn = new RoslynSolutionAnalysis();
roslyn.CompileFullSolutionInBackgroundAndReportErrors(slnPath, (message) => customPane.OutputStringThreadSafe(message));
}
public static void Log(string message)
{
if (string.IsNullOrEmpty(message))
{
return;
}
try
{
if (EnsurePane())
{
_pane.OutputStringThreadSafe($"{DateTime.Now}: {message} {Environment.NewLine}");
}
}
catch (Exception ex)
{
System.Diagnostics.Debug.Write(ex);
}
}
///// <summary>
///// Initializes the logger and Application Insights telemetry client.
///// </summary>
///// <param name="provider">The service provider or Package instance.</param>
///// <param name="name">The name to use for the custom Output Window pane.</param>
///// <param name="version">The version of the Visual Studio extension.</param>
///// <param name="telemetryKey">The Applicatoin Insights instrumentation key (usually a GUID).</param>
//public static void Initialize(IServiceProvider provider, string name, string version, string telemetryKey)
//{
// Initialize(provider, name);
// Telemetry.Initialize(provider, version, telemetryKey);
//}
/// <summary>
/// Logs a message to the Output Window.
/// </summary>
/// <param name="message">The message to output.</param>
public static void Log(string message)
{
if (string.IsNullOrWhiteSpace(message))
{
return;
}
try
{
if (EnsurePane())
{
pane?.OutputStringThreadSafe(DateTime.Now + ": " + message + Environment.NewLine);
}
}
catch (Exception ex)
{
Debug.Write(ex);
}
}
public static void WriteExtensionOutput(string message, int retyrCount = 20)
{
try
{
IVsOutputWindowPane customPane = GetThisExtensionOutputPane();
customPane.OutputStringThreadSafe(message);
}
catch (InvalidOperationException ex)
{
if (retyrCount > 0 && ex.Message.Contains("has not been loaded yet"))
{
System.Threading.Tasks.Task.Factory.StartNew(async() =>
{
await System.Threading.Tasks.Task.Delay(5000);
WriteExtensionOutput(message, retyrCount - 1);
});
}
}
}
public bool RemovePackage(string packageId)
{
if (!m_packageServices.IsPackageInstalled(m_project, packageId))
{
return(false);
}
var meta = m_packageServices.GetInstalledPackages(m_project).FirstOrDefault(p => p.Id == packageId);
if (string.IsNullOrEmpty(meta?.InstallPath))
{
//
// UinstallPackage() fails, with the following exception when the respective package is still
// referenced by the project, but no longer present in the "packages"-folder.
//
// So in this case a rebuild of the project _and_ a restore of the (existing/old) NuGet
// packages is required.
//
// System.ArgumentException: Empty path name is not legal.
// at System.IO.FileStream.Init(String path, FileMode mode, FileAccess access, Int32 rights, Boolean useRights, FileShare share, Int32 bufferSize, FileOptions options, SECURITY_ATTRIBUTES secAttrs, String msgPath, Boolean bFromProxy, Boolean useLongPath, Boolean checkHost)
// at System.IO.FileStream..ctor(String path, FileMode mode, FileAccess access, FileShare share)
// at NuGet.ProjectManagement.MSBuildNuGetProject.<UninstallPackageAsync>d__36.MoveNext()
// ...
// at NuGet.VisualStudio.VsPackageUninstaller.UninstallPackage(Project project, String packageId, Boolean removeDependencies)
// at NUnitToMSTestPackage.Utilities.PackageHandler.RemovePackage(String packageId) in C:\Sources\Stuff\mine\NUnitToMSTest\NUnitToMSTestPackage\Utilities\PackageHandler.cs:line 87
// at NUnitToMSTestPackage.Commands.TransformProjectFilesCommand.RemoveNUnitPackages(Project selectedProject, StatusbarContext statusbar, Int32& complete, Int32 total) in C:\Sources\Stuff\mine\NUnitToMSTest\NUnitToMSTestPackage\Commands\TransformProjectFilesCommand.cs:line 186
// at NUnitToMSTestPackage.Commands.TransformProjectFilesCommand.<InvokeRefactoring>d__16.MoveNext() in C:\Sources\Stuff\mine\NUnitToMSTest\NUnitToMSTestPackage\Commands\TransformProjectFilesCommand.cs:line 147
//
string str = $"Could not remove package {packageId}, because it's InstallPath is not set. " +
"Possibly the package is no longer present in your \"packages\" folder. Packages can " +
"only be removed, if they are present there. You could revert what has changed, restore " +
"all existing/old packages and retry the conversion. Or you can manually remove the package " +
$"{packageId} from the project {m_project.Name}.";
m_outputWindowPane?.OutputStringThreadSafe("Warning: " + str);
ReportWarning?.Invoke(str);
return(false);
}
m_uninstaller.UninstallPackage(m_project, packageId, true);
return(true);
}
/// <inheritdoc />
protected override void LogImpl(LogSeverity severity, string message, ExceptionData exceptionData)
{
if (severity < LogSeverity.Info)
{
return;
}
StringBuilder output = new StringBuilder();
output.AppendLine(message);
if (exceptionData != null)
{
output.Append(" ");
output.AppendLine(exceptionData.ToString());
}
IVsOutputWindowPane outputWindowPane = GetOutputWindowPane();
outputWindowPane.OutputStringThreadSafe(output.ToString());
}
internal static void DisplayOutPutMessage(string message)
{
IVsOutputWindowPane outputPane = null;
var outputWindow = ServiceProvider.GlobalProvider.GetService(typeof(SVsOutputWindow)) as IVsOutputWindow;
if (outputWindow != null && ErrorHandler.Failed(outputWindow.GetPane(XSharpOutputWindowPane, out outputPane)))
{
IVsWindowFrame windowFrame;
var vsUiShell = ServiceProvider.GlobalProvider.GetService(typeof(SVsUIShell)) as IVsUIShell;
uint flags = (uint)__VSFINDTOOLWIN.FTW_fForceCreate;
vsUiShell.FindToolWindow(flags, VSConstants.StandardToolWindows.Output, out windowFrame);
windowFrame.Show();
outputWindow.CreatePane(XSharpOutputWindowPane, "XSharp - Debug Window", 1, 1);
outputWindow.GetPane(XSharpOutputWindowPane, out outputPane);
outputPane.Activate();
}
message = DateTime.Now.ToString("hh:mm:ss.fff") + " " + message + "\r\n";
outputPane?.OutputStringThreadSafe(message);
}
internal override void BuildAsync(uint vsopts, string config, IVsOutputWindowPane output, string target, Action<MSBuildResult, string> uiThreadCallback) {
var xSolutionBuildManager = (IVsSolutionBuildManager)this.GetService(typeof(IVsSolutionBuildManager));
var xSolution = (IVsSolution)this.GetService(typeof(IVsSolution));
if (xSolutionBuildManager != null && xSolution != null) {
IVsHierarchy xStartupProj;
xSolutionBuildManager.get_StartupProject(out xStartupProj);
if (xStartupProj != null) {
var xProj = xStartupProj as IVsProject3;
Guid xGuid;
xSolution.GetGuidOfProject(xStartupProj, out xGuid);
if (xGuid != Guid.Empty) {
if (xGuid != this.ProjectIDGuid) {
uiThreadCallback(MSBuildResult.Successful, "Skipped");
output.OutputStringThreadSafe("Project skipped, as it's not necessary for running\r\n\r\n");
return;
}
}
}
}
base.BuildAsync(vsopts, config, output, target, uiThreadCallback);
}
public static async Task LogAsync(string message)
{
await ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync();
if (string.IsNullOrEmpty(message))
{
return;
}
try
{
if (EnsurePane())
{
pane.OutputStringThreadSafe(DateTime.Now + ": " + message + Environment.NewLine);
}
}
catch (Exception ex)
{
System.Diagnostics.Debug.Write(ex);
}
}
#pragma warning disable VSTHRD010
/// <inheritdoc/>
public void Emit(LogEvent logEvent)
{
var sw = new StringWriter();
_formatter.Format(logEvent, sw);
var message = sw.ToString();
if (_pane is IVsOutputWindowPaneNoPump noPump)
{
noPump.OutputStringNoPump(message);
}
else
{
ErrorHandler.ThrowOnFailure(_pane.OutputStringThreadSafe(message));
}
if (logEvent.Level == LogEventLevel.Error)
{
_pane.Activate();
}
}
public static void Log(string message)
{
if (string.IsNullOrEmpty(message))
{
return;
}
try
{
if (!EnsurePane())
{
return;
}
ThreadHelper.ThrowIfNotOnUIThread();
_pane.OutputStringThreadSafe(DateTime.Now + ": " + message + Environment.NewLine);
}
catch (Exception ex)
{
System.Diagnostics.Debug.WriteLine(ex);
}
}
public static void Log(string message)
{
if (string.IsNullOrEmpty(message))
{
return;
}
try
{
if (EnsurePane())
{
ThreadHelper.Generic.BeginInvoke(() =>
{
pane.OutputStringThreadSafe(DateTime.Now + ": " + message + Environment.NewLine);
});
}
}
catch (Exception ex)
{
System.Diagnostics.Debug.Write(ex);
}
}
protected override void WriteLine(string format, params object[] args)
{
if (outputPane == null)
{
var output = (IVsOutputWindow)Package.GetGlobalService(typeof(SVsOutputWindow));
var generalPaneGuid = VSConstants.GUID_OutWindowGeneralPane;
if (ErrorHandler.Failed(output.GetPane(ref generalPaneGuid, out outputPane)) || outputPane == null)
{
if (ErrorHandler.Failed(output.CreatePane(ref generalPaneGuid, "Global Command Capture Output", 1, 1)))
{
statusBar.SetText("Attempt to create output pane failed");
Stop();
return;
}
if (ErrorHandler.Failed(output.GetPane(ref generalPaneGuid, out outputPane)) || outputPane == null)
{
statusBar.SetText("Attempt to get output pane failed");
Stop();
return;
}
}
outputPane.SetName("Global Command Capture Output");
WriteLine(format, args);
}
else
{
outputPane.OutputStringThreadSafe(string.Format(format + "\r\n", args));
}
}
//--//
private void Message(IVsOutputWindowPane pane, String msg)
{
if (pane == null)
{
return;
}
if (msg == null)
{
msg = "[no message string provided to MessageCentre.Message()" + new StackTrace().ToString();
}
try
{
lock (pane)
{
pane.Activate();
pane.OutputStringThreadSafe(msg + "\r\n");
}
}
catch (InvalidOperationException)
{
}
}
private void LogMessageToOutputWindow([CanBeNull] string value)
{
_pane.OutputStringThreadSafe(value);
}
private static void WriteLineToPane(IVsOutputWindowPane pane, string messageFormat, params object[] args)
{
int hr = pane.OutputStringThreadSafe(string.Format(CultureInfo.CurrentCulture, messageFormat, args: args) + Environment.NewLine);
Debug.Assert(ErrorHandler.Succeeded(hr), "Failed in OutputStringThreadSafe: " + hr.ToString());
}
private void Build(uint options, IVsOutputWindowPane output, string target) {
if (!this.NotifyBuildBegin()) {
return;
}
try {
config.ProjectMgr.BuildAsync(options, this.config.ConfigName, output, target, (result, buildTarget) => this.NotifyBuildEnd(result, buildTarget));
} catch (Exception e) {
if (e.IsCriticalException()) {
throw;
}
Trace.WriteLine("Exception : " + e.Message);
ErrorHandler.ThrowOnFailure(output.OutputStringThreadSafe("Unhandled Exception:" + e.Message + "\n"));
this.NotifyBuildEnd(MSBuildResult.Failed, target);
throw;
} finally {
ErrorHandler.ThrowOnFailure(output.FlushToTaskList());
}
}
public void Write(MessageCategory category, string message)
{
EnsurePaneVisible();
_pane?.OutputStringThreadSafe(message);
}
private void Build(uint options, IVsOutputWindowPane output, string target)
{
if (!this.config.ProjectMgr.HasPassedSecurityChecks)
{
// From a security perspective, if there was something truly malicious about the project,
// the user is about to toast himself by requesting a build. Any further attempts at
// preventing damage by avoiding MSBuild targets/tasks are futile. So, from this point
// forward, we might as well pretend that this project has passed all security checks,
// and we're free to run any targets we like.
this.config.ProjectMgr.HasPassedSecurityChecks = true;
}
// We want to refresh the references if we are building with the Build or Rebuild target or if the project was opened for browsing only.
bool shouldRepaintReferences = (target == null || target == MsBuildTarget.Build || target == MsBuildTarget.Rebuild ||
!this.config.ProjectMgr.HasPassedSecurityChecks);
int shouldContinue = 1;
foreach (IVsBuildStatusCallback cb in callbacks)
{
try
{
ErrorHandler.ThrowOnFailure(cb.BuildBegin(ref shouldContinue));
if (shouldContinue == 0)
{
return;
}
}
catch (Exception e)
{
// If those who ask for status have bugs in their code it should not prevent the build/notification from happening
Debug.Fail(String.Format(CultureInfo.CurrentCulture, SR.GetString(SR.BuildEventError, CultureInfo.CurrentUICulture), e.Message));
}
}
MSBuildResult result = MSBuildResult.Failed;
try
{
result = config.ProjectMgr.Build(options, this.config.ConfigName, this.config.PlatformName, output, target);
}
catch (Exception e)
{
Trace.WriteLine("Exception : " + e.Message);
ErrorHandler.ThrowOnFailure(output.OutputStringThreadSafe("Unhandled Exception:" + e.Message + "\n"));
throw e;
}
finally
{
int success = ((result == MSBuildResult.Successful) ? 1 : 0);
foreach (IVsBuildStatusCallback cb in callbacks)
{
try
{
ErrorHandler.ThrowOnFailure(cb.BuildEnd(success));
}
catch (Exception e)
{
// If those who ask for status have bugs in their code it should not prevent the build/notification from happening
Debug.Fail(String.Format(CultureInfo.CurrentCulture, SR.GetString(SR.BuildEventError, CultureInfo.CurrentUICulture), e.Message));
}
}
ErrorHandler.ThrowOnFailure(output.FlushToTaskList());
// Now repaint references if that is needed.
// We hardly rely here on the fact the ResolveAssemblyReferences target has been run as part of the build.
// One scenario to think at is when an assembly reference is renamed on disk thus becomming unresolvable,
// but msbuild can actually resolve it.
// Another one if the project was opened only for browsing and now the user chooses to build or rebuild.
if (shouldRepaintReferences && (result == MSBuildResult.Successful))
{
this.RefreshReferences();
}
}
}
private static void StreamOutput(Process/*!*/ process, StreamReader/*!*/ from, IVsOutputWindowPane/*!*/ output, BackgroundWorker worker)
{
while (!process.HasExited) {
string line;
while ((line = from.ReadLine()) != null) {
output.OutputStringThreadSafe(line);
output.OutputStringThreadSafe("\n");
worker.ReportProgress(5);
}
}
}
public Task WriteAsync(MessageCategory category, string message)
{
EnsurePaneVisible();
_pane?.OutputStringThreadSafe(message);
return(Task.CompletedTask);
}
public virtual bool ObsoleteBuild(uint vsopts, string config, IVsOutputWindowPane output, bool fCleanBuild)
{
if (fCleanBuild)
{
// we are done
return true;
}
lock (Project.BuildLock)
{
ProjectOptions options = this.GetProjectOptions(config);
CompilerResults results;
ArrayList files = new ArrayList();
/*UNDONE: need to get this to use MSBuild
foreach (XmlElement e in doc.SelectNodes("//Files/Include/File"))
{
//TODO: Support other "BuildActions" like "EmbeddedResource"...
if (e.GetAttribute("BuildAction") == "Compile")
{
string rel = e.GetAttribute("RelPath");
Url url = new Url(new Url(doc.BaseURI), rel);
files.Add(url.AbsoluteUrl);
}
}
*/
try
{
ICodeCompiler compiler = this.GetCompiler();
if (files.Count == 1)
{
string filename = (string)files[0];
results = compiler.CompileAssemblyFromFile(options, filename);
}
else
{
string[] fileNames = (string[])files.ToArray(typeof(string));
results = compiler.CompileAssemblyFromFileBatch(options, fileNames);
}
}
catch (Exception e)
{
results = new CompilerResults(options.TempFiles);
results.Errors.Add(new CompilerError(options.OutputAssembly, 1, 1, "", "Internal Compiler Error: " + e.ToString() + "\n"));
results.NativeCompilerReturnValue = 1;
}
taskProvider.Tasks.Clear();
int errorCount = 0;
int warningCount = 0;
foreach (CompilerError e in results.Errors)
{
if (e.IsWarning) warningCount++;
else
errorCount++;
NativeMethods.ThrowOnFailure(output.OutputTaskItemString(GetFormattedErrorMessage(e, false) + "\n", VSTASKPRIORITY.TP_HIGH, VSTASKCATEGORY.CAT_BUILDCOMPILE, "", -1, e.FileName, (uint)e.Line - 1, e.ErrorText));
}
NativeMethods.ThrowOnFailure(output.OutputStringThreadSafe("Build complete -- " + errorCount + " errors, " + warningCount + " warnings")); //TODO: globalize
NativeMethods.ThrowOnFailure(output.FlushToTaskList());
return results.NativeCompilerReturnValue == 0;
}
}
/// <summary>
/// Creates a logger instance
/// </summary>
/// <param name="shouldLog">Predicate that will be called when logging. Should return true if logging is to be performed, false otherwise.</param>
/// <param name="pane">The output pane where logging should be targeted</param>
public OutputWindowLogger(Func<bool> shouldLog, IVsOutputWindowPane pane)
{
this.predicate = shouldLog;
if (pane is IVsOutputWindowPaneNoPump)
{
var asNoPump = pane as IVsOutputWindowPaneNoPump;
this.print = (s) => asNoPump.OutputStringNoPump(s);
}
else
{
this.print = (s) => pane.OutputStringThreadSafe(s);
}
}
private static void WriteLineToPane(IVsOutputWindowPane pane, string messageFormat, params object[] args)
{
int hr = pane.OutputStringThreadSafe(string.Format(CultureInfo.CurrentCulture, messageFormat, args: args) + Environment.NewLine);
Debug.Assert(ErrorHandler.Succeeded(hr), "Failed in OutputStringThreadSafe: " + hr.ToString());
}
public override void WriteLine(string line)
{
_pane.OutputStringThreadSafe(line + Environment.NewLine);
Debug.WriteLine(line, "Output Window");
}
public void WriteLine(string text)
{
output.Activate();
output.OutputStringThreadSafe(text + Environment.NewLine);
}
private void PrintDebugMessage(string message, params object[] args)
{
var hResult = m_packageOutputPane.OutputStringThreadSafe(string.Format(CultureInfo.CurrentCulture, message, args) + Environment.NewLine);
Marshal.ThrowExceptionForHR(hResult);
}
private static void WriteLineToPane(IVsOutputWindowPane pane, string message)
{
int hr = pane.OutputStringThreadSafe(message + Environment.NewLine);
Debug.Assert(ErrorHandler.Succeeded(hr), "Failed in OutputStringThreadSafe: " + hr.ToString());
}
private void OnEventsOnPackageUninstalled(IVsPackageMetadata m)
{
m_outputWindowPane.OutputStringThreadSafe($"Uninstalled package {m.Id}, version {m.VersionString}.");
}
public void Log(string message)
{
ErrorHandler.ThrowOnFailure(pane.OutputStringThreadSafe(DateTime.Now + ": Ref12: " + message + "\n"));
}
public static void WriteToOutputPane(string message)
{
_pane.OutputStringThreadSafe($"{DateTime.Now}: {message} \n");
}
public VsGitFlowWrapper(string repoPath,IVsOutputWindowPane outputWindow)
: base(repoPath)
{
CommandOutputDataReceived += (o, args) => outputWindow.OutputStringThreadSafe(args.Output);
CommandErrorDataReceived += (o, args) => outputWindow.OutputStringThreadSafe(args.Output);
}
//////////////////////////////////////////////////////////////////////////////////////////////////
// This is called from the compiler background thread.
// fCleanBuild is not part of the vsopts, but passed down as the callpath is differently
//
//////////////////////////////////////////////////////////////////////////////////////////////////
/// <include file='doc\Project.uex' path='docs/doc[@for="Project.Build"]/*' />
public virtual bool Build(uint vsopts, XmlElement config, IVsOutputWindowPane output, bool fCleanBuild){
if (fCleanBuild){
// we are done
return true;
}
lock (Project.BuildLock){
#if LookForMemoryLeaks
System.GC.Collect();
System.GC.WaitForPendingFinalizers();
System.GC.Collect();
System.GC.WaitForPendingFinalizers();
long usedMemoryBeforeBuild = System.GC.GetTotalMemory(true);
#endif
int errorCount = 0;
int warningCount = 0;
CompilerResults results = this.CompileProject(config);
#if WHIDBEY
if (this.taskManager != null && this.taskManagerBuild != null) {
taskManager.ClearTasksOnProject(this.Caption);
taskManagerBuild.ClearTasksOnProject(this.Caption);
bool runVerifierBuildOnly = this.GetBoolAttr(config, "RunProgramVerifier") && !this.GetBoolAttr(config, "RunProgramVerifierWhileEditing");
string verifierCode = ((int)System.Compiler.Error.GenericWarning).ToString("0000");
foreach (CompilerError e in results.Errors) {
if (e.IsWarning)
warningCount++;
else
errorCount++;
// output.OutputTaskItemString(GetFormattedErrorMessage(e, false) + "\n", VSTASKPRIORITY.TP_HIGH, VSTASKCATEGORY.CAT_BUILDCOMPILE, "", -1, e.FileName, (uint)e.Line - 1, e.ErrorText);
int endLine;
int endColumn;
if (e is System.Compiler.CompilerErrorEx) {
System.Compiler.CompilerErrorEx errorEx = (System.Compiler.CompilerErrorEx)e;
endLine = errorEx.EndLine;
endColumn = errorEx.EndColumn;
}
else {
endLine = e.Line;
endColumn = e.Column + 1;
}
bool isBuildOnly = runVerifierBuildOnly && e.ErrorNumber == verifierCode;
(isBuildOnly ? taskManagerBuild : taskManager).AddTask(e.ErrorText, null, e.ErrorNumber, "CS" + e.ErrorNumber,
TaskPriority.Normal, (e.IsWarning ? TaskCategory.Warning : TaskCategory.Error),
(isBuildOnly ? TaskMarker.Error : (e.IsWarning ? TaskMarker.Warning : TaskMarker.CodeSense)),
TaskOutputPane.Build, this.Caption, e.FileName,
e.Line, e.Column, endLine, endColumn, null);
}
taskManager.OutputString("Build complete -- " + errorCount + " errors, " + warningCount + " warnings\n", TaskOutputPane.Build);
taskManager.Refresh();
taskManagerBuild.Refresh();
}
else {
#endif
this.taskProvider.ClearErrors();
foreach (CompilerError e in results.Errors) {
if (e.IsWarning) warningCount++;
else
errorCount++;
output.OutputTaskItemString(GetFormattedErrorMessage(e, false) + "\n", VSTASKPRIORITY.TP_HIGH, VSTASKCATEGORY.CAT_BUILDCOMPILE, "", -1, e.FileName, (uint)e.Line - 1, e.ErrorText);
}
output.OutputStringThreadSafe("Build complete -- " + errorCount + " errors, " + warningCount + " warnings\n"); //TODO: globalize
output.FlushToTaskList();
#if WHIDBEY
}
#endif
bool success = results.NativeCompilerReturnValue == 0;
#if LookForMemoryLeaks
results = null;
System.GC.Collect();
System.GC.WaitForPendingFinalizers();
System.GC.Collect();
System.GC.WaitForPendingFinalizers();
long usedMemoryAfterBuild = System.GC.GetTotalMemory(true);
output.OutputStringThreadSafe("Build leaked "+(usedMemoryAfterBuild-usedMemoryBeforeBuild)+" bytes");
#endif
return success;
}
}
private void Build(uint options, IVsOutputWindowPane output, string target)
{
if (!this.config.ProjectMgr.HasPassedSecurityChecks)
{
// From a security perspective, if there was something truly malicious about the project,
// the user is about to toast himself by requesting a build. Any further attempts at
// preventing damage by avoiding MSBuild targets/tasks are futile. So, from this point
// forward, we might as well pretend that this project has passed all security checks,
// and we're free to run any targets we like.
this.config.ProjectMgr.HasPassedSecurityChecks = true;
}
// We want to refresh the references if we are building with the Build or Rebuild target or if the project was opened for browsing only.
bool shouldRepaintReferences = (target == null || target == MsBuildTarget.Build || target == MsBuildTarget.Rebuild
|| !this.config.ProjectMgr.HasPassedSecurityChecks);
int shouldContinue = 1;
foreach (IVsBuildStatusCallback cb in callbacks)
{
try
{
ErrorHandler.ThrowOnFailure(cb.BuildBegin(ref shouldContinue));
if (shouldContinue == 0)
return;
}
catch (Exception e)
{
// If those who ask for status have bugs in their code it should not prevent the build/notification from happening
Debug.Fail(String.Format(CultureInfo.CurrentCulture, SR.GetString(SR.BuildEventError, CultureInfo.CurrentUICulture), e.Message));
}
}
MSBuildResult result = MSBuildResult.Failed;
try
{
result = config.ProjectMgr.Build(options, this.config.ConfigName, output, target);
}
catch (Exception e)
{
Trace.WriteLine("Exception : " + e.Message);
ErrorHandler.ThrowOnFailure(output.OutputStringThreadSafe("Unhandled Exception:" + e.Message + "\n"));
throw e;
}
finally
{
int success = ((result == MSBuildResult.Successful) ? 1 : 0);
foreach (IVsBuildStatusCallback cb in callbacks)
{
try
{
ErrorHandler.ThrowOnFailure(cb.BuildEnd(success));
}
catch (Exception e)
{
// If those who ask for status have bugs in their code it should not prevent the build/notification from happening
Debug.Fail(String.Format(CultureInfo.CurrentCulture, SR.GetString(SR.BuildEventError, CultureInfo.CurrentUICulture), e.Message));
}
}
ErrorHandler.ThrowOnFailure(output.FlushToTaskList());
// Now repaint references if that is needed.
// We hardly rely here on the fact the ResolveAssemblyReferences target has been run as part of the build.
// One scenario to think at is when an assembly reference is renamed on disk thus becomming unresolvable,
// but msbuild can actually resolve it.
// Another one if the project was opened only for browsing and now the user chooses to build or rebuild.
if (shouldRepaintReferences && (result == MSBuildResult.Successful))
{
this.RefreshReferences();
}
}
}
private void Build(uint options, IVsOutputWindowPane output, string target)
{
int shouldContinue = 1;
foreach (IVsBuildStatusCallback cb in callbacks)
{
try
{
ErrorHandler.ThrowOnFailure(cb.BuildBegin(ref shouldContinue));
if (shouldContinue == 0)
return;
}
catch (Exception e)
{
// If those who ask for status have bugs in their code it should not prevent the build/notification from happening
Debug.Fail(String.Format("Exception was thrown during BuildBegin event\n{0}", e.Message));
}
}
MSBuildResult result = MSBuildResult.Failed;
try
{
result = config.ProjectMgr.Build(options, this.config.ConfigName, output, target);
}
catch (Exception e)
{
Trace.WriteLine("Exception : " + e.Message);
ErrorHandler.ThrowOnFailure(output.OutputStringThreadSafe("Unhandled Exception:" + e.Message + "\n"));
throw e;
}
finally
{
int success = ((result == MSBuildResult.Sucessful) ? 1 : 0);
foreach (IVsBuildStatusCallback cb in callbacks)
{
try
{
ErrorHandler.ThrowOnFailure(cb.BuildEnd(success));
}
catch (Exception e)
{
// If those who ask for status have bugs in their code it should not prevent the build/notification from happening
Debug.Fail(String.Format("Exception was thrown during BuildEnd event\n{0}", e.Message));
}
}
ErrorHandler.ThrowOnFailure(output.FlushToTaskList());
}
}
public void Build(uint options, IVsOutputWindowPane output, string target)
{
// We want to refresh the references if we are building with the Build or Rebuild target.
bool shouldRepaintReferences = (target == null || target == MsBuildTarget.Build || target == MsBuildTarget.Rebuild);
if (!NotifyBuildBegin()) return;
try
{
config.ProjectMgr.BuildAsync(options, this.config.ConfigCanonicalName, output, target, (result, projectInstance) =>
{
this.BuildCoda(new BuildResult(result, projectInstance), output, shouldRepaintReferences);
});
}
catch (Exception e)
{
Trace.WriteLine("Exception : " + e.Message);
ErrorHandler.ThrowOnFailure(output.OutputStringThreadSafe("Unhandled Exception:" + e.Message + "\n"));
this.BuildCoda(new BuildResult(MSBuildResult.Failed, null), output, shouldRepaintReferences);
throw;
}
}
//--//
private void Message(IVsOutputWindowPane pane, String msg)
{
if(pane == null)
return;
if(msg==null)
msg = "[no message string provided to MessageCentre.Message()" + new StackTrace().ToString();
try
{
lock (pane)
{
pane.Activate();
pane.OutputStringThreadSafe(msg + "\r\n");
}
}
catch( InvalidComObjectException )
{
}
}
