Exportar (0) Imprimir
Expandir Tudo
Este artigo foi traduzido por máquina. Coloque o ponteiro do mouse sobre as frases do artigo para ver o texto original. Mais informações.
Tradução
Original

Classe LoggerException

Permite que um agente de log forçar a compilação para parar de forma explícita.

System.Object
  System.Exception
    Microsoft.Build.Framework.LoggerException

Namespace:  Microsoft.Build.Framework
Assembly:  Microsoft.Build.Framework (em Microsoft.Build.Framework.dll)

[SerializableAttribute]
public class LoggerException : Exception

O tipo LoggerException expõe os membros a seguir.

  NomeDescrição
Método públicoLoggerException()Initializes a new instance of the LoggerException class.
Método públicoLoggerException(String)Inicializa uma nova instância de LoggerException classe com os valores especificados.
Método protegidoLoggerException(SerializationInfo, StreamingContext)Inicializa uma nova instância de LoggerException a classe com os valores especificados.
Método públicoLoggerException(String, Exception)Inicializa uma nova instância de LoggerException a classe com os valores especificados.
Método públicoLoggerException(String, Exception, String, String)Inicializa uma nova instância de LoggerException a classe com os valores especificados.
Início

  NomeDescrição
Propriedade públicaData Obtém uma coleção de pares chave/valor que fornecem informações adicionais definidas pelo usuário sobre a exceção. (Herdado de Exception.)
Propriedade públicaErrorCodeObtém o código de erro associado a mensagem da exceção.
Propriedade públicaHelpKeywordObtém a palavra-chave de Ajuda F1 associada a esse erro.
Propriedade públicaHelpLinkObtém ou define um link para o arquivo de ajuda associado a esta exceção. (Herdado de Exception.)
Propriedade protegidaHResultObtém ou define HRESULT, um valor numérico codificado que é atribuído a uma exceção específica. (Herdado de Exception.)
Propriedade públicaInnerExceptionObtém a instância de Exception que causou a exceção atual. (Herdado de Exception.)
Propriedade públicaMessageRecebe uma mensagem que descreve a exceção atual. (Herdado de Exception.)
Propriedade públicaSource Obtém ou define o nome do aplicativo ou do objeto que causa o erro. (Herdado de Exception.)
Propriedade públicaStackTraceObtém uma representação de seqüência de caracteres dos quadros imediatas na pilha de chamadas. (Herdado de Exception.)
Propriedade públicaTargetSiteObtém o método que gera a exceção atual. (Herdado de Exception.)
Início

  NomeDescrição
Método públicoEquals(Object) Determina se o Object especificado é igual ao Object atual. (Herdado de Object.)
Método protegidoFinalize Permite um objeto tentar liberar recursos e executar outras operações de limpeza antes que ele seja recuperado pela coleta de lixo. (Herdado de Object.)
Método públicoGetBaseException Quando substituído em uma classe derivada, retorna a Exception que é a causa raiz de uma ou mais exceções subsequentes. (Herdado de Exception.)
Método públicoGetHashCodeServe como uma função hash para um tipo específico. (Herdado de Object.)
Método públicoGetObjectDataConjuntos de SerializationInfo com informações sobre a exceção. (Substitui Exception.GetObjectData(SerializationInfo, StreamingContext).)
Método públicoGetType Obtém o tipo em tempo de execução da instância atual. (Herdado de Exception.)
Método protegidoMemberwiseCloneCria uma cópia superficial do Object atual. (Herdado de Object.)
Método públicoToString Cria e retorna uma representação da cadeia de caracteres da exceção atual. (Herdado de Exception.)
Início

  NomeDescrição
Evento protegidoSerializeObjectStateOcorre quando uma exceção é serializada criar um objeto de estado de exceção contém dados sobre a exceção de serializado. (Herdado de Exception.)
Início

Essa exceção pode ser usada por um agente de log para indicar a um host que ele recebeu parâmetros inválidos, ou não pode continuar o log por algum motivo e quer parar de maneira controlada.

O exemplo a seguir mostra como escrever um agente de log básico que responde a eventos de compilação.


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;
	}
}


.NET Framework

Com suporte em: 4, 3.5, 3.0, 2.0

Windows 7, Windows Vista SP1 ou posterior, Windows XP SP3, Windows XP SP2 x64 Edition, Windows Server 2008 (Server Core não compatível), Windows Server 2008 R2 (Server Core não compatível com SP1 ou posterior), Windows Server 2003 SP2

O .NET Framework não oferece suporte a todas as versões de cada plataforma. Para obter uma lista das versões com suporte, consulte Requisitos de sistema do .NET Framework.

Quaisquer membros static (Shared no Visual Basic) públicos deste tipo são thread-safe. Não há garantia de que qualquer membro de instância seja thread-safe.

Contribuições da comunidade

ADICIONAR
Mostrar:
© 2015 Microsoft