EventSchemaTraceListener Třída

Reference

Definice

Obor názvů:: System.Diagnostics

Sestavení:: System.Core.dll

Důležité

Některé informace platí pro předběžně vydaný produkt, který se může zásadně změnit, než ho výrobce nebo autor vydá. Microsoft neposkytuje žádné záruky, výslovné ani předpokládané, týkající se zde uváděných informací.

Směruje trasování nebo ladění výstupu komplexních událostí do souboru protokolu zakódovaného ve formátu XML, který vyhovuje schématu.

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

public class EventSchemaTraceListener : System.Diagnostics.TextWriterTraceListener

type EventSchemaTraceListener = class
    inherit TextWriterTraceListener

Public Class EventSchemaTraceListener
Inherits TextWriterTraceListener

Dědičnost: Object

MarshalByRefObject

TraceListener

TextWriterTraceListener
EventSchemaTraceListener

Příklady

Následující příklad kódu ukazuje, jak použít EventSchemaTraceListener třídu.


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

Poznámky

Třída EventSchemaTraceListener poskytuje trasování událostí kompatibilních s kompletním schématem. Komplexní trasování můžete použít pro systém, který má heterogenní komponenty, které překračují hranice mezi vlákny, AppDomainprocesy a počítači. Standardizované schéma událostí umožňuje trasování přes tyto hranice. Schéma umožňuje přidání vlastních elementů kompatibilních se schématem. K zobrazení dat událostí můžete použít nástroj Service Trace Viewer (SvcTraceViewer.exe ).

EventSchemaTraceListener je vyladěný pro výkon protokolování s implicitní podporou trasování bez uzamčení.

Třída EventSchemaTraceListener převádí trasovací a ladicí informace do textového streamu s kódováním XML. Popis výstupu XML se zobrazí v tabulkách dále v této části.

V kódu můžete vytvořit EventSchemaTraceListener objekt. Případně můžete pro aplikace .NET Framework povolit nebo zakázat EventSchemaTraceListener objekt prostřednictvím konfiguračního souboru aplikace a pak použít nakonfigurovaný EventSchemaTraceListener objekt ve vaší aplikaci. Informace o použití konfiguračních souborů pro trasování a ladění v aplikacích .NET Framework najdete v tématu Schéma nastavení trasování a ladění.

Pokud chcete nakonfigurovat EventSchemaTraceListener objekt v aplikaci .NET Framework, upravte konfigurační soubor, který odpovídá názvu vaší aplikace. V tomto souboru můžete přidat, odebrat nebo nastavit vlastnosti naslouchacího procesu. Konfigurační soubor by měl být naformátovaný takto:

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

Třída EventSchemaTraceListener dědí Filter vlastnost ze základní třídy TraceListener. Vlastnost Filter umožňuje další úroveň filtrování výstupu trasování v naslouchacím procesu. Pokud je k dispozici filtr, Trace metody trasovacího naslouchacího procesu volají ShouldTrace metodu filtru, aby se určilo, zda se má trasování vygenerovat.

Pokud dojde k pokusu o zápis do souboru, který se používá nebo je nedostupný, automaticky se k názvu souboru přidá přípona GUID.

Poznámka

Metody naslouchacího Debugprocesu mají být volána metodami tříd , Tracea TraceSource . Nevolejte metody naslouchacího procesu přímo z kódu aplikace. Naslouchací EventSchemaTraceListener proces je primárně určen pro použití TraceSource třídou.

Následující tabulka popisuje elementy a atributy výstupu XML.

Prvek	Atributy	Výstup	Poznámky
`CallStack`	Žádné	Závisí na přítomnosti příznaku Callstack TraceOutputOptions ve vlastnosti.	Speciální znaky, jako > jsou nebo < , jsou nahrazeny řídicími sekvencemi. Podívejte se na tabulku překladu řídicích znaků v další tabulce.
`Computer`	Žádné	Vždy přítomen.	Tento prvek představuje hodnotu MachineName vlastnosti.
`Correlation`	`ActivityID`	Vždy přítomen.	Pokud `ActivityID` není zadaný, výchozí hodnota je prázdný identifikátor GUID.
	`RelatedActivityID`	Závisí na přítomnosti parametru `relatedActivityId` ve `Trace` volání metody.	Atribut `RelatedActivityID` odpovídá `relatedActivityId` parametru TraceTransfer metody.
