EventSchemaTraceListener Clase

Referencia

Definición

Espacio de nombres:: System.Diagnostics

Ensamblado:: System.Core.dll

Importante

Parte de la información hace referencia a la versión preliminar del producto, que puede haberse modificado sustancialmente antes de lanzar la versión definitiva. Microsoft no otorga ninguna garantía, explícita o implícita, con respecto a la información proporcionada aquí.

Dirige los resultados de seguimiento o de depuración de eventos de un extremo a otro a un archivo de registro con codificación XML conforme al esquema.

public ref class EventSchemaTraceListener : System::Diagnostics::TextWriterTraceListener

public class EventSchemaTraceListener : System.Diagnostics.TextWriterTraceListener

type EventSchemaTraceListener = class
    inherit TextWriterTraceListener

Public Class EventSchemaTraceListener
Inherits TextWriterTraceListener

Herencia: Object

MarshalByRefObject

TraceListener

TextWriterTraceListener
EventSchemaTraceListener

Ejemplos

En el ejemplo de código siguiente se muestra cómo usar la EventSchemaTraceListener clase .


///////////////////////////////////////////////////////////////////////
//
// EventSchemaTraceListener.cpp : main project file.
// Expected Output:
// 1)
//      EventSchemaTraceListener CPP Sample
//
//      IsThreadSafe? True
//      BufferSize =  65536
//      MaximumFileSize =  20480000
//      MaximumNumberOfFiles =  2
//      Name =  eventListener
//      TraceLogRetentionOption = LimitedCircularFiles
//      TraceOutputOptions = DateTime, Timestamp, ProcessId
//
//      Press the enter key to exit
//
// 2) An output file is created named TraceOutput.xml.  It will be
//    opened and displayed in Microsoft Notepad.
//
// NOTE 1:
//  Under certain circumstances, the VS C++ compiler will treat
//          Console::WriteLine("MyText = " + MyVar);
//        differently then the VS CSharp compiler.
//        The C++ compiler will produce error C3063, whereas the 
//        CSharp compiler accepts the statement.
//        This occurs when the VS C++ compiler cannot determine the
//        datatype of "MyVar" because it is an enumeration type.
//        The solution is:
//        Use either of the following two methods:
//          Console::WriteLine("MyText = {0} " , MyVar);
//          Console::WriteLine("MyText =  " + MyVar.ToString());
//
//        Although not specific to this particular pieces of code,
//        this is demonstrated below in the Display function:  The
//        last two members, TraceLogRetentionOption, and
//        TraceOutputOptions, are enumerations, and cannot simply be
//        concatenated into Console::WriteLine.
//
///////////////////////////////////////////////////////////////////////
#using <System.dll>
#using <System.Core.dll>

#define NOCONFIGFILE 1
using namespace System;
using namespace System::IO;
using namespace System::Diagnostics;


[STAThreadAttribute]
void main()
{
    Console::WriteLine("EventSchemaTraceListener CPP Sample\n");

    File::Delete("TraceOutput.xml");
    TraceSource ^ ts = gcnew TraceSource("TestSource");


#if NOCONFIGFILE
    ts->Listeners->Add(gcnew EventSchemaTraceListener("TraceOutput.xml",
                            "eventListener", 65536,
                            TraceLogRetentionOption::LimitedCircularFiles,
                            20480000, 2));
    ts->Listeners["eventListener"]->TraceOutputOptions =
                                    TraceOptions::DateTime |
                                    TraceOptions::ProcessId |
                                    TraceOptions::Timestamp;
#endif

    EventSchemaTraceListener ^ ESTL =
               (EventSchemaTraceListener^)(ts->Listeners["eventListener"]);


    Console::WriteLine("IsThreadSafe?            = " + ESTL->IsThreadSafe);
    Console::WriteLine("BufferSize               = " + ESTL->BufferSize);
    Console::WriteLine("MaximumFileSize          = " + ESTL->MaximumFileSize);
    Console::WriteLine("MaximumNumberOfFiles     = " + ESTL->MaximumNumberOfFiles);
    Console::WriteLine("Name                     = " + ESTL->Name);
    Console::WriteLine("TraceLogRetentionOption  = " + ESTL->TraceLogRetentionOption.ToString());
    Console::WriteLine("TraceOutputOptions       = {0}\n", ESTL->TraceOutputOptions);

    ts->Switch->Level = SourceLevels::All;
    String ^ testString = "<Test><InnerElement Val=\"1\" />"
                        + "<InnerElement Val=\"Data\"/>"
                        + "<AnotherElement>11</AnotherElement></Test>";

    UnescapedXmlDiagnosticData ^ unXData = gcnew UnescapedXmlDiagnosticData(testString);
    ts->TraceData(TraceEventType::Error, 38, unXData);
    ts->TraceEvent(TraceEventType::Error, 38, testString);
    ts->Flush();
    ts->Close();

    Process::Start("notepad.exe", "TraceOutput.xml");
    Console::WriteLine("\nPress the enter key to exit");
    Console::ReadLine();
}

