BuildResult IProjectBuildHandler.Build(BuildItemNode buildItem)
        {
            _isBuildInProgress = true;

            ProjectNode project = buildItem.Parent.Parent.Parent;
            BuildConfigurationNode configuration = buildItem.Parent;

            string solutionFilePath = buildItem.GetFullPath();
            string workingDirectory = Path.GetDirectoryName(project.FileName);
            BuildResult result = new BuildResult();

            _currentBuildProcess = new Process();
            _currentBuildProcess.StartInfo.FileName = _msBuildPath;

            if (configuration.PerformReBuild)
            {
                PerformClean(buildItem);
            }
            _currentBuildProcess.StartInfo.Arguments = string.Format("\"{0}\" /p:Configuration={1} /verbosity:{2}", solutionFilePath, GetConfiguration(configuration.Configuration, buildItem), configuration.Verbosity);

            _currentBuildProcess.StartInfo.RedirectStandardOutput = true;
            _currentBuildProcess.StartInfo.UseShellExecute = false;
            _currentBuildProcess.EnableRaisingEvents = true;
            _currentBuildProcess.OutputDataReceived += (o, e) =>
            {
                string text = e.Data;
                if (string.IsNullOrWhiteSpace(e.Data))
                {
                    return;
                }

                text = text.Trim();

                BuildInfoItem item = new BuildInfoItem() { Text = text };
                item.Level = BuildInfoItemLevel.Trace;
                if (text.Contains("->")) { item.Level = BuildInfoItemLevel.Info; }
                if (text.Contains("error")) { item.Level = BuildInfoItemLevel.Error; }
                if (text.Contains("warning")) { item.Level = BuildInfoItemLevel.Warning; }
                result.Items.Add(item);
            };

            _currentBuildProcess.Start();
            _currentBuildProcess.BeginOutputReadLine();
            _currentBuildProcess.WaitForExit();
            _currentBuildProcess = null;

            _isBuildInProgress = false;
            return result;
        }
示例#2
0
        private void BuildProcess_BuildCompleted(BuildResult result)
        {
            this.lsvOutput.Invoke((Action)(() =>
            {
                lsvOutput.BeginUpdate();
                lsvOutput.Items.AddRange(CreateListViewItems(result));

                if (lsvOutput.Items.Count > 0)
                {
                    lsvOutput.EnsureVisible(lsvOutput.Items.Count - 1);
                }

                lsvOutput.EndUpdate();
            }));
        }
 private void OnBuildCompleted(BuildResult result)
 {
     var copy = BuildCompleted;
     if (copy != null)
     {
         copy(result);
     }
 }
        /// <summary>
        /// Represents the build thread, in which the build is running.
        /// </summary>
        /// <param name="parameter">An object-array containing the parameters for this method.</param>
        private void BuildThread(object parameter)
        {
            object[] parameters = (object[])parameter;

            BuildConfigurationNode configuration = (BuildConfigurationNode)parameters[0];
            BuildStartArgs args = (BuildStartArgs)parameters[1];

            // Process and build each item...
            foreach (BuildItemNode buildItem in configuration.BuildItems)
            {
                BuildResult result = new BuildResult();

                BuildLogItem bli = new BuildLogItem();
                bli.ItemName = buildItem.Name;
                bli.BuildStarted = DateTime.UtcNow;

                // shall we build this item?
                if (args.ItemsToBuild == null || args.ItemsToBuild.Contains(buildItem.Name))
                {
                    try
                    {
                        _stopwatch.Restart();

                        // Build the damn thing!
                        result = _projectBuildHandler.Build(buildItem);

                        bli.BuildCompleted = DateTime.UtcNow;
                        _stopwatch.Stop();

                        // add the result to the items
                        result.Items.Add(new BuildInfoItem()
                        {
                            Level = BuildInfoItemLevel.BuildEvent,
                            Text = string.Format("Build of '{0}' finished in '{1}' milliseconds.", buildItem.ToString(), _stopwatch.ElapsedMilliseconds),
                        });

                        OnBuildCompleted(result);
                    }
                    catch (Exception ex)
                    {
                        bli.BuildCompleted = DateTime.UtcNow;
                        string message = string.Format("An exception of type {0} occurred while attempting to build solution item '{1}' with project build handler {2}. The error message was: {3}", ex.GetType().Name, buildItem.Path, _projectBuildHandler.GetType().Name, ex.Message);

                        bli.Errors.Add(message);
                        Debug.WriteLine(message);
                    }
                }
                else
                {
                    bli.BuildCompleted = DateTime.UtcNow;

                    result.AddItem(BuildInfoItemLevel.BuildEvent, "Skipped building '{0}'.", buildItem.Name);
                    OnBuildCompleted(result);
                }

                // Before going on, fill the build log...
                if (result != null && result.Items.Count > 0)
                {
                    foreach (var item in result.Items)
                    {
                        switch (item.Level)
                        {
                            case BuildInfoItemLevel.BuildEvent:
                            case BuildInfoItemLevel.Trace:
                            case BuildInfoItemLevel.Info:
                            default:
                                bli.Infos.Add(item.Text);
                                break;
                            case BuildInfoItemLevel.Warning:
                                bli.Warnings.Add(item.Text);
                                break;
                            case BuildInfoItemLevel.Error:
                                bli.Errors.Add(item.Text);
                                break;
                        }
                    }
                }

                _buildLog.Items.Add(bli);
            }

            _buildLog.BuildCompleted = DateTime.UtcNow;
            _buildLog.CompletionType = BuildCompletionType.RanToCompletion;
            OnBuildFinished(BuildCompletionType.RanToCompletion);
        }