DefaultTraceListener Klas

Definitie

public ref class DefaultTraceListener : System::Diagnostics::TraceListener

public class DefaultTraceListener : System.Diagnostics.TraceListener

[System.Runtime.InteropServices.ComVisible(false)]
public class DefaultTraceListener : System.Diagnostics.TraceListener

type DefaultTraceListener = class
    inherit TraceListener

[<System.Runtime.InteropServices.ComVisible(false)>]
type DefaultTraceListener = class
    inherit TraceListener

Public Class DefaultTraceListener
Inherits TraceListener

Overname

Object

MarshalByRefObject

TraceListener

DefaultTraceListener

Overname

Object

TraceListener

DefaultTraceListener

Kenmerken

ComVisibleAttribute

Voorbeelden

In het volgende codevoorbeeld worden binomiale coëfficiënten berekend. Dit zijn waarden die worden gebruikt in waarschijnlijkheid en statistieken. In dit voorbeeld wordt een om DefaultTraceListener resultaten en logboekfouten te traceren. Er wordt een nieuwe DefaultTraceListenergemaakt, toegevoegd aan de Trace.Listeners verzameling en de LogFileName eigenschap wordt ingesteld op het logboekbestand dat is opgegeven in de opdrachtregelargumenten.

Als er een fout wordt gedetecteerd tijdens het verwerken van de invoerparameter of als de CalcBinomial functie een uitzondering genereert, worden de Fail methodelogboeken en een foutbericht weergegeven. Als de AssertUiEnabled eigenschap is false, wordt het foutbericht ook naar de console geschreven. Wanneer het resultaat is berekend, schrijven de Write(String) en WriteLine(String) methoden de resultaten naar het logboekbestand.

De Fail, Writeen WriteLine methoden zorgen ervoor dat traceringsinformatie alleen naar de DefaultTraceListener. Als u traceringsinformatie naar alle listeners in de Trace.Listeners verzameling wilt schrijven, gebruikt u de Failen WriteWriteLine methoden van de Trace klasse.

using System;
using System.Diagnostics;
using Microsoft.VisualBasic;

class Binomial
{

    // args(0) is the number of possibilities for binomial coefficients.
    // args(1) is the file specification for the trace log file.
    public static void Main(string[] args)
    {

        decimal possibilities;
        decimal iter;

        // Remove the original default trace listener.
        Trace.Listeners.RemoveAt(0);

        // Create and add a new default trace listener.
        DefaultTraceListener defaultListener;
        defaultListener = new DefaultTraceListener();
        Trace.Listeners.Add(defaultListener);

        // Assign the log file specification from the command line, if entered.
        if (args.Length>=2)
        {
            defaultListener.LogFileName = args[1];
        }

        // Validate the number of possibilities argument.
        if (args.Length>=1)

            // Verify that the argument is a number within the correct range.
        {
            try
            {
                const decimal MAX_POSSIBILITIES = 99;
                possibilities = Decimal.Parse(args[0]);
                if (possibilities<0||possibilities>MAX_POSSIBILITIES)
                {
                    throw new Exception(String.Format("The number of possibilities must " +
                        "be in the range 0..{0}.", MAX_POSSIBILITIES));
                }
            }
            catch(Exception ex)
            {
                string failMessage = String.Format("\"{0}\" " +
                    "is not a valid number of possibilities.", args[0]);
                defaultListener.Fail(failMessage, ex.Message);
                if (!defaultListener.AssertUiEnabled)
                {
                    Console.WriteLine(failMessage+ "\n" +ex.Message);
                }
                return;
            }
        }
        else
        {
            // Report that the required argument is not present.
            const string ENTER_PARAM = "Enter the number of " +
                      "possibilities as a command line argument.";
            defaultListener.Fail(ENTER_PARAM);
            if (!defaultListener.AssertUiEnabled)
            {
                Console.WriteLine(ENTER_PARAM);
            }
            return;
        }

        for(iter=0; iter<=possibilities; iter++)
        {
            decimal result;
            string binomial;

            // Compute the next binomial coefficient and handle all exceptions.
            try
            {
                result = CalcBinomial(possibilities, iter);
            }
            catch(Exception ex)
            {
                string failMessage = String.Format("An exception was raised when " +
                    "calculating Binomial( {0}, {1} ).", possibilities, iter);
                defaultListener.Fail(failMessage, ex.Message);
                if (!defaultListener.AssertUiEnabled)
                {
                    Console.WriteLine(failMessage+ "\n" +ex.Message);
                }
                return;
            }

            // Format the trace and console output.
            binomial = String.Format("Binomial( {0}, {1} ) = ", possibilities, iter);
            defaultListener.Write(binomial);
            defaultListener.WriteLine(result.ToString());
            Console.WriteLine("{0} {1}", binomial, result);
        }
    }

    public static decimal CalcBinomial(decimal possibilities, decimal outcomes)
    {

        // Calculate a binomial coefficient, and minimize the chance of overflow.
        decimal result = 1;
        decimal iter;
        for(iter=1; iter<=possibilities-outcomes; iter++)
        {
            result *= outcomes+iter;
            result /= iter;
        }
        return result;
    }
}

Imports System.Diagnostics