#define NOCONFIGFILE
using System;
using System.IO;
using System.Xml;
using System.Xml.XPath;
using System.Diagnostics;

class testClass
{
    [STAThreadAttribute]
    static void Main()
    {
        File.Delete("TraceOutput.xml");
        TraceSource ts = new TraceSource("TestSource");
#if NOCONFIGFILE
        //ts.Listeners.Add(new EventSchemaTraceListener("TraceOutput.xml", "eventListener", 65536, TraceLogRetentionOption.LimitedCircularFiles, 20480000, 2));
        ts.Listeners.Add(new EventSchemaTraceListener("TraceOutput.xml", "eventListener"));
        ts.Listeners["eventListener"].TraceOutputOptions = TraceOptions.DateTime | TraceOptions.ProcessId | TraceOptions.Timestamp;
#endif
        ts.Switch.Level = SourceLevels.All;
        string testString = "<Test><InnerElement Val=\"1\" /><InnerElement Val=\"Data\"/><AnotherElement>11</AnotherElement></Test>";
        UnescapedXmlDiagnosticData unXData = new UnescapedXmlDiagnosticData(testString);
        ts.TraceData(TraceEventType.Error, 38, unXData);
        ts.TraceEvent(TraceEventType.Error, 38, testString);
        Trace.Listeners.Add(new EventSchemaTraceListener("TraceOutput.xml"));
        Trace.Write("test", "test");
        Trace.Flush();
        ts.Flush();
        ts.Close();
        DisplayProperties(ts);
        Process.Start("notepad.exe", "TraceOutput.xml");
        Console.WriteLine("Press the enter key to exit");
        Console.ReadLine();
    }
    private static void DisplayProperties(TraceSource ts)
    {
        Console.WriteLine("IsThreadSafe? " + ((EventSchemaTraceListener)ts.Listeners["eventListener"]).IsThreadSafe);
        Console.WriteLine("BufferSize =  " + ((EventSchemaTraceListener)ts.Listeners["eventListener"]).BufferSize);
        Console.WriteLine("MaximumFileSize =  " + ((EventSchemaTraceListener)ts.Listeners["eventListener"]).MaximumFileSize);
        Console.WriteLine("MaximumNumberOfFiles =  " + ((EventSchemaTraceListener)ts.Listeners["eventListener"]).MaximumNumberOfFiles);
        Console.WriteLine("Name =  " + ((EventSchemaTraceListener)ts.Listeners["eventListener"]).Name);
        Console.WriteLine("TraceLogRetentionOption =  " + ((EventSchemaTraceListener)ts.Listeners["eventListener"]).TraceLogRetentionOption);
        Console.WriteLine("TraceOutputOptions =  " + ((EventSchemaTraceListener)ts.Listeners["eventListener"]).TraceOutputOptions);
    }
}

#Const NOCONFIGFILE = True
Imports System.IO
Imports System.Xml
Imports System.Xml.XPath
Imports System.Diagnostics

Class testClass

    <STAThreadAttribute()> _
    Shared Sub Main()
        File.Delete("TraceOutput.xml")
        Dim ts As New TraceSource("TestSource")
#If NOCONFIGFILE Then
        ts.Listeners.Add(New EventSchemaTraceListener("TraceOutput.xml", "eventListener", 65536, TraceLogRetentionOption.LimitedCircularFiles, 20480000, 2))
        ts.Listeners("eventListener").TraceOutputOptions = TraceOptions.DateTime Or TraceOptions.ProcessId Or TraceOptions.Timestamp