`Data`	Žádné	Vždy přítomen.	Tento prvek představuje vstup parametru (`data`). Pro každý datový objekt je k dispozici jeden prvek. V případě protokolů `Data` událostí element obsahuje řídicí data XML. V případě datových protokolů `Data` obsahuje element uneescaped data. Výstup datového protokolu používá metodu `ToString` předaných datových objektů.
`Event`	Žádné	Vždy přítomen.	Tento prvek obsahuje událost trasování.
`EventData`	Žádné	K dispozici pro protokoly událostí.	Tento element představuje vstup parametru (`message`, `args`). Obsahuje `Data` elementy s řídicími daty XML, které jsou vytvořeny voláním TraceEvent metody .
`EventID`	Žádné	Vždy přítomen.	Tento element představuje vstup parametru (`id`).
`Execution`	`ProcessID`	Závisí na přítomnosti příznaku ProcessId ve TraceOutputOptions vlastnosti .	Atribut `ProcessID` je zadaný v .TraceEventCache
	`ThreadID`	Je k dispozici, když `ProcessID` je k dispozici.	Atribut `ThreadID` je zadaný v .TraceEventCache
`Level`	Žádné	Vždy přítomen.	Tento prvek představuje vstup parametru (číselná hodnota ).`eventType` Hodnoty parametrů, které jsou větší než 255, jsou výstupem jako úroveň 8, která představuje TraceEventType.Information. Výstupem Criticaljsou typy událostí trasování , Error, Warning Information, a Verbose jako úrovně 1, 2, 4, 8 a 10.
`LogicalOperationStack`	Žádné	Závisí na přítomnosti příznaku LogicalOperationStack ve TraceOutputOptions vlastnosti .	Může existovat pouze jedna logická operace. Proto se hodnoty zapisují jako `LogicalOperation` uzly pod elementem `LogicalOperationStack` .
`OpCode`	Žádné	K dispozici, pokud `Level` je větší než 255.	Tento prvek představuje trasování typy událostí, které mají číselné hodnoty větší než 255. StartVýstupem jsou Stop, nebo Transfer úrovně 1, 2, 4, 8 a 10. Suspend Resume
`Provider`	`GUID`	Vždy přítomen.	Vždy prázdné.
`RenderingInfo`	`Culture`	Vždy přítomen.	Tento atribut představuje řetězec prostředku pro typ události. Vždy je to "en-CS\".
`System`	`Name`	Vždy přítomen.
`TimeCreated`	`SystemTime`	Závisí na přítomnosti příznaku DateTime ve TraceOutputOptions vlastnosti .	Čas je hodnota TraceEventCache.DateTime vlastnosti . Tato vlastnost je vyjádřena jako koordinovaný univerzální čas.
`TimeStamp`	Žádné	Závisí na přítomnosti příznaku Timestamp ve TraceOutputOptions vlastnosti .	Tento prvek je zadaný v objektu TraceEventCache.
`UserData`	Žádné	Je k dispozici pro datové protokoly.	Tento element obsahuje `Data` elementy s unescaped, uživatelem poskytnutá data z TraceData metody.

V následující tabulce jsou uvedeny znaky, které jsou ve výstupu XML umisovány řídicími znaky. K escapingu dochází ve všech elementech a atributech s výjimkou elementu UserData , který obsahuje uživatelem poskytnutá data bez uživatele. Element UserData je výsledkem volání TraceData metody .

Řídicí znak	Hodnota
&	&
<	<
>	>
"	"
\|'
0xD
0xA

Konstruktory

