Switch Klasse

Referenz

Definition

Namespace:: System.Diagnostics

Assembly:: System.Diagnostics.TraceSource.dll

Assembly:: System.dll

Assembly:: netstandard.dll

Quelle:: Switch.cs

Quelle:: Switch.cs

Quelle:: Switch.cs

Wichtig

Einige Informationen beziehen sich auf Vorabversionen, die vor dem Release ggf. grundlegend überarbeitet werden. Microsoft übernimmt hinsichtlich der hier bereitgestellten Informationen keine Gewährleistungen, seien sie ausdrücklich oder konkludent.

Stellt eine abstrakte Basisklasse zum Erstellen neuer Schalter für Debuggen und Ablaufverfolgung bereit.

public ref class Switch abstract

public abstract class Switch

type Switch = class

Public MustInherit Class Switch

Vererbung: Object
Switch

Abgeleitet: System.Diagnostics.BooleanSwitch

System.Diagnostics.SourceSwitch

System.Diagnostics.TraceSwitch

Beispiele

Das folgende Beispiel zeigt, wie sie eine neue Switch Klasse mit vier Ablaufverfolgungsebenen definieren, die zum Nachverfolgen eines Aufrufstapels verwendet werden können. Sie können den Switch verwenden, um Ihre Anwendung zu instrumentieren, um jedes Mal zu protokollieren, wenn die Methode eingegeben oder beendet wird.

Im ersten Beispiel wird die Enumeration erstellt, mit der die Switchebene festgelegt wird.

// The following are possible values for the new switch.
public enum class MethodTracingSwitchLevel
{
    Off = 0,
    EnteringMethod = 1,
    ExitingMethod = 2,
    Both = 3
};

// The following are possible values for the new switch.
public enum MethodTracingSwitchLevel
{
    Off = 0,
    EnteringMethod = 1,
    ExitingMethod = 2,
    Both = 3,
}

' The following are possible values for the new switch.
Public Enum MethodTracingSwitchLevel
    Off = 0
    EnteringMethod = 1
    ExitingMethod = 2
    Both = 3
End Enum 'MethodTracingSwitchLevel

Im folgenden Beispiel wird der neue Switch erstellt. Der Code implementiert eine Level Eigenschaft, um den Wert des neuen Switches festzulegen. Level ruft die geschützte Eigenschaft SwitchSetting auf, die den Wert dem neuen Switch zuweist. In diesem Beispiel werden auch zwei Bewertungseigenschaften implementiert, um den zugewiesenen Wert des Switches abzurufen.

public ref class MyMethodTracingSwitch: public Switch
{
protected:
    bool outExit;
    bool outEnter;
    MethodTracingSwitchLevel level;

public:
    MyMethodTracingSwitch( String^ displayName, String^ description )
       : Switch( displayName, description )
    {}

    property MethodTracingSwitchLevel Level
    {
        MethodTracingSwitchLevel get()
        {
            return level;
        }

       void set( MethodTracingSwitchLevel value )
       {
           SetSwitchSetting( (int)value );
       }
    }

protected:
    void SetSwitchSetting( int value )
    {
        if ( value < 0 )
        {
            value = 0;
        }

        if ( value > 3 )
        {
            value = 3;
        }

        level = (MethodTracingSwitchLevel)value;
        outEnter = false;
        if ((value == (int)MethodTracingSwitchLevel::EnteringMethod) ||
            (value == (int)MethodTracingSwitchLevel::Both))
        {
            outEnter = true;
        }

        outExit = false;
        if ((value == (int)MethodTracingSwitchLevel::ExitingMethod) ||
            (value == (int)MethodTracingSwitchLevel::Both))
        {
            outExit = true;
        }
    }

public:
    property bool OutputExit
    {
        bool get()
        {
            return outExit;
        }
    }

    property bool OutputEnter
    {
        bool get()
        {
            return outEnter;
        }
    }
};

public class MyMethodTracingSwitch : Switch
{
    protected bool outExit;
    protected bool outEnter;
    protected MethodTracingSwitchLevel level;

    public MyMethodTracingSwitch(string displayName, string description) :
        base(displayName, description)
    {
    }

    public MethodTracingSwitchLevel Level
    {
        get
        {
            return level;
        }
        set
        {
            SetSwitchSetting((int)value);
        }
    }

    protected void SetSwitchSetting(int value)
    {
        if (value < 0)
        {
            value = 0;
        }
        if (value > 3)
        {
            value = 3;
        }

        level = (MethodTracingSwitchLevel)value;

        outEnter = false;
        if ((value == (int)MethodTracingSwitchLevel.EnteringMethod) ||
            (value == (int)MethodTracingSwitchLevel.Both))
        {
            outEnter = true;
        }

        outExit = false;
        if ((value == (int)MethodTracingSwitchLevel.ExitingMethod) ||
            (value == (int)MethodTracingSwitchLevel.Both))
        {
            outExit = true;
        }
    }

    public bool OutputExit
    {
        get
        {
            return outExit;
        }
    }

    public bool OutputEnter
    {
        get
        {
            return outEnter;
        }
    }
}