#End If
        ts.Switch.Level = SourceLevels.All
        Dim testString As String = "<Test><InnerElement Val=""1"" /><InnerElement Val=""Data""/><AnotherElement>11</AnotherElement></Test>"
        Dim unXData As New UnescapedXmlDiagnosticData(testString)
        ts.TraceData(TraceEventType.Error, 38, unXData)
        ts.TraceEvent(TraceEventType.Error, 38, testString)
        ts.Flush()
        ts.Close()
        DisplayProperties(ts)
        Process.Start("notepad.exe", "TraceOutput.xml")
        Console.WriteLine("Press the enter key to exit")
        Console.ReadLine()

    End Sub

    Private Shared Sub DisplayProperties(ByVal ts As TraceSource)
        Console.WriteLine("IsThreadSafe? " + CType(ts.Listeners("eventListener"), EventSchemaTraceListener).IsThreadSafe.ToString())
        Console.WriteLine("BufferSize =  " + CType(ts.Listeners("eventListener"), EventSchemaTraceListener).BufferSize.ToString())
        Console.WriteLine("MaximumFileSize =  " + CType(ts.Listeners("eventListener"), EventSchemaTraceListener).MaximumFileSize.ToString())
        Console.WriteLine("MaximumNumberOfFiles =  " + CType(ts.Listeners("eventListener"), EventSchemaTraceListener).MaximumNumberOfFiles.ToString())
        Console.WriteLine("Name =  " + CType(ts.Listeners("eventListener"), EventSchemaTraceListener).Name)
        Console.WriteLine("TraceLogRetentionOption =  " + CType(ts.Listeners("eventListener"), EventSchemaTraceListener).TraceLogRetentionOption.ToString())
        Console.WriteLine("TraceOutputOptions =  " + CType(ts.Listeners("eventListener"), EventSchemaTraceListener).TraceOutputOptions.ToString())
    End Sub
End Class

Comentarios

La EventSchemaTraceListener clase proporciona un seguimiento de eventos compatibles con el esquema de un extremo a otro. Puede usar el seguimiento de un extremo a otro para un sistema que tenga componentes heterogéneos que entre subprocesos, AppDomain, procesos y límites de equipo. Un esquema de eventos estandarizado permite el seguimiento a través de estos límites. El esquema permite agregar elementos personalizados y compatibles con el esquema. Puede usar service Trace Viewer Tool (SvcTraceViewer.exe) para mostrar los datos del evento.

EventSchemaTraceListener está optimizado para el rendimiento del registro con compatibilidad implícita para el seguimiento sin bloqueos.

La EventSchemaTraceListener clase convierte la información de seguimiento y depuración en una secuencia de texto codificada en XML. La descripción de la salida XML se muestra en las tablas más adelante en esta sección.

Puede crear un EventSchemaTraceListener objeto en el código. Como alternativa, para las aplicaciones de .NET Framework, puede habilitar o deshabilitar un EventSchemaTraceListener objeto a través del archivo de configuración de la aplicación y, a continuación, usar el objeto configurado EventSchemaTraceListener en la aplicación. Para obtener información sobre el uso de archivos de configuración para el seguimiento y la depuración en aplicaciones de .NET Framework, vea Esquema de configuración de seguimiento y depuración.

Para configurar un EventSchemaTraceListener objeto en una aplicación de .NET Framework, modifique el archivo de configuración que corresponde al nombre de la aplicación. En este archivo, puede agregar, quitar o establecer las propiedades de un agente de escucha. El archivo de configuración debe tener el formato siguiente:

<configuration>  
    <system.diagnostics>  
        <sources>  
            <source name="TestSource" >  
                <listeners>  
                    <!--Remove the default trace listener for better performance.-->  
                    <remove name="Default"/>  
                    <!--Note: Removing the default trace listener prevents the dialog box   
                    from being displayed for Debug.Fail or Debug.Assert commands that are   
                    executed in user mode.-->  
                    <add name="eventListener"   
                      type="System.Diagnostics.EventSchemaTraceListener,  system.core"  
                      initializeData="TraceOutput.xml"   
                      traceOutputOptions="ProcessId, DateTime, Timestamp"   
                      bufferSize="65536"  
                      maximumFileSize="20480000"  
                      logRetentionOption="LimitedCircularFiles"  
                      maximumNumberOfFiles="2"/>  
                </listeners>  
            </source>  
        </sources>  
    </system.diagnostics>

