EventSchemaTraceListener Classe

Referência

Definição

Namespace:: System.Diagnostics

Assembly:: System.Core.dll

Importante

Algumas informações se referem a produtos de pré-lançamento que podem ser substancialmente modificados antes do lançamento. A Microsoft não oferece garantias, expressas ou implícitas, das informações aqui fornecidas.

Direciona a saída do rastreamento ou da depuração de eventos de ponta a ponta para um arquivo de log em conformidade com o esquema, codificado em XML.

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

public class EventSchemaTraceListener : System.Diagnostics.TextWriterTraceListener

type EventSchemaTraceListener = class
    inherit TextWriterTraceListener

Public Class EventSchemaTraceListener
Inherits TextWriterTraceListener

Herança: Object

MarshalByRefObject

TraceListener

TextWriterTraceListener
EventSchemaTraceListener

Exemplos

O exemplo de código a seguir demonstra como usar a EventSchemaTraceListener classe .


///////////////////////////////////////////////////////////////////////
//
// 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

Comentários

A EventSchemaTraceListener classe fornece rastreamento de eventos em conformidade com esquema de ponta a ponta. Você pode usar o rastreamento de ponta a ponta para um sistema que tem componentes heterogêneos que cruzam limites de thread, AppDomain, processo e computador. Um esquema de evento padronizado permite o rastreamento entre esses limites. O esquema permite a adição de elementos personalizados em conformidade com esquema. Você pode usar a Ferramenta visualizador de rastreamento de serviço (SvcTraceViewer.exe) para exibir os dados do evento.

EventSchemaTraceListener é ajustado para registrar em log o desempenho com suporte implícito para rastreamento sem bloqueio.

A EventSchemaTraceListener classe converte informações de rastreamento e depuração em um fluxo de texto codificado em XML. A descrição da saída XML é mostrada nas tabelas mais adiante nesta seção.

Você pode criar um EventSchemaTraceListener objeto em seu código. Como alternativa, para .NET Framework aplicativos, você pode habilitar ou desabilitar um EventSchemaTraceListener objeto por meio do arquivo de configuração do aplicativo e, em seguida, usar o objeto configurado EventSchemaTraceListener em seu aplicativo. Para obter informações sobre o uso de arquivos de configuração para rastreamento e depuração em aplicativos .NET Framework, consulte Esquema de configurações de rastreamento e depuração.

Para configurar um EventSchemaTraceListener objeto em um aplicativo .NET Framework, modifique o arquivo de configuração que corresponde ao nome do aplicativo. Nesse arquivo, você pode adicionar, remover ou definir as propriedades de um ouvinte. O arquivo de configuração deve ser formatado da seguinte maneira:

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

A EventSchemaTraceListener classe herda a Filter propriedade da classe TraceListenerbase . A Filter propriedade permite um nível adicional de filtragem de saída de rastreamento no ouvinte. Se um filtro estiver presente, os Trace métodos do ouvinte de rastreamento chamarão o ShouldTrace método do filtro para determinar se deseja emitir o rastreamento.

Se for feita uma tentativa de gravar em um arquivo que está sendo usado ou que não está disponível, um sufixo GUID é adicionado automaticamente ao nome do arquivo.

Observação

Os métodos de ouvinte devem ser chamados por métodos das Debugclasses , Tracee TraceSource . Não chame os métodos de ouvinte diretamente do código do aplicativo. O EventSchemaTraceListener ouvinte destina-se principalmente ao uso pela TraceSource classe .

A tabela a seguir descreve os elementos e atributos da saída XML.

Elemento	Atributos	Saída	Observações
`CallStack`	Nenhum	Depende da presença do Callstack sinalizador na TraceOutputOptions propriedade .	Caracteres especiais, como > ou < , são substituídos por sequências de escape. Consulte a tabela de conversão de caracteres com escape na próxima tabela.
`Computer`	Nenhum	Sempre presente.	Esse elemento representa o valor da MachineName propriedade .
`Correlation`	`ActivityID`	Sempre presente.	Se `ActivityID` não for especificado, o padrão será um GUID vazio.
	`RelatedActivityID`	Depende da presença do `relatedActivityId` parâmetro na chamada de `Trace` método.	O `RelatedActivityID` atributo corresponde ao `relatedActivityId` parâmetro do TraceTransfer método .
`Data`	Nenhum	Sempre presente.	Esse elemento representa a entrada de parâmetro (`data`). Um elemento é fornecido para cada objeto de dados. No caso de logs de eventos, o `Data` elemento contém dados XML de escape. No caso de logs de dados, o `Data` elemento contém dados sem escape. A saída do log de dados usa o `ToString` método dos objetos de dados passados.
`Event`	Nenhum	Sempre presente.	Esse elemento contém um evento de rastreamento.
`EventData`	Nenhum	Presente para logs de eventos.	Esse elemento representa a entrada de parâmetro (`message`, `args`). Ele contém `Data` elementos com dados XML de escape criados chamando o TraceEvent método .
`EventID`	Nenhum	Sempre presente.	Esse elemento representa a entrada de parâmetro (`id`).
`Execution`	`ProcessID`	Depende da presença do ProcessId sinalizador na TraceOutputOptions propriedade .	O `ProcessID` atributo é especificado no TraceEventCache.
	`ThreadID`	Presente quando `ProcessID` estiver presente.	O `ThreadID` atributo é especificado no TraceEventCache.
