Exportar (0) Imprimir
Expandir todo
Este artículo se tradujo de forma manual. Mueva el puntero sobre las frases del artículo para ver el texto original.
Traducción
Original

BuildWarningEventArgs (Clase)

Proporciona datos para el evento WarningRaised.

Espacio de nombres:  Microsoft.Build.Framework
Ensamblado:  Microsoft.Build.Framework (en Microsoft.Build.Framework.dll)

[SerializableAttribute]
public class BuildWarningEventArgs : LazyFormattedBuildEventArgs

El tipo BuildWarningEventArgs expone los siguientes miembros.

  NombreDescripción
Método protegidoBuildWarningEventArgs()Inicializa una nueva instancia de la clase BuildWarningEventArgs.
Método públicoBuildWarningEventArgs(String, String, String, Int32, Int32, Int32, Int32, String, String, String)Inicializa una nueva instancia de la clase BuildWarningEventArgs con los valores especificados de las propiedades SubCategory(), Code, File, LineNumber, ColumnNumber, EndLineNumber, EndColumnNumber, Message, HelpKeyword y SenderName.
Método públicoBuildWarningEventArgs(String, String, String, Int32, Int32, Int32, Int32, String, String, String, DateTime)Este constructor permite establecer la marca de tiempo
Método públicoBuildWarningEventArgs(String, String, String, Int32, Int32, Int32, Int32, String, String, String, DateTime, Object[])Este constructor permite establecer la marca de tiempo
Arriba

  NombreDescripción
Propiedad públicaBuildEventContextObtiene o establece la información contextual de ubicación. Esta información está asociada a los eventos de registro para definir dónde están localizados con respecto al proceso, motor, proyecto, destino o tarea que está ejecutando. (Se hereda de BuildEventArgs).
Propiedad públicaCodeObtiene el código de advertencia del evento.
Propiedad públicaColumnNumberObtiene el número de columna que corresponde al principio de la sección de código que ha generado el evento.
Propiedad públicaEndColumnNumberObtiene el número de columna que corresponde al final de la sección de código que ha generado el evento.
Propiedad públicaEndLineNumberObtiene el número de línea que corresponde al final de la sección de código que ha generado el evento.
Propiedad públicaFileObtiene el nombre del archivo que generó el evento.
Propiedad públicaHelpKeywordObtiene la palabra clave de Ayuda para el evento. (Se hereda de BuildEventArgs).
Propiedad públicaLineNumberObtiene el número de línea que corresponde al principio de la sección de código que ha generado el evento.
Propiedad públicaMessageObtiene el mensaje con formato. (Se hereda de LazyFormattedBuildEventArgs).
Propiedad públicaProjectFileObtiene o establece el proyecto que se estaba compilando cuando se emitió el mensaje.
Propiedad públicaSenderNameObtiene el nombre del Object que genera el evento. (Se hereda de BuildEventArgs).
Propiedad públicaSubcategoryObtiene la subcategoría personalizada del evento.
Propiedad públicaThreadIdObtiene un identificador entero para el subproceso que generó el evento. (Se hereda de BuildEventArgs).
Propiedad públicaTimestampObtiene la hora a la que se provocó el evento como DateTime. (Se hereda de BuildEventArgs).
Arriba

  NombreDescripción
Método públicoEquals(Object)Determina si el objeto Object especificado es igual al objeto Object actual. (Se hereda de Object).
Método protegidoFinalize Permite que un objeto intente liberar recursos y realizar otras operaciones de limpieza antes de ser reclamado por la recolección de elementos no utilizados. (Se hereda de Object).
Método públicoGetHashCodeActúa como función hash para un tipo concreto. (Se hereda de Object).
Método públicoGetType Obtiene el Type de la instancia actual. (Se hereda de Object).
Método protegidoMemberwiseClone Crea una copia superficial del Object actual. (Se hereda de Object).
Método públicoToString Retorna una cadena que representa al objeto actual. (Se hereda de Object).
Arriba

ADVERTENCIA: marcar un tipo [Serializable] sin implementar ISerializable impone un contrato de serialización; es una propuesta para no cambiar nunca los campos del tipo, por ejemplo. el tipo es inmutable; agregar nuevos campos en la versión siguiente del tipo sin seguir ciertas normas especiales de FX, puede interrumpir la compatibilidad tanto con versiones anteriores como con versiones posteriores

En el ejemplo siguiente se muestra cómo escribir un registrador básico que responde a los eventos de compilación.


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

Compatible con: 4, 3.5, 3.0, 2.0

Windows 7, Windows Vista SP1 o posterior, Windows XP SP3, Windows XP SP2 x64 Edition, Windows Server 2008 (no se admite Server Core), Windows Server 2008 R2 (se admite Server Core con SP1 o posterior), Windows Server 2003 SP2

.NET Framework no admite todas las versiones de todas las plataformas. Para obtener una lista de las versiones compatibles, vea Requisitos de sistema de .NET Framework.

Todos los miembros static (Shared en Visual Basic) públicos de este tipo son seguros para la ejecución de subprocesos. No se garantiza que los miembros de instancias sean seguros para la ejecución de subprocesos.

Adiciones de comunidad

AGREGAR
Mostrar:
© 2014 Microsoft