EventSchemaTraceListener(String)	Inicializuje novou instanci EventSchemaTraceListener třídy pomocí zadaného souboru jako příjemce výstupu ladění a trasování.
EventSchemaTraceListener(String, String)	Inicializuje novou instanci EventSchemaTraceListener třídy se zadaným názvem pomocí zadaného souboru jako příjemce výstupu ladění a trasování.
EventSchemaTraceListener(String, String, Int32)	Inicializuje novou instanci EventSchemaTraceListener třídy se zadaným názvem a zadanou velikostí vyrovnávací paměti pomocí zadaného souboru jako příjemce výstupu ladění a trasování.
EventSchemaTraceListener(String, String, Int32, TraceLogRetentionOption)	Inicializuje novou instanci EventSchemaTraceListener třídy se zadaným názvem a zadanou velikostí vyrovnávací paměti pomocí zadaného souboru se zadanými zásadami uchovávání protokolů jako příjemce výstupu ladění a trasování.
EventSchemaTraceListener(String, String, Int32, TraceLogRetentionOption, Int64)	Inicializuje novou instanci EventSchemaTraceListener třídy se zadaným názvem a zadanou velikostí vyrovnávací paměti pomocí zadaného souboru se zadanou zásadou uchovávání protokolů a maximální velikostí jako příjemce výstupu ladění a trasování.
EventSchemaTraceListener(String, String, Int32, TraceLogRetentionOption, Int64, Int32)	Inicializuje novou instanci EventSchemaTraceListener třídy se zadaným názvem a zadanou velikostí vyrovnávací paměti pomocí zadaného souboru se zadanou zásadou uchovávání protokolů, maximální velikostí a počtem souborů jako příjemce výstupu ladění a trasování.

Vlastnosti

Attributes	Získá vlastní atributy trasovacího naslouchacího procesu definované v konfiguračním souboru aplikace. (Zděděno od TraceListener)
BufferSize	Získá velikost výstupní vyrovnávací paměti.
Filter	Získá nebo nastaví filtr trasování pro trasovací naslouchací proces. (Zděděno od TraceListener)
IndentLevel	Získá nebo nastaví úroveň odsazení. (Zděděno od TraceListener)
IndentSize	Získá nebo nastaví počet mezer v odsazení. (Zděděno od TraceListener)
IsThreadSafe	Získá hodnotu označující, zda trasovací naslouchací proces je bezpečný z více vláken.
MaximumFileSize	Získá maximální velikost souboru protokolu.
MaximumNumberOfFiles	Získá maximální počet souborů protokolu.
Name	Získá nebo nastaví název pro tento TraceListener. (Zděděno od TraceListener)
NeedIndent	Získá nebo nastaví hodnotu označující, zda odsadit výstup. (Zděděno od TraceListener)
TraceLogRetentionOption	Získá možnost uchovávání protokolu trasování pro soubor.
TraceOutputOptions	Získá nebo nastaví možnosti výstupu trasování. (Zděděno od TraceListener)
Writer	Získá nebo nastaví základní zapisovač textu, který zapisuje do souboru protokolu.

Metody