Module Binomial

    ' args(0) is the number of possibilities for binomial coefficients.
    ' args(1) is the file specification for the trace log file.
    Sub Main(ByVal args() As String)

        Dim possibilities As Decimal
        Dim iter As Decimal

        ' Remove the original default trace listener.
        Trace.Listeners.RemoveAt(0)

        ' Create and add a new default trace listener.
        Dim defaultListener As DefaultTraceListener
        defaultListener = New DefaultTraceListener
        Trace.Listeners.Add(defaultListener)

        ' Assign the log file specification from the command line, if entered.
        If args.Length >= 2 Then
            defaultListener.LogFileName = args(1)
        End If

        ' Validate the number of possibilities argument.
        If args.Length >= 1 Then

            ' Verify that the argument is a number within the correct range.
            Try
                Const MAX_POSSIBILITIES As Decimal = 99
                possibilities = Decimal.Parse(args(0))
                If possibilities < 0 Or possibilities > MAX_POSSIBILITIES Then
                    Throw New Exception( _
                        String.Format("The number of possibilities must " & _
                            "be in the range 0..{0}.", MAX_POSSIBILITIES))
                End If
            Catch ex As Exception
                Dim failMessage As String = String.Format("""{0}"" " & _
                    "is not a valid number of possibilities.", args(0))
                defaultListener.Fail(failMessage, ex.Message)
                If Not defaultListener.AssertUiEnabled Then
                    Console.WriteLine(failMessage & vbCrLf & ex.Message)
                End If
                Return
            End Try
        Else
            ' Report that the required argument is not present.
            Const ENTER_PARAM As String = "Enter the number of " & _
                "possibilities as a command line argument."
            defaultListener.Fail(ENTER_PARAM)
            If Not defaultListener.AssertUiEnabled Then
                Console.WriteLine(ENTER_PARAM)
            End If
            Return
        End If

        For iter = 0 To possibilities
            Dim result As Decimal
            Dim binomial As String

            ' Compute the next binomial coefficient and handle all exceptions.
            Try
                result = CalcBinomial(possibilities, iter)
            Catch ex As Exception
                Dim failMessage As String = String.Format( _
                        "An exception was raised when " & _
                        "calculating Binomial( {0}, {1} ).", _
                        possibilities, iter)
                defaultListener.Fail(failmessage, ex.Message)
                If Not defaultListener.AssertUiEnabled Then
                    Console.WriteLine(failMessage & vbCrLf & ex.Message)
                End If
                Return
            End Try

            ' Format the trace and console output.
            binomial = String.Format("Binomial( {0}, {1} ) = ", _
                            possibilities, iter)
            defaultListener.Write(binomial)
            defaultListener.WriteLine(result.ToString)
            Console.WriteLine("{0} {1}", binomial, result)
        Next
    End Sub

    Function CalcBinomial(ByVal possibilities As Decimal, _
                        ByVal outcomes As Decimal) As Decimal

        ' Calculate a binomial coefficient, and minimize the chance of overflow.
        Dim result As Decimal = 1
        Dim iter As Decimal
        For iter = 1 To possibilities - outcomes
            result *= outcomes + iter
            result /= iter
        Next
        Return result
    End Function
End Module

Opmerkingen

Er wordt automatisch een exemplaar van deze klasse toegevoegd aan de Debug.Listeners en Trace.Listeners verzamelingen. Als u expliciet een seconde DefaultTraceListener toevoegt, worden dubbele berichten in het uitvoervenster van het foutopsporingsprogramma en dubbele berichtvakken voor asserties veroorzaakt.

Standaard verzenden de Write en WriteLine methoden het bericht naar de functie Win32 OutputDebugString en naar de Debugger.Log methode.

De Fail methode geeft standaard een berichtvak weer wanneer de toepassing wordt uitgevoerd in een gebruikersinterfacemodus. Het bericht wordt ook verzonden met behulp van WriteLine.

U moet tracering of foutopsporing inschakelen om een traceringslistener te gebruiken. De volgende syntaxis is specifiek voor compileren. Als u andere compilers dan C# of Visual Basic gebruikt, raadpleegt u de documentatie voor uw compiler.

• Als u foutopsporing in C# wilt inschakelen, voegt u de /d:DEBUG vlag toe aan de opdrachtregel van de compiler wanneer u uw code compileert of voegt u deze toe #define DEBUG aan het begin van het bestand. Voeg in Visual Basic de vlag /d:DEBUG=True toe aan de opdrachtregel van de compiler.

• Als u tracering in C# wilt inschakelen, voegt u de /d:TRACE vlag toe aan de opdrachtregel van de compiler wanneer u uw code compileert of voegt u deze toe #define TRACE aan het begin van het bestand. Voeg in Visual Basic de vlag /d:TRACE=True toe aan de opdrachtregel van de compiler.

Voor .NET Framework-apps kunt u een traceringslistener toevoegen door het configuratiebestand te bewerken dat overeenkomt met de naam van uw toepassing. In dit bestand kunt u een listener toevoegen, het type instellen en de parameters instellen, een listener verwijderen of alle listeners wissen die eerder door de toepassing zijn ingesteld. Het configuratiebestand moet worden opgemaakt zoals in het volgende voorbeeld:

<configuration>
<system.diagnostics>
  <trace autoflush="false" indentsize="4">
    <listeners>
      <remove name="Default" />
      <add name="myListener" type="System.Diagnostics.TextWriterTraceListener" initializeData="c:\myListener.log" />
    </listeners>
  </trace>
</system.diagnostics>
</configuration>

Veiligheid thread

Deze klasse is thread veilig.

Zie ook

• TraceListener
• TextWriterTraceListener
• ConsoleTraceListener
• Debug
• Trace