Condividi tramite


EventSchemaTraceListener Classe

Definizione

Dirige l'output di tracciatura o di debug degli eventi end-to-end in un file di log codificato in XML e conforme allo schema.

public ref class EventSchemaTraceListener : System::Diagnostics::TextWriterTraceListener
public class EventSchemaTraceListener : System.Diagnostics.TextWriterTraceListener
type EventSchemaTraceListener = class
    inherit TextWriterTraceListener
Public Class EventSchemaTraceListener
Inherits TextWriterTraceListener
Ereditarietà

Esempio

Nell'esempio di codice seguente viene illustrato come usare la 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

Commenti

La EventSchemaTraceListener classe fornisce la traccia degli eventi conformi allo schema end-to-end. È possibile usare la traccia end-to-end per un sistema che dispone di componenti eterogenei tra thread, AppDomainprocessi e limiti computer. Uno schema di eventi standardizzato consente di tracciare questi limiti. Lo schema consente l'aggiunta di elementi personalizzati e conformi allo schema. È possibile usare lo strumento Visualizzatore traccia del servizio (SvcTraceViewer.exe) per visualizzare i dati dell'evento.

EventSchemaTraceListener è ottimizzato per la registrazione delle prestazioni con supporto implicito per la traccia senza blocco.

La EventSchemaTraceListener classe converte le informazioni di traccia e debug in un flusso di testo con codifica XML. La descrizione dell'output XML viene visualizzata nelle tabelle più avanti in questa sezione.

È possibile creare un EventSchemaTraceListener oggetto nel codice. In alternativa, per le app .NET Framework è possibile abilitare o disabilitare un EventSchemaTraceListener oggetto tramite il file di configurazione dell'applicazione e quindi usare l'oggetto configurato EventSchemaTraceListener nell'applicazione. Per informazioni sull'uso dei file di configurazione per la traccia e il debug nelle app .NET Framework, vedere Schema delle impostazioni di traccia e debug.

Per configurare un EventSchemaTraceListener oggetto in un'app .NET Framework, modificare il file di configurazione corrispondente al nome dell'applicazione. In questo file è possibile aggiungere, rimuovere o impostare le proprietà per un listener. Il file di configurazione deve essere formattato come segue:

<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 classe eredita la Filter proprietà dalla classe TraceListenerbase . La Filter proprietà consente un livello aggiuntivo di filtro dell'output di traccia nel listener. Se è presente un filtro, i Trace metodi del listener di traccia chiamano il ShouldTrace metodo del filtro per determinare se generare la traccia.

Se viene eseguito un tentativo di scrittura in un file usato o non disponibile, viene aggiunto automaticamente un suffisso GUID al nome del file.

Nota

I metodi listener devono essere chiamati dai metodi delle Debugclassi , Tracee TraceSource . Non chiamare i metodi listener direttamente dal codice dell'applicazione. Il EventSchemaTraceListener listener è principalmente destinato all'uso dalla TraceSource classe.

La tabella seguente descrive gli elementi e gli attributi dell'output XML.

Elemento Attributi Output Note
CallStack nessuno Dipende dalla presenza del Callstack flag nella TraceOutputOptions proprietà. Caratteri speciali come > o < vengono sostituiti con sequenze di escape. Vedere la tabella di traduzione dei caratteri di escape nella tabella successiva.
Computer nessuno Sempre presente. Questo elemento rappresenta il valore della MachineName proprietà.
Correlation ActivityID Sempre presente. Se ActivityID non viene specificato, il valore predefinito è un GUID vuoto.
RelatedActivityID Dipende dalla presenza del relatedActivityId parametro nella chiamata al Trace metodo. L'attributo RelatedActivityIDrelatedActivityIdTraceTransfer corrisponde al parametro del metodo.
Data nessuno Sempre presente. Questo elemento rappresenta l'input dei parametri (data). Viene fornito un elemento per ogni oggetto dati. Nel caso dei registri eventi, l'elemento Data contiene dati XML preceduti da escape. Nel caso dei log di dati, l'elemento Data contiene dati senza caratteri di escape. L'output del log dati usa il ToString metodo degli oggetti dati passati.
Event nessuno Sempre presente. Questo elemento contiene un evento di traccia.
EventData nessuno Presente per i registri eventi. Questo elemento rappresenta l'input del parametro (message, args). Data Contiene elementi con dati XML preceduti da escape creati chiamando il TraceEvent metodo .
EventID nessuno Sempre presente. Questo elemento rappresenta l'input del parametro (id).
Execution ProcessID Dipende dalla presenza del ProcessId flag nella TraceOutputOptions proprietà . L'attributo ProcessID viene specificato in TraceEventCache.
ThreadID Presente quando ProcessID è presente. L'attributo ThreadID viene specificato in TraceEventCache.
Level nessuno Sempre presente. Questo elemento rappresenta l'input del parametro (valore numerico di eventType). I valori dei parametri maggiori di 255 vengono restituiti come livello 8, che rappresenta TraceEventType.Information. I tipi di Criticalevento di traccia , , InformationErrorWarning, e Verbose vengono restituiti rispettivamente come livelli 1, 2, 4, 8 e 10.
LogicalOperationStack nessuno Dipende dalla presenza del LogicalOperationStack flag nella TraceOutputOptions proprietà . Può esistere una sola operazione logica. Di conseguenza, i valori vengono scritti come LogicalOperation nodi nell'elemento LogicalOperationStack .
OpCode nessuno Presente quando Level è maggiore di 255. Questo elemento rappresenta i tipi di evento Trace con valori numerici maggiori di 255. Start, Stop, Suspend, Resumeo Transfer sono restituiti rispettivamente come livelli 1, 2, 4, 8 e 10.
Provider GUID Sempre presente. Sempre vuoto.
RenderingInfo Culture Sempre presente. Questo attributo rappresenta una stringa di risorsa per il tipo di evento. È sempre "en-EN\".
System Name Sempre presente.
TimeCreated SystemTime Dipende dalla presenza del DateTime flag nella TraceOutputOptions proprietà . L'ora è il valore della TraceEventCache.DateTime proprietà . Questa proprietà è espressa come Coordinated Universal Time
TimeStamp nessuno Dipende dalla presenza del Timestamp flag nella TraceOutputOptions proprietà . Questo elemento viene specificato in TraceEventCache.
UserData nessuno Presente per i log di dati. Questo elemento contiene Data elementi con dati senza caratteri di escape forniti dall'utente da un TraceData metodo.