`Level`	Nenhum	Sempre presente.	Esse elemento representa a entrada de parâmetro (o valor numérico de `eventType`). Os valores de parâmetro maiores que 255 são gerados como um nível 8, que representa TraceEventType.Information. Os tipos Criticalde evento de rastreamento , Error, Warning, Informatione Verbose são gerados como níveis 1, 2, 4, 8 e 10, respectivamente.
`LogicalOperationStack`	Nenhum	Depende da presença do LogicalOperationStack sinalizador na TraceOutputOptions propriedade .	Somente uma operação lógica pode existir. Portanto, os valores são gravados como `LogicalOperation` nós no `LogicalOperationStack` elemento .
`OpCode`	Nenhum	Presente quando `Level` for maior que 255.	Esse elemento representa tipos de evento Trace que têm valores numéricos maiores que 255. Start, Stop, Suspend, Resumeou Transfer são gerados como níveis 1, 2, 4, 8 e 10, respectivamente.
`Provider`	`GUID`	Sempre presente.	Sempre vazio.
`RenderingInfo`	`Culture`	Sempre presente.	Esse atributo representa uma cadeia de caracteres de recurso para o tipo de evento. É sempre "en-EN\".
`System`	`Name`	Sempre presente.
`TimeCreated`	`SystemTime`	Depende da presença do DateTime sinalizador na TraceOutputOptions propriedade .	A hora é o valor da TraceEventCache.DateTime propriedade . Essa propriedade é expressa como Tempo Universal Coordenado
`TimeStamp`	Nenhum	Depende da presença do Timestamp sinalizador na TraceOutputOptions propriedade .	Esse elemento é especificado no TraceEventCache.
`UserData`	Nenhum	Presente para logs de dados.	Esse elemento contém `Data` elementos com dados sem escape fornecidos pelo usuário de um TraceData método .

A tabela a seguir mostra os caracteres que são escapados na saída XML. O escape ocorre em todos os elementos e atributos, exceto no UserData elemento , que contém dados sem escape fornecidos pelo usuário. O UserData elemento é resultado de chamadas para o TraceData método .

Caractere com escape	Valor
&	&
<	<
>	>
"	"
\|'
0xD
0xA

Construtores

EventSchemaTraceListener(String)	Inicializa uma nova instância da classe EventSchemaTraceListener usando o arquivo especificado como o destinatário da saída de depuração e de rastreamento.
EventSchemaTraceListener(String, String)	Inicializa uma nova instância da classe EventSchemaTraceListener com o nome especificado usando o arquivo indicado como o destinatário da saída de depuração e de rastreamento.
EventSchemaTraceListener(String, String, Int32)	Inicializa uma nova instância da classe EventSchemaTraceListener com o nome e o tamanho do buffer especificados usando o arquivo indicado como o destinatário da saída de depuração e de rastreamento.
EventSchemaTraceListener(String, String, Int32, TraceLogRetentionOption)	Inicializa uma nova instância da classe EventSchemaTraceListener com o nome e o tamanho do buffer especificados usando o arquivo indicado com a política de retenção de log fornecido como o destinatário da saída de depuração e de rastreamento.
EventSchemaTraceListener(String, String, Int32, TraceLogRetentionOption, Int64)	Inicializa uma nova instância da classe EventSchemaTraceListener com o nome e o tamanho do buffer especificados usando o arquivo indicado com a política de retenção de log e o tamanho máximo fornecidos como o destinatário da saída de depuração e de rastreamento.
EventSchemaTraceListener(String, String, Int32, TraceLogRetentionOption, Int64, Int32)	Inicializa uma nova instância da classe EventSchemaTraceListener com o nome e o tamanho do buffer especificados usando o arquivo indicado com a política de retenção de log, o tamanho máximo e a contagem de arquivos fornecidos como o destinatário da saída de depuração e de rastreamento.

Propriedades

Attributes	Obtém os atributos do ouvinte de rastreamento personalizados definidos no arquivo de configuração de aplicativo. (Herdado de TraceListener)
BufferSize	Obtém o tamanho do buffer de saída.
Filter	Obtém ou define o filtro de rastreamento para o ouvinte de rastreamento. (Herdado de TraceListener)
IndentLevel	Obtém ou define o nível de recuo. (Herdado de TraceListener)
IndentSize	Obtém ou define o número de espaços em um recuo. (Herdado de TraceListener)
IsThreadSafe	Obtém um valor que indica se o ouvinte de rastreamento é thread-safe.
MaximumFileSize	Obtém o tamanho máximo do arquivo de log.
MaximumNumberOfFiles	Obtém o número máximo de arquivos de log.
Name	Obtém ou define um nome para este TraceListener. (Herdado de TraceListener)
NeedIndent	Obtém ou define um valor que indica se a saída deve ser recuada. (Herdado de TraceListener)
TraceLogRetentionOption	Obtém a opção de retenção de log de rastreamento para o arquivo.
TraceOutputOptions	Obtém ou define as opções de saída de rastreamento. (Herdado de TraceListener)
Writer	Obtém ou define o text writer subjacente que grava o arquivo de log.

