Share via


Derleme günlükçü oluşturma

Günlükçüler, derlemenizin çıkışını özelleştirmeniz ve belirli derleme olaylarına yanıt olarak iletileri, hataları veya uyarıları görüntülemenizi sağlayan bir yol sağlar. Her günlükçü, Microsoft.Build.Framework.dll derlemesinde tanımlanan arabirimi uygulayan ILogger bir .NET sınıfı olarak uygulanır.

Günlükçü uygularken kullanabileceğiniz iki yaklaşım vardır:

  • ILogger Arabirimi doğrudan uygulayın.

  • Sınıfınızı Microsoft.Build.Utilities.dll derlemesinde tanımlanan yardımcı sınıfından Loggertüretin. Loggerbazı ILogger üyelerin ILogger varsayılan uygulamalarını uygular ve sağlar.

    Bu konu başlığında, öğesinden Loggertüretilen basit bir günlükçü yazma ve bazı derleme olaylarına yanıt olarak konsolda iletileri görüntüleme açıklanmaktadır.

Olaylara kaydolma

Günlükçülerin amacı, derleme altyapısı tarafından bildirilen derleme ilerleme durumu hakkında bilgi toplamak ve ardından bu bilgileri yararlı bir şekilde raporlamaktır. Tüm günlükçüler, günlükçülerin Initialize olaylara kaydolduğu yöntemi geçersiz kılmalıdır. Bu örnekte, günlükçü , ProjectStartedve ProjectFinished olayları için TargetStartedkaydolr.

public class MySimpleLogger : Logger
{
    public override void Initialize(Microsoft.Build.Framework.IEventSource eventSource)
    {
        //Register for the ProjectStarted, TargetStarted, and ProjectFinished events
        eventSource.ProjectStarted += new ProjectStartedEventHandler(eventSource_ProjectStarted);
        eventSource.TargetStarted += new TargetStartedEventHandler(eventSource_TargetStarted);
        eventSource.ProjectFinished += new ProjectFinishedEventHandler(eventSource_ProjectFinished);
    }

Olaylara yanıt verme

Günlükçü belirli olaylar için kayıtlı olduğuna göre, bu olayları gerçekleştiğinde işlemesi gerekir. ProjectStartedve ProjectFinished olayları için günlükçü basitçe kısa bir tümcecik ve olaya dahil olan proje dosyasının adını yazar. Günlükçüden gelen tüm iletiler konsol penceresine yazılır.


void eventSource_ProjectStarted(object sender, ProjectStartedEventArgs e)
{
    Console.WriteLine("Project Started: " + e.ProjectFile);			
}

void eventSource_ProjectFinished(object sender, ProjectFinishedEventArgs e)
{
    Console.WriteLine("Project Finished: " + e.ProjectFile);
}

Günlükçü ayrıntı değerlerine yanıt verme

Bazı durumlarda, yalnızca MSBuild.exe -verbosity anahtarı belirli bir değer içeriyorsa bir olaydaki bilgileri günlüğe kaydetmek isteyebilirsiniz. Bu örnekte, TargetStarted olay işleyicisi yalnızca -verbosity anahtarı tarafından ayarlanan özelliği değerine eşitse Verbosity bir ileti günlüğe LoggerVerbosityDetailedkaydeder.

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

Günlükçü belirtme

Günlükçü bir derlemede derlendiğinde, DERLEMEler sırasında MSBuild'e bu günlükçüsü kullanmasını söylemeniz gerekir. Bu işlem MSBuild.exe ile -logger anahtarı kullanılarak yapılır. MSBuild.exe için kullanılabilen anahtarlar hakkında daha fazla bilgi için bkz. Komut satırı başvurusu.

Aşağıdaki komut satırı MyProject.csproj projesini oluşturur ve SimpleLogger.dll dosyasında uygulanan günlükçü sınıfını kullanır. -nologo anahtarı başlık ve telif hakkı iletisini gizler ve -noconsolelogger anahtarı varsayılan MSBuild konsol günlükçüsünü devre dışı bırakır.

MSBuild -nologo -noconsolelogger -logger:SimpleLogger.dll

Aşağıdaki komut satırı projeyi aynı günlükçü ile ancak düzeyiyle VerbosityDetailedoluşturur.

MSBuild -nologo -noconsolelogger -logger:SimpleLogger.dll -verbosity:Detailed

Örnek 1

Açıklama

Aşağıdaki örnek günlükçü için tam kodu içerir.

Kod

using System;
using Microsoft.Build.Utilities;
using Microsoft.Build.Framework;

namespace SimpleLogger
{

    public class MySimpleLogger : Logger
    {
        public override void Initialize(Microsoft.Build.Framework.IEventSource eventSource)
        {
            //Register for the ProjectStarted, TargetStarted, and ProjectFinished events
            eventSource.ProjectStarted += new ProjectStartedEventHandler(eventSource_ProjectStarted);
            eventSource.TargetStarted += new TargetStartedEventHandler(eventSource_TargetStarted);
            eventSource.ProjectFinished += new ProjectFinishedEventHandler(eventSource_ProjectFinished);
        }