Nella tabella seguente vengono illustrati i caratteri di escape nell'output XML. L'escape si verifica in tutti gli elementi e gli attributi, ad eccezione dell'elemento UserData , che contiene dati senza caratteri di escape forniti dall'utente. L'elemento UserData è il risultato delle chiamate al TraceData metodo .

Caratteri di escape Valore
& &
< <
> >
" "
|'
0xD
0xA

Costruttori

EventSchemaTraceListener(String)

Inizializza una nuova istanza della classe EventSchemaTraceListener, usando il file specificato come destinatario dell'output di debug e di tracciatura.

EventSchemaTraceListener(String, String)

Inizializza una nuova istanza della classe EventSchemaTraceListener con il nome specificato, usando il file specificato come destinatario dell'output di debug e di tracciatura.

EventSchemaTraceListener(String, String, Int32)

Inizializza una nuova istanza della classe EventSchemaTraceListener con il nome e le dimensioni del buffer specificati, usando il file specificato come destinatario dell'output di debug e di tracciatura.

EventSchemaTraceListener(String, String, Int32, TraceLogRetentionOption)

Inizializza una nuova istanza della classe EventSchemaTraceListener con il nome e le dimensioni del buffer specificati, usando il file specificato con i criteri di conservazione dei log indicati come destinatario dell'output di debug e di tracciatura.

EventSchemaTraceListener(String, String, Int32, TraceLogRetentionOption, Int64)

Inizializza una nuova istanza della classe EventSchemaTraceListener con il nome e le dimensioni del buffer specificati, usando il file specificato con i criteri di conservazione dei log e la dimensione massima indicati come destinatario dell'output di debug e di tracciatura.

EventSchemaTraceListener(String, String, Int32, TraceLogRetentionOption, Int64, Int32)

Inizializza una nuova istanza della classe EventSchemaTraceListener con il nome e le dimensioni del buffer specificati, usando il file specificato con i criteri di conservazione dei log, la dimensione massima e il conteggio di file indicati come destinatario dell'output di debug e di tracciatura.

Proprietà

Attributes

Ottiene gli attributi personalizzati del listener di traccia definiti nel file di configurazione dell'applicazione.

(Ereditato da TraceListener)
BufferSize

Ottiene le dimensioni del buffer di output.

Filter

Ottiene o imposta il filtro di traccia per il listener di traccia.

(Ereditato da TraceListener)
IndentLevel

Ottiene o imposta il livello di rientro.

(Ereditato da TraceListener)
IndentSize

Ottiene o imposta il numero di spazi in un rientro.

(Ereditato da TraceListener)
IsThreadSafe

Ottiene un valore che indica se il listener di traccia è thread-safe.

MaximumFileSize

Ottiene la dimensione massima del file di log.

MaximumNumberOfFiles

Ottiene il numero massimo di file di log.

Name

Ottiene o imposta un nome per l'oggetto TraceListener.

(Ereditato da TraceListener)
NeedIndent

Ottiene o imposta un valore che indica se impostare il rientro dell'output.

(Ereditato da TraceListener)
TraceLogRetentionOption

Ottiene l'opzione di conservazione dei registri di traccia per il file.

TraceOutputOptions

Ottiene o imposta le opzioni dell'output di traccia.

(Ereditato da TraceListener)
Writer