La EventSchemaTraceListener clase hereda la Filter propiedad de la clase TraceListenerbase . La Filter propiedad permite un nivel adicional de filtrado de salida de seguimiento en el agente de escucha. Si hay un filtro presente, los Trace métodos del agente de escucha de seguimiento llaman al ShouldTrace método del filtro para determinar si se va a emitir el seguimiento.

Si se intenta escribir en un archivo que se está usando o no está disponible, se agrega automáticamente un sufijo GUID al nombre de archivo.

Nota

Los métodos de escucha están diseñados para llamarse mediante métodos de las Debugclases , Tracey TraceSource . No llame a los métodos de escucha directamente desde el código de la aplicación. El EventSchemaTraceListener agente de escucha está pensado principalmente para su uso por parte de la TraceSource clase .

En la tabla siguiente se describen los elementos y atributos de la salida XML.

Elemento	Atributos	Resultados	Notas
`CallStack`	Ninguno	Depende de la presencia de la Callstack marca en la TraceOutputOptions propiedad .	Caracteres especiales como > o < se reemplazan por secuencias de escape. Vea la tabla de traducción de caracteres con escape en la tabla siguiente.
`Computer`	Ninguno	Siempre está presente.	Este elemento representa el valor de la MachineName propiedad .
`Correlation`	`ActivityID`	Siempre está presente.	Si `ActivityID` no se especifica, el valor predeterminado es un GUID vacío.
	`RelatedActivityID`	Depende de la presencia del `relatedActivityId` parámetro en la llamada al `Trace` método.	El `RelatedActivityID` atributo corresponde al `relatedActivityId` parámetro del TraceTransfer método .
`Data`	Ninguno	Siempre está presente.	Este elemento representa la entrada de parámetros (`data`). Se proporciona un elemento para cada objeto de datos. En el caso de los registros de eventos, el `Data` elemento contiene datos XML de escape. En el caso de los registros de datos, el `Data` elemento contiene datos sin escape. La salida del registro de datos usa el `ToString` método de los objetos de datos pasados.
`Event`	Ninguno	Siempre está presente.	Este elemento contiene un evento de seguimiento.
`EventData`	Ninguno	Presente para los registros de eventos.	Este elemento representa la entrada de parámetros (`message`, `args`). Contiene `Data` elementos con datos XML de escape creados mediante una llamada al TraceEvent método .
`EventID`	Ninguno	Siempre está presente.	Este elemento representa la entrada de parámetros (`id`).
`Execution`	`ProcessID`	Depende de la presencia de la ProcessId marca en la TraceOutputOptions propiedad .	El `ProcessID` atributo se especifica en .TraceEventCache
	`ThreadID`	Presente cuando `ProcessID` está presente.	El `ThreadID` atributo se especifica en .TraceEventCache
`Level`	Ninguno	Siempre está presente.	Este elemento representa la entrada de parámetros (el valor numérico de `eventType`). Los valores de parámetro que son mayores de 255 se generan como un nivel 8, que representa TraceEventType.Information. Los tipos Criticalde eventos de seguimiento , Error, Warning, Informationy Verbose son resultados como niveles 1, 2, 4, 8 y 10, respectivamente.
`LogicalOperationStack`	Ninguno	Depende de la presencia de la LogicalOperationStack marca en la TraceOutputOptions propiedad .	Solo puede existir una operación lógica. Por lo tanto, los valores se escriben como `LogicalOperation` nodos en el `LogicalOperationStack` elemento .
`OpCode`	Ninguno	Presente cuando `Level` es mayor que 255.	Este elemento representa los tipos de eventos Trace que tienen valores numéricos mayores que 255. Start, , Stop Suspend, Resumeo Transfer son resultados como niveles 1, 2, 4, 8 y 10, respectivamente.
`Provider`	`GUID`	Siempre está presente.	Siempre vacía.
`RenderingInfo`	`Culture`	Siempre está presente.	Este atributo representa una cadena de recurso para el tipo de evento. Siempre es "en-EN\".
`System`	`Name`	Siempre está presente.
`TimeCreated`	`SystemTime`	Depende de la presencia de la DateTime marca en la TraceOutputOptions propiedad .	La hora es el valor de la TraceEventCache.DateTime propiedad . Esta propiedad se expresa como hora universal coordinada
`TimeStamp`	Ninguno	Depende de la presencia de la Timestamp marca en la TraceOutputOptions propiedad .	Este elemento se especifica en .TraceEventCache
`UserData`	Ninguno	Presente para los registros de datos.	Este elemento contiene `Data` elementos con datos proporcionados por el usuario sin escape de un TraceData método .

