Switch Klasa

Odwołanie

Definicja

Przestrzeń nazw:: System.Diagnostics

Zestaw:: System.Diagnostics.TraceSource.dll

Zestaw:: System.dll

Zestaw:: netstandard.dll

Źródło:: Switch.cs

Źródło:: Switch.cs

Źródło:: Switch.cs

Ważne

Niektóre informacje odnoszą się do produktu w wersji wstępnej, który może zostać znacząco zmodyfikowany przed wydaniem. Firma Microsoft nie udziela żadnych gwarancji, jawnych lub domniemanych, w odniesieniu do informacji podanych w tym miejscu.

Udostępnia abstrakcyjną klasę bazową do tworzenia nowych przełączników debugowania i śledzenia.

public ref class Switch abstract

public abstract class Switch

type Switch = class

Public MustInherit Class Switch

Dziedziczenie: Object
Switch

Pochodne: System.Diagnostics.BooleanSwitch

System.Diagnostics.SourceSwitch

System.Diagnostics.TraceSwitch

Przykłady

W poniższym przykładzie pokazano, jak zdefiniować nową Switch klasę z czterema poziomami śledzenia, których można użyć do śledzenia stosu wywołań. Możesz użyć przełącznika , aby instrumentować aplikację w celu rejestrowania za każdym razem, gdy metoda zostanie wprowadzona lub zakończona.

Pierwszy przykład tworzy wyliczenie używane do ustawiania poziomu przełącznika.

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

Poniższy przykład tworzy nowy przełącznik. Kod implementuje Level właściwość , aby ustawić wartość nowego przełącznika. Level wywołuje właściwość SwitchSetting chronioną, która przypisuje wartość do nowego przełącznika. W tym przykładzie zaimplementowane są również dwie właściwości oceniania w celu uzyskania przypisanej wartości przełącznika.

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

Poniższy przykład tworzy nowy przełącznik w programie Main. Tworzy nowy przełącznik i przypisuje mu wartość. Następnie, w zależności od ustawień przełącznika, generuje komunikaty debugowania do wprowadzania i opuszczania metody.

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

Uwagi

Przełącznik zapewnia wydajny mechanizm kontrolowania danych wyjściowych śledzenia i debugowania w czasie wykonywania przy użyciu ustawień zewnętrznych. Klasa Switch implementuje domyślne zachowanie przełączników, umożliwiając zmianę poziomu przełącznika w czasie wykonywania.

Ta klasa jest klasą bazową dla BooleanSwitchklas , SourceSwitchi TraceSwitch . Te przełączniki spełniają większość potrzeb debugowania i śledzenia. Aby uzyskać więcej informacji na temat przełączników śledzenia, zobacz Trace Switches (Przełączniki śledzenia).

Aby użyć przełącznika, należy włączyć śledzenie lub debugowanie. Następująca składnia jest specyficzna dla kompilatora. Jeśli używasz kompilatorów innych niż C# lub Visual Basic, zapoznaj się z dokumentacją kompilatora.

Aby włączyć debugowanie w języku C#, dodaj flagę /d:DEBUG do wiersza polecenia kompilatora podczas kompilowania kodu lub możesz dodać #define DEBUG ją na początku pliku. W języku Visual Basic dodaj flagę /d:DEBUG=True do wiersza polecenia kompilatora.
Aby włączyć śledzenie przy użyciu języka C#, dodaj flagę /d:TRACE do wiersza polecenia kompilatora podczas kompilowania kodu lub dodaj #define TRACE ją na początku pliku. W języku Visual Basic dodaj flagę /d:TRACE=True do wiersza polecenia kompilatora.

Aby ustawić poziom przełącznika w aplikacji .NET Framework, zmodyfikuj plik konfiguracji odpowiadający nazwie aplikacji. W tym pliku można dodać przełącznik i ustawić jego wartość, usunąć przełącznik lub wyczyścić wszystkie przełączniki ustawione wcześniej przez aplikację. Plik konfiguracji powinien być sformatowany tak, jak w poniższym przykładzie:

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

W tej przykładowej sekcji konfiguracji zdefiniowano BooleanSwitch element z właściwością ustawioną DisplayName na mySwitch , a wartość ustawioną Enabled na true. W aplikacji można użyć skonfigurowanej wartości przełącznika, tworząc element BooleanSwitch o tej samej nazwie, jak pokazano w poniższym przykładzie kodu.

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)
    {
        //...
    }
}

Uwagi dotyczące implementowania

Jeśli potrzebujesz poziomów śledzenia lub mechanizmów ustawiania poziomów przełączników innych niż te udostępniane przez BooleanSwitch, SourceSwitch i TraceSwitch, możesz dziedziczyć z Switchklasy . Podczas dziedziczenia z tej klasy należy zaimplementować metodę SwitchSetting .

Konstruktory

Switch(String, String)	Inicjuje nowe wystąpienie klasy Switch.
Switch(String, String, String)	Inicjuje Switch nowe wystąpienie klasy, określając nazwę wyświetlaną, opis i wartość domyślną przełącznika.

Właściwości

Attributes	Pobiera atrybuty przełącznika niestandardowego zdefiniowane w pliku konfiguracji aplikacji.
DefaultValue	Pobiera wartość domyślną przypisaną w konstruktorze.
Description	Pobiera opis przełącznika.
DisplayName	Pobiera nazwę używaną do identyfikowania przełącznika.
SwitchSetting	Pobiera lub ustawia bieżące ustawienie dla tego przełącznika.
Value	Pobiera lub ustawia wartość przełącznika.

Metody

Equals(Object)	Określa, czy dany obiekt jest taki sam, jak bieżący obiekt. (Odziedziczone po Object)
GetHashCode()	Służy jako domyślna funkcja skrótu. (Odziedziczone po Object)
GetSupportedAttributes()	Pobiera atrybuty niestandardowe obsługiwane przez przełącznik.
GetType()	Type Pobiera wartość bieżącego wystąpienia. (Odziedziczone po Object)
MemberwiseClone()	Tworzy płytkią kopię bieżącego Objectelementu . (Odziedziczone po Object)
OnSwitchSettingChanged()	Wywoływane SwitchSetting po zmianie właściwości.
OnValueChanged()	Wywoływane Value po zmianie właściwości.
Refresh()	Odświeża dane konfiguracji śledzenia.
ToString()	Zwraca ciąg reprezentujący bieżący obiekt. (Odziedziczone po Object)

Zdarzenia

Initializing

Występuje, gdy należy zainicjować element Switch .

Dotyczy