EventSchemaTraceListener Classe

Riferimento

Definizione

Spazio dei nomi:: System.Diagnostics

Assembly:: System.Core.dll

Importante

Alcune informazioni sono relative alla release non definitiva del prodotto, che potrebbe subire modifiche significative prima della release definitiva. Microsoft non riconosce alcuna garanzia, espressa o implicita, in merito alle informazioni qui fornite.

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à: Object

MarshalByRefObject

TraceListener

TextWriterTraceListener
EventSchemaTraceListener

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 `RelatedActivityIDrelatedActivityId`TraceTransfer 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 , , Information Error Warning, 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