Public Class MyMethodTracingSwitch
    Inherits Switch
    Protected outExit As Boolean
    Protected outEnter As Boolean
    Protected myLevel As MethodTracingSwitchLevel
    
    Public Sub New(displayName As String, description As String)
        MyBase.New(displayName, description)
    End Sub


    Public Property Level() As MethodTracingSwitchLevel
        Get
            Return myLevel
        End Get
        Set
            SetSwitchSetting(CInt(value))
        End Set
    End Property


    Protected Sub SetSwitchSetting(value As Integer)
        If value < 0 Then
            value = 0
        End If
        If value > 3 Then
            value = 3
        End If

        myLevel = CType(value, MethodTracingSwitchLevel)

        outEnter = False
        If value = CInt(MethodTracingSwitchLevel.EnteringMethod) Or _
            value = CInt(MethodTracingSwitchLevel.Both) Then

            outEnter = True
        End If

        outExit = False
        If value = CInt(MethodTracingSwitchLevel.ExitingMethod) Or _
            value = CInt(MethodTracingSwitchLevel.Both) Then

            outExit = True
        End If
    End Sub


    Public ReadOnly Property OutputExit() As Boolean
        Get
            Return outExit
        End Get
    End Property


    Public ReadOnly Property OutputEnter() As Boolean
        Get
            Return outEnter
        End Get
    End Property
End Class

Im folgenden Beispiel wird ein neuer Switch in Mainerstellt. Er erstellt einen neuen Switch und weist ihm einen Wert zu. Abhängig von den Schaltereinstellungen werden dann Debugmeldungen zum Eingeben und Verlassen der Methode ausgegeben.

public ref class Class1
{
private:

    /* Create an instance of MyMethodTracingSwitch.*/
    static MyMethodTracingSwitch^ mySwitch =
        gcnew MyMethodTracingSwitch( "Methods","Trace entering and exiting method" );

public:
    static void main()
    {
        // Add the console listener to see trace messages as console output
        Trace::Listeners->Add(gcnew ConsoleTraceListener(true));
        Debug::AutoFlush = true;

        // Set the switch level to both enter and exit
        mySwitch->Level = MethodTracingSwitchLevel::Both;

        // Write a diagnostic message if the switch is set to entering.
        Debug::WriteLineIf(mySwitch->OutputEnter, "Entering Main");

        // Insert code to handle processing here...

        // Write another diagnostic message if the switch is set to exiting.
        Debug::WriteLineIf(mySwitch->OutputExit, "Exiting Main");
    }
};

public class Class1
{
    /* Create an instance of MyMethodTracingSwitch.*/
    static MyMethodTracingSwitch mySwitch =
        new MyMethodTracingSwitch("Methods", "Trace entering and exiting method");

    public static void Main()
    {
        // Add the console listener to see trace messages as console output
        Trace.Listeners.Add(new ConsoleTraceListener(true));
        Debug.AutoFlush = true;

        // Set the switch level to both enter and exit
        mySwitch.Level = MethodTracingSwitchLevel.Both;

        // Write a diagnostic message if the switch is set to entering.
        Debug.WriteLineIf(mySwitch.OutputEnter, "Entering Main");

        // Insert code to handle processing here...

        // Write another diagnostic message if the switch is set to exiting.
        Debug.WriteLineIf(mySwitch.OutputExit, "Exiting Main");
    }
}

Public Class Class1
    ' Create an instance of MyMethodTracingSwitch.
    Private Shared mySwitch As New _
        MyMethodTracingSwitch("Methods", "Trace entering and exiting method")

    Public Shared Sub Main()
        ' Add the console listener to see trace messages as console output
        Trace.Listeners.Add(New ConsoleTraceListener(True))
        Debug.AutoFlush = True

        ' Set the switch level to both enter and exit
        mySwitch.Level = MethodTracingSwitchLevel.Both

        ' Write a diagnostic message if the switch is set to entering.
        Debug.WriteLineIf(mySwitch.OutputEnter, "Entering Main")

        ' Insert code to handle processing here...

        ' Write another diagnostic message if the switch is set to exiting.
        Debug.WriteLineIf(mySwitch.OutputExit, "Exiting Main")
    End Sub
End Class

Hinweise

Ein Switch bietet einen effizienten Mechanismus zum Steuern der Ablaufverfolgung und zum Debuggen der Ausgabe zur Laufzeit mithilfe externer Einstellungen. Die Switch -Klasse implementiert das Standardverhalten für Switches, sodass Sie die Switchebene zur Laufzeit ändern können.

Diese Klasse ist die Basisklasse für die BooleanSwitchKlassen , SourceSwitchund TraceSwitch . Diese Switches erfüllen die meisten Debug- und Ablaufverfolgungsanforderungen. Weitere Informationen zu Ablaufverfolgungsschaltern finden Sie unter Ablaufverfolgungsschalter.

Sie müssen die Ablaufverfolgung oder das Debuggen aktivieren, um einen Switch verwenden zu können. Die folgende Syntax ist compilerspezifisch. Wenn Sie andere Compiler als C# oder Visual Basic verwenden, lesen Sie die Dokumentation für Ihren Compiler.