Métodos

Close()	Fecha o arquivo de log deste ouvinte para que ele não receba mais a saída de rastreamento ou de depuração.
CreateObjRef(Type)	Cria um objeto que contém todas as informações relevantes necessárias para gerar um proxy usado para se comunicar com um objeto remoto. (Herdado de MarshalByRefObject)
Dispose()	Libera todos os recursos usados pelo TraceListener. (Herdado de TraceListener)
Dispose(Boolean)	Descarta este objeto TextWriterTraceListener. (Herdado de TextWriterTraceListener)
Equals(Object)	Determina se o objeto especificado é igual ao objeto atual. (Herdado de Object)
Fail(String)	Emite uma mensagem de erro para o ouvinte criado ao implementar a classe TraceListener. (Herdado de TraceListener)
Fail(String, String)	Grava as informações de erro, incluindo uma mensagem de erro básica e uma mensagem de erro detalhada, no arquivo de log.
Flush()	Faz com que os dados em buffer sejam gravados no log para este ouvinte.
GetHashCode()	Serve como a função de hash padrão. (Herdado de Object)
GetLifetimeService()	Obsoleto. Recupera o objeto de serviço de tempo de vida atual que controla a política de ciclo de vida para esta instância. (Herdado de MarshalByRefObject)
GetSupportedAttributes()	Obtém os atributos de configuração XML personalizados compatíveis com o ouvinte de rastreamento.
GetType()	Obtém o Type da instância atual. (Herdado de Object)
InitializeLifetimeService()	Obsoleto. Obtém um objeto de serviço de tempo de vida para controlar a política de tempo de vida para essa instância. (Herdado de MarshalByRefObject)
MemberwiseClone()	Cria uma cópia superficial do Object atual. (Herdado de Object)
MemberwiseClone(Boolean)	Cria uma cópia superficial do objeto MarshalByRefObject atual. (Herdado de MarshalByRefObject)
ToString()	Retorna uma cadeia de caracteres que representa o objeto atual. (Herdado de Object)
TraceData(TraceEventCache, String, TraceEventType, Int32, Object)	Grava informações de rastreamento, um único objeto de dados e informações de evento no arquivo de log.
TraceData(TraceEventCache, String, TraceEventType, Int32, Object[])	Grava informações de rastreamento, vários objetos de dados e informações de evento no arquivo de log.
TraceEvent(TraceEventCache, String, TraceEventType, Int32)	Grava as informações de rastreamento e evento para a saída específica do ouvinte. (Herdado de TraceListener)
TraceEvent(TraceEventCache, String, TraceEventType, Int32, String)	Grava informações de rastreamento, uma mensagem e informações de evento no arquivo de log.
TraceEvent(TraceEventCache, String, TraceEventType, Int32, String, Object[])	Grava informações de rastreamento, uma mensagem formatada e informações de evento no arquivo de log.
TraceTransfer(TraceEventCache, String, Int32, String, Guid)	Grava informações de rastreamento, incluindo a identidade de uma atividade relacionada, uma mensagem e informações de evento no arquivo de log.
Write(Object)	Grava o valor do método ToString() do objeto no ouvinte criado ao implementar a classe TraceListener. (Herdado de TraceListener)
Write(Object, String)	Grava um nome de categoria e o valor do método ToString() do objeto no ouvinte criado ao implementar a classe TraceListener. (Herdado de TraceListener)
Write(String)	Grava uma mensagem para o arquivo de log sem fornecer informações de contexto adicionais.
Write(String, String)	Grava um nome de categoria e uma mensagem no ouvinte criado ao implementar a classe TraceListener. (Herdado de TraceListener)
WriteIndent()	Grava o recuo para o ouvinte criar durante a implementação dessa classe e redefine a propriedade NeedIndent para `false`. (Herdado de TraceListener)
WriteLine(Object)	Grava o valor do método ToString() do objeto no ouvinte criado ao implementar a classe TraceListener, seguido por um terminador de linha. (Herdado de TraceListener)
WriteLine(Object, String)	Grava um nome de categoria e o valor do método ToString() do objeto no ouvinte criado ao implementar a classe TraceListener, seguido por um terminador de linha. (Herdado de TraceListener)
WriteLine(String)	Grava uma mensagem seguida pelo terminador de linha atual para o arquivo de log sem fornecer nenhuma informação de contexto adicional.
WriteLine(String, String)	Grava um nome de categoria e uma mensagem no ouvinte criado ao implementar a classe TraceListener, seguido por um terminador de linha. (Herdado de TraceListener)

Aplica-se a

Partilhar via