Ottiene o imposta il writer di testo sottostante che scrive nel file di log.

Metodi

Close()

Chiude il file di log per questo listener in modo che non riceva più output di tracciatura o di debug.

CreateObjRef(Type)

Consente di creare un oggetto che contiene tutte le informazioni rilevanti necessarie per la generazione del proxy utilizzato per effettuare la comunicazione con un oggetto remoto.

(Ereditato da MarshalByRefObject)
Dispose()

Rilascia tutte le risorse usate da TraceListener.

(Ereditato da TraceListener)
Dispose(Boolean)

Elimina questo oggetto TextWriterTraceListener.

(Ereditato da TextWriterTraceListener)
Equals(Object)

Determina se l'oggetto specificato è uguale all'oggetto corrente.

(Ereditato da Object)
Fail(String)

Genera un messaggio di errore nel listener creato durante l'implementazione della classe TraceListener.

(Ereditato da TraceListener)
Fail(String, String)

Scrive informazioni sull'errore, incluso un messaggio di errore di base e un messaggio di errore dettagliato, nel file di log.

Flush()

Fa sì che i dati memorizzati nel buffer siano scritti nel registro per questo listener.

GetHashCode()

Funge da funzione hash predefinita.

(Ereditato da Object)
GetLifetimeService()
Obsoleti.

Consente di recuperare l'oggetto servizio di durata corrente per controllare i criteri di durata per l'istanza.

(Ereditato da MarshalByRefObject)
GetSupportedAttributes()

Ottiene gli attributi di configurazione XML personalizzati supportati dal listener di traccia.

GetType()

Ottiene l'oggetto Type dell'istanza corrente.

(Ereditato da Object)
InitializeLifetimeService()
Obsoleti.

Ottiene un oggetto servizio di durata per controllare i criteri di durata per questa istanza.

(Ereditato da MarshalByRefObject)
MemberwiseClone()

Crea una copia superficiale dell'oggetto Object corrente.

(Ereditato da Object)
MemberwiseClone(Boolean)

Crea una copia dei riferimenti dell'oggetto MarshalByRefObject corrente.

(Ereditato da MarshalByRefObject)
ToString()

Restituisce una stringa che rappresenta l'oggetto corrente.

(Ereditato da Object)
TraceData(TraceEventCache, String, TraceEventType, Int32, Object)

Scrive le informazioni di traccia, un singolo oggetto dati e le informazioni sull'evento nel file di log.

TraceData(TraceEventCache, String, TraceEventType, Int32, Object[])

Scrive le informazioni di traccia, più oggetti dati e le informazioni sull'evento nel file di log.

TraceEvent(TraceEventCache, String, TraceEventType, Int32)

Scrive le informazioni di traccia e di evento nell'output specifico del listener.

(Ereditato da TraceListener)
TraceEvent(TraceEventCache, String, TraceEventType, Int32, String)

Scrive le informazioni di traccia, un messaggio e le informazioni sull'evento nel file di log.

TraceEvent(TraceEventCache, String, TraceEventType, Int32, String, Object[])

Scrive le informazioni di traccia, un messaggio formattato e le informazioni sull'evento nel file di log.

TraceTransfer(TraceEventCache, String, Int32, String, Guid)

Scrive le informazioni di traccia, tra cui l'identità di un'attività correlata, un messaggio e le informazioni sull'evento, nel file di log.

Write(Object)

Scrive il valore del metodo ToString() dell'oggetto nel listener creato durante l'implementazione della classe TraceListener.

(Ereditato da TraceListener)
Write(Object, String)

Scrive un nome di categoria e il valore del metodo ToString() dell'oggetto nel listener creato durante l'implementazione della classe TraceListener.

(Ereditato da TraceListener)
Write(String)

Scrive un messaggio nel file di log senza fornire informazioni di contesto aggiuntive.

Write(String, String)

Scrive un nome di categoria e un messaggio nel listener creato durante l'implementazione della classe TraceListener.

(Ereditato da TraceListener)
WriteIndent()

Inserisce il rientro nel listener creato quando si implementa questa classe e reimposta la proprietà NeedIndent su false.

(Ereditato da TraceListener)
WriteLine(Object)

Scrive il valore del metodo ToString() dell'oggetto nel listener creato durante l'implementazione della classe TraceListener, seguito da un terminatore di riga.

(Ereditato da TraceListener)
WriteLine(Object, String)

Scrive un nome di categoria e il valore del metodo ToString() dell'oggetto nel listener creato durante l'implementazione della classe TraceListener, seguito da un terminatore di riga.

(Ereditato da TraceListener)
WriteLine(String)

Scrive un messaggio, seguito dal terminatore di riga corrente, nel file di log senza fornire informazioni di contesto aggiuntive.

WriteLine(String, String)

Scrive un nome di categoria e un messaggio nel listener creato durante l'implementazione della classe TraceListener, seguiti da un terminatore di riga.

(Ereditato da TraceListener)

Si applica a