Um das Debuggen in C# zu aktivieren, fügen Sie das /d:DEBUG Flag der Compiler-Befehlszeile hinzu, wenn Sie Ihren Code kompilieren, oder Sie können die Datei oben hinzufügen #define DEBUG . Fügen Sie in Visual Basic der Compiler-Befehlszeile das /d:DEBUG=True Flag hinzu.
Um die Ablaufverfolgung mit in C# zu aktivieren, fügen Sie das /d:TRACE Flag der Compilerbefehlszeile hinzu, wenn Sie Ihren Code kompilieren, oder fügen Sie die Datei oben hinzu #define TRACE . Fügen Sie in Visual Basic der Compiler-Befehlszeile das /d:TRACE=True Flag hinzu.

Um die Ebene Ihres Switches in einer .NET Framework-App festzulegen, bearbeiten Sie die Konfigurationsdatei, die dem Namen Ihrer Anwendung entspricht. In dieser Datei können Sie einen Switch hinzufügen und dessen Wert festlegen, einen Schalter entfernen oder alle zuvor von der Anwendung festgelegten Switches löschen. Die Konfigurationsdatei sollte wie im folgenden Beispiel formatiert werden:

<configuration>  
  <system.diagnostics>  
    <switches>  
      <add name="mySwitch" value="true" />  
    </switches>  
  </system.diagnostics>  
</configuration>

In diesem Beispielkonfigurationsabschnitt wird ein BooleanSwitch definiert, wobei die DisplayName Eigenschaft auf mySwitch und der Enabled Wert auf festgelegt ist true. In Ihrer Anwendung können Sie den konfigurierten Switchwert verwenden, indem Sie einen BooleanSwitch mit demselben Namen erstellen, wie im folgenden Codebeispiel gezeigt.

private:
    static BooleanSwitch^ boolSwitch = gcnew BooleanSwitch("mySwitch",
        "Switch in config file");

public:
    static void Main( )
    {
        //...
        Console::WriteLine("Boolean switch {0} configured as {1}",
            boolSwitch->DisplayName, ((Boolean^)boolSwitch->Enabled)->ToString());
        if (boolSwitch->Enabled)
        {
            //...
        }
    }

private static BooleanSwitch boolSwitch = new BooleanSwitch("mySwitch",
    "Switch in config file");

public static void Main()
{
    //...
    Console.WriteLine("Boolean switch {0} configured as {1}",
        boolSwitch.DisplayName, boolSwitch.Enabled.ToString());
    if (boolSwitch.Enabled)
    {
        //...
    }
}

Hinweise für Ausführende

Wenn Sie Ablaufverfolgungsebenen oder Mechanismen zum Festlegen von Schalterebenen benötigen, die sich von den von BooleanSwitchund SourceSwitch TraceSwitchbereitgestellten unterscheiden, können Sie von erben Switch. Wenn Sie von dieser Klasse erben, müssen Sie die SwitchSetting -Methode implementieren.

Konstruktoren

Switch(String, String)	Initialisiert eine neue Instanz der Switch-Klasse.
Switch(String, String, String)	Initialisiert eine neue Instanz der Switch-Klasse und gibt den Anzeigenamen, die Beschreibung und den Standardwert für den Schalter an.

Eigenschaften

Attributes	Ruft die benutzerdefinierten Schalterattribute ab, die in der Anwendungskonfigurationsdatei definiert sind.
DefaultValue	Ruft den im Konstruktor zugewiesenen Standardwert ab.
Description	Ruft eine Beschreibung des Schalters ab.
DisplayName	Ruft einen Namen zum Bezeichnen des Schalters ab.
SwitchSetting	Ruft die aktuelle Einstellung des Schalters ab oder legt diese fest.
Value	Ruft den Wert des Schalters ab oder legt diesen fest.

Methoden

Equals(Object)	Bestimmt, ob das angegebene Objekt gleich dem aktuellen Objekt ist. (Geerbt von Object)
GetHashCode()	Fungiert als Standardhashfunktion. (Geerbt von Object)
GetSupportedAttributes()	Ruft die benutzerdefinierten Attribute ab, die vom Schalter unterstützt werden.
GetType()	Ruft den Type der aktuellen Instanz ab. (Geerbt von Object)
MemberwiseClone()	Erstellt eine flache Kopie des aktuellen Object. (Geerbt von Object)
OnSwitchSettingChanged()	Wird aufgerufen, wenn die SwitchSetting-Eigenschaft geändert wird.
OnValueChanged()	Wird aufgerufen, wenn die Value-Eigenschaft geändert wird.
Refresh()	Aktualisiert die Konfigurationsdaten für die Ablaufverfolgung.
ToString()	Gibt eine Zeichenfolge zurück, die das aktuelle Objekt darstellt. (Geerbt von Object)

Ereignisse

Initializing

Tritt auf, wenn ein Switch initialisiert werden muss.

Gilt für:

Teilen über