En la tabla siguiente se muestran los caracteres que se escapan en la salida XML. El escape se produce en todos los elementos y atributos, excepto en el elemento , que contiene datos sin escape proporcionados por el UserData usuario. El UserData elemento es el resultado de las llamadas al TraceData método .

Carácter de escape	Valor
&	&
<	<
>	>
"	"
\|'
0xD
0xA

Constructores

EventSchemaTraceListener(String)	Inicializa una nueva instancia de la clase EventSchemaTraceListener y usa el archivo especificado como destinatario de los resultados de seguimiento o de depuración.
EventSchemaTraceListener(String, String)	Inicializa una nueva instancia de la clase EventSchemaTraceListener con el nombre especificado y usa el archivo especificado como destinatario de los resultados de seguimiento o de depuración.
EventSchemaTraceListener(String, String, Int32)	Inicializa una nueva instancia de la clase EventSchemaTraceListener con el nombre especificado y el tamaño de búfer especificado, y usa el archivo especificado como destinatario de los resultados de seguimiento o de depuración.
EventSchemaTraceListener(String, String, Int32, TraceLogRetentionOption)	Inicializa una nueva instancia de la clase EventSchemaTraceListener con el nombre especificado y el tamaño de búfer especificado, y usa el archivo especificado, con la directiva de retención de registro especificada, como destinatario de los resultados de seguimiento o de depuración.
EventSchemaTraceListener(String, String, Int32, TraceLogRetentionOption, Int64)	Inicializa una nueva instancia de la clase EventSchemaTraceListener con el nombre especificado y el tamaño de búfer especificado, y usa el archivo especificado, con la directiva de retención de registro especificada y el tamaño máximo, como destinatario de los resultados de seguimiento o de depuración.
EventSchemaTraceListener(String, String, Int32, TraceLogRetentionOption, Int64, Int32)	Inicializa una nueva instancia de la clase EventSchemaTraceListener con el nombre especificado y el tamaño de búfer especificado, y usa el archivo especificado, con la directiva de retención de registro especificada, el tamaño máximo y el recuento de archivos, como destinatario de los resultados de seguimiento o de depuración.

Propiedades

Attributes	Obtiene los atributos de agente de escucha de seguimiento personalizados que están definidos en el archivo de configuración de la aplicación. (Heredado de TraceListener)
BufferSize	Obtiene el tamaño del búfer de salida.
Filter	Obtiene o establece el filtro de seguimiento para el agente de escucha de seguimiento. (Heredado de TraceListener)
IndentLevel	Obtiene o establece el nivel de sangría. (Heredado de TraceListener)
IndentSize	Obtiene o establece el número de espacios de una sangría. (Heredado de TraceListener)
IsThreadSafe	Obtiene un valor que indica si el agente de escucha de seguimiento es seguro para la ejecución de subprocesos.
MaximumFileSize	Obtiene el tamaño máximo del archivo de registro.
MaximumNumberOfFiles	Obtiene el número máximo de archivos de registro.
Name	Obtiene o establece un nombre para este objeto TraceListener. (Heredado de TraceListener)
NeedIndent	Obtiene o establece un valor que indica si se va a aplicar sangría a los resultados. (Heredado de TraceListener)
TraceLogRetentionOption	Obtiene la opción de retención de registro del seguimiento para el archivo.
TraceOutputOptions	Obtiene o establece las opciones de los resultados de seguimiento. (Heredado de TraceListener)
Writer	Obtiene o establece el escritor de texto subyacente que escribe en el archivo de registro.

Métodos