        void eventSource_ProjectStarted(object sender, ProjectStartedEventArgs e)
        {
            Console.WriteLine("Project Started: " + e.ProjectFile);			
        }

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

Örnek 2

Açıklama

Aşağıdaki örnekte, günlüğü konsol penceresinde görüntülemek yerine bir dosyaya yazan bir günlükçü nasıl uygulanacak gösterilmektedir.

Kod

using System;
using System.IO;
using System.Security;
using Microsoft.Build.Framework;
using Microsoft.Build.Utilities;

namespace MyLoggers
{
    // This logger will derive from the Microsoft.Build.Utilities.Logger class,
    // which provides it with getters and setters for Verbosity and Parameters,
    // and a default empty Shutdown() implementation.
    public class BasicFileLogger : Logger
    {
        /// <summary>
        /// Initialize is guaranteed to be called by MSBuild at the start of the build
        /// before any events are raised.
        /// </summary>
        public override void Initialize(IEventSource eventSource)
        {
            // The name of the log file should be passed as the first item in the
            // "parameters" specification in the /logger switch.  It is required
            // to pass a log file to this logger. Other loggers may have zero or more than 
            // one parameters.
            if (null == Parameters)
            {
                throw new LoggerException("Log file was not set.");
            }
            string[] parameters = Parameters.Split(';');
            
            string logFile = parameters[0];
            if (String.IsNullOrEmpty(logFile))
            {
                throw new LoggerException("Log file was not set.");
            }
            
            if (parameters.Length > 1)
            {
                throw new LoggerException("Too many parameters passed.");
            }
            
            try
            {
                // Open the file
                this.streamWriter = new StreamWriter(logFile);
            }
            catch (Exception ex)
            {
                if
                (
                    ex is UnauthorizedAccessException
                    || ex is ArgumentNullException
                    || ex is PathTooLongException
                    || ex is DirectoryNotFoundException
                    || ex is NotSupportedException
                    || ex is ArgumentException
                    || ex is SecurityException
                    || ex is IOException
                )
                {
                    throw new LoggerException("Failed to create log file: " + ex.Message);
                }
                else
                {
                    // Unexpected failure
                    throw;
                }
            }

            // For brevity, we'll only register for certain event types. Loggers can also
            // register to handle TargetStarted/Finished and other events.
            eventSource.ProjectStarted += new ProjectStartedEventHandler(eventSource_ProjectStarted);
            eventSource.TaskStarted += new TaskStartedEventHandler(eventSource_TaskStarted);
            eventSource.MessageRaised += new BuildMessageEventHandler(eventSource_MessageRaised);
            eventSource.WarningRaised += new BuildWarningEventHandler(eventSource_WarningRaised);
            eventSource.ErrorRaised += new BuildErrorEventHandler(eventSource_ErrorRaised);
            eventSource.ProjectFinished += new ProjectFinishedEventHandler(eventSource_ProjectFinished);
        }

        void eventSource_ErrorRaised(object sender, BuildErrorEventArgs e)
        {
            // BuildErrorEventArgs adds LineNumber, ColumnNumber, File, amongst other parameters
            string line = String.Format(": ERROR {0}({1},{2}): ", e.File, e.LineNumber, e.ColumnNumber);
            WriteLineWithSenderAndMessage(line, e);
        }
        
        void eventSource_WarningRaised(object sender, BuildWarningEventArgs e)
        {
            // BuildWarningEventArgs adds LineNumber, ColumnNumber, File, amongst other parameters
            string line = String.Format(": Warning {0}({1},{2}): ", e.File, e.LineNumber, e.ColumnNumber);
            WriteLineWithSenderAndMessage(line, e);
        }

        void eventSource_MessageRaised(object sender, BuildMessageEventArgs e)
        {
            // BuildMessageEventArgs adds Importance to BuildEventArgs
            // Let's take account of the verbosity setting we've been passed in deciding whether to log the message
            if ((e.Importance == MessageImportance.High && IsVerbosityAtLeast(LoggerVerbosity.Minimal))
                || (e.Importance == MessageImportance.Normal && IsVerbosityAtLeast(LoggerVerbosity.Normal))
                || (e.Importance == MessageImportance.Low && IsVerbosityAtLeast(LoggerVerbosity.Detailed))				
                )
            {
                WriteLineWithSenderAndMessage(String.Empty, e);
            }
        }

        void eventSource_TaskStarted(object sender, TaskStartedEventArgs e)
        {
            // TaskStartedEventArgs adds ProjectFile, TaskFile, TaskName
            // To keep this log clean, this logger will ignore these events.
        }
        
        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++;
        }

        void eventSource_ProjectFinished(object sender, ProjectFinishedEventArgs e)
        {
            // The regular message string is good enough here too.
            indent--;
            WriteLine(String.Empty, e);
        }
        
        /// <summary>
        /// Write a line to the log, adding the SenderName and Message
        /// (these parameters are on all MSBuild event argument objects)
        /// </summary>
        private void WriteLineWithSenderAndMessage(string line, BuildEventArgs e)
        {
            if (0 == String.Compare(e.SenderName, "MSBuild", true /*ignore case*/))
            {
                // Well, if the sender name is MSBuild, let's leave it out for prettiness
                WriteLine(line, e);
            }
            else
            {
                WriteLine(e.SenderName + ": " + line, e);
            }
        }
        
        /// <summary>
        /// Just write a line to the log
        /// </summary>
        private void WriteLine(string line, BuildEventArgs e)
        {
            for (int i = indent; i > 0; i--)
            {
                streamWriter.Write("\t");
            }
            streamWriter.WriteLine(line + e.Message);
        }
        
        /// <summary>
        /// Shutdown() is guaranteed to be called by MSBuild at the end of the build, after all 
        /// events have been raised.
        /// </summary>
        public override void Shutdown()
        {
            // Done logging, let go of the file
            streamWriter.Close();
        }

        private StreamWriter streamWriter;
        private int indent;
    }
}