Close()	Zavře soubor protokolu pro tento naslouchací proces, aby již nepřijímal výstup trasování nebo ladění.
CreateObjRef(Type)	Vytvoří objekt, který obsahuje všechny relevantní informace potřebné k vygenerování proxy používaného ke komunikaci se vzdáleným objektem. (Zděděno od MarshalByRefObject)
Dispose()	Uvolní všechny prostředky používané nástrojem TraceListener. (Zděděno od TraceListener)
Dispose(Boolean)	Odstraní tento TextWriterTraceListener objekt. (Zděděno od TextWriterTraceListener)
Equals(Object)	Určí, zda se zadaný objekt rovná aktuálnímu objektu. (Zděděno od Object)
Fail(String)	Vygeneruje chybovou zprávu do naslouchacího procesu, který vytvoříte při implementaci TraceListener třídy. (Zděděno od TraceListener)
Fail(String, String)	Zapíše informace o chybě, včetně základní chybové zprávy a podrobné chybové zprávy, do souboru protokolu.
Flush()	Způsobí zápis dat ve vyrovnávací paměti do protokolu pro tento naslouchací proces.
GetHashCode()	Slouží jako výchozí hashovací funkce. (Zděděno od Object)
GetLifetimeService()	Zastaralé. Načte objekt služby aktuální životnosti, který řídí zásady životnosti pro tuto instanci. (Zděděno od MarshalByRefObject)
GetSupportedAttributes()	Získá vlastní atributy konfigurace XML, které trasovací naslouchací proces podporuje.
GetType()	Získá aktuální Type instanci. (Zděděno od Object)
InitializeLifetimeService()	Zastaralé. Získá objekt služby životnosti, který řídí zásady životnosti pro tuto instanci. (Zděděno od MarshalByRefObject)
MemberwiseClone()	Vytvoří mělkou kopii aktuálního Objectsouboru . (Zděděno od Object)
MemberwiseClone(Boolean)	Vytvoří mělkou kopii aktuálního MarshalByRefObject objektu. (Zděděno od MarshalByRefObject)
ToString()	Vrátí řetězec, který představuje aktuální objekt. (Zděděno od Object)
TraceData(TraceEventCache, String, TraceEventType, Int32, Object)	Zapíše trasovací informace, jeden datový objekt a informace o událostech do souboru protokolu.
TraceData(TraceEventCache, String, TraceEventType, Int32, Object[])	Zapíše trasovací informace, více datových objektů a informace o událostech do souboru protokolu.
TraceEvent(TraceEventCache, String, TraceEventType, Int32)	Zapíše trasování a informace o událostech do výstupu specifického pro naslouchací proces. (Zděděno od TraceListener)
TraceEvent(TraceEventCache, String, TraceEventType, Int32, String)	Zapíše trasovací informace, zprávu a informace o událostech do souboru protokolu.
TraceEvent(TraceEventCache, String, TraceEventType, Int32, String, Object[])	Zapíše trasovací informace, formátovanou zprávu a informace o událostech do souboru protokolu.
TraceTransfer(TraceEventCache, String, Int32, String, Guid)	Zapíše trasovací informace, včetně identity související aktivity, zprávy a informací o událostech, do souboru protokolu.
Write(Object)	Zapíše hodnotu metody objektu ToString() do naslouchacího procesu, který vytvoříte při implementaci TraceListener třídy. (Zděděno od TraceListener)
Write(Object, String)	Zapíše název kategorie a hodnotu metody objektu ToString() do naslouchacího procesu, který vytvoříte při implementaci TraceListener třídy. (Zděděno od TraceListener)
Write(String)	Zapíše zprávu do souboru protokolu bez poskytnutí dalších kontextových informací.
Write(String, String)	Zapíše název kategorie a zprávu do naslouchacího procesu, který vytvoříte při implementaci TraceListener třídy. (Zděděno od TraceListener)
WriteIndent()	Zapíše odsazení do naslouchacího procesu, který vytvoříte při implementaci této třídy, a resetuje NeedIndent vlastnost na `false`. (Zděděno od TraceListener)
WriteLine(Object)	Zapíše hodnotu metody objektu ToString() do naslouchacího procesu, který vytvoříte při implementaci TraceListener třídy, následovaný ukončovacím znakem řádku. (Zděděno od TraceListener)
WriteLine(Object, String)	Zapíše název kategorie a hodnotu metody objektu ToString() do naslouchacího procesu, který vytvoříte při implementaci TraceListener třídy, následovaný ukončovacím znakem řádku. (Zděděno od TraceListener)
WriteLine(String)	Zapíše zprávu následovanou ukončovačem aktuálního řádku do souboru protokolu bez poskytnutí dalších kontextových informací.
WriteLine(String, String)	Zapíše název kategorie a zprávu naslouchacímu procesu, který vytvoříte při implementaci TraceListener třídy, následovaný ukončovacím znakem řádku. (Zděděno od TraceListener)

Platí pro