Close()	Cierra el archivo de registro para este agente de escucha, de modo que ya no recibe ningún resultado de seguimiento o de depuración.
CreateObjRef(Type)	Crea un objeto que contiene toda la información relevante necesaria para generar un proxy utilizado para comunicarse con un objeto remoto. (Heredado de MarshalByRefObject)
Dispose()	Libera todos los recursos que usa TraceListener. (Heredado de TraceListener)
Dispose(Boolean)	Desecha este objeto TextWriterTraceListener. (Heredado de TextWriterTraceListener)
Equals(Object)	Determina si el objeto especificado es igual que el objeto actual. (Heredado de Object)
Fail(String)	Emite un mensaje de error para el agente de escucha que se crea al implementar la clase TraceListener. (Heredado de TraceListener)
Fail(String, String)	Escribe la información de error, que incluye un mensaje de error básico y un mensaje de error detallado, en el archivo de registro.
Flush()	Hace que los datos almacenados en el búfer se escriban en el registro para este agente de escucha.
GetHashCode()	Sirve como la función hash predeterminada. (Heredado de Object)
GetLifetimeService()	Obsoletos. Recupera el objeto de servicio de duración actual que controla la directiva de duración de esta instancia. (Heredado de MarshalByRefObject)
GetSupportedAttributes()	Obtiene los atributos de configuración XML personalizados que admite el agente de escucha de seguimiento.
GetType()	Obtiene el Type de la instancia actual. (Heredado de Object)
InitializeLifetimeService()	Obsoletos. Obtiene un objeto de servicio de duración para controlar la directiva de duración de esta instancia. (Heredado de MarshalByRefObject)
MemberwiseClone()	Crea una copia superficial del Object actual. (Heredado de Object)
MemberwiseClone(Boolean)	Crea una copia superficial del objeto MarshalByRefObject actual. (Heredado de MarshalByRefObject)
ToString()	Devuelve una cadena que representa el objeto actual. (Heredado de Object)
TraceData(TraceEventCache, String, TraceEventType, Int32, Object)	Escribe la información de seguimiento, un solo objeto de datos y la información de los eventos en el archivo de registro.
TraceData(TraceEventCache, String, TraceEventType, Int32, Object[])	Escribe la información de seguimiento, varios objetos de datos y la información de los eventos en el archivo de registro.
TraceEvent(TraceEventCache, String, TraceEventType, Int32)	Escribe la información de seguimiento y de evento en los resultados específicos del agente de escucha. (Heredado de TraceListener)
TraceEvent(TraceEventCache, String, TraceEventType, Int32, String)	Escribe la información de seguimiento, un mensaje y la información de los eventos en el archivo de registro.
TraceEvent(TraceEventCache, String, TraceEventType, Int32, String, Object[])	Escribe la información del seguimiento, un mensaje con formato y la información de los eventos en el archivo de registro.
TraceTransfer(TraceEventCache, String, Int32, String, Guid)	Escribe la información de seguimiento (incluida la identidad de una actividad relacionada), un mensaje y la información de eventos en el archivo de registro.
Write(Object)	Escribe el valor del método ToString() del objeto en el agente de escucha que se crea al implementar la clase TraceListener. (Heredado de TraceListener)
Write(Object, String)	Escribe un nombre de categoría y el valor del método ToString() del objeto en el agente de escucha que se crea al implementar la clase TraceListener. (Heredado de TraceListener)
Write(String)	Escribe un mensaje en el archivo de registro sin proporcionar ninguna información de contexto adicional.
Write(String, String)	Escribe un nombre de categoría y un mensaje en el agente de escucha que se crea al implementar la clase TraceListener. (Heredado de TraceListener)
WriteIndent()	Escribe la sangría en el agente de escucha que se crea al implementar esta clase y restablece la propiedad NeedIndent en `false`. (Heredado de TraceListener)
WriteLine(Object)	Escribe el valor del método ToString() del objeto en el agente de escucha que se crea al implementar la clase TraceListener, seguido de un terminador de línea. (Heredado de TraceListener)
WriteLine(Object, String)	Escribe un nombre de categoría y el valor del método ToString() del objeto en el agente de escucha que se crea al implementar la clase TraceListener, seguidos de un terminador de línea. (Heredado de TraceListener)
WriteLine(String)	Escribe un mensaje seguido del terminador de línea actual del archivo de registro sin proporcionar información de contexto adicional.
WriteLine(String, String)	Escribe un nombre de categoría y un mensaje en el agente de escucha que se crea al implementar la clase TraceListener, seguidos de un terminador de línea. (Heredado de TraceListener)

Se aplica a

Compartir vía