EventSchemaTraceListener Clase

Definición

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

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, , StopSuspend, 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