Switch Třída

Reference

Definice

Obor názvů:: System.Diagnostics

Sestavení:: System.Diagnostics.TraceSource.dll

Sestavení:: System.dll

Sestavení:: netstandard.dll

Zdroj:: Switch.cs

Zdroj:: Switch.cs

Zdroj:: Switch.cs

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

Poskytuje abstraktní základní třídu pro vytvoření nových přepínačů ladění a trasování.

public ref class Switch abstract

public abstract class Switch

type Switch = class

Public MustInherit Class Switch

Dědičnost: Object
Switch

Odvozené: System.Diagnostics.BooleanSwitch

System.Diagnostics.SourceSwitch

System.Diagnostics.TraceSwitch

Příklady

Následující příklad ukazuje, jak definovat novou Switch třídu se čtyřmi úrovněmi trasování, které lze použít k trasování zásobníku volání. Pomocí přepínače můžete instrumentovat aplikaci tak, aby protokolovala při každém zadání nebo ukončení metody.

První příklad vytvoří výčet použitý k nastavení úrovně přepínače.

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

Následující příklad vytvoří nový přepínač. Kód implementuje Level vlastnost pro nastavení hodnoty nového přepínače. Level volá chráněnou vlastnost SwitchSetting , která přiřadí hodnotu novému přepínači. Tento příklad také implementuje dvě vlastnosti posouzení, aby získaly přiřazenou hodnotu přepínače.

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

Následující příklad vytvoří nový přepínač v Mainsouboru . Vytvoří nový přepínač a přiřadí mu hodnotu. V závislosti na nastavení přepínače pak vypíše ladicí zprávy pro zadání a opuštění 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

Poznámky

Přepínač poskytuje efektivní mechanismus pro řízení výstupu trasování a ladění za běhu pomocí externího nastavení. Třída Switch implementuje výchozí chování přepínačů, což umožňuje změnit úroveň přepínače za běhu.

Tato třída je základní třídou pro BooleanSwitchtřídy , SourceSwitcha TraceSwitch . Tyto přepínače splňují většinu potřeb ladění a trasování. Další informace o přepínačích trasování naleznete v tématu Přepínače trasování.

Pokud chcete použít přepínač, musíte povolit trasování nebo ladění. Následující syntaxe je specifická pro kompilátor. Pokud používáte jiné kompilátory než C# nebo Visual Basic, přečtěte si dokumentaci k kompilátoru.

Pokud chcete povolit ladění v jazyce C#, přidejte /d:DEBUG příznak do příkazového řádku kompilátoru při kompilaci kódu, nebo ho můžete přidat #define DEBUG na začátek souboru. V jazyce Visual Basic přidejte /d:DEBUG=True příznak do příkazového řádku kompilátoru.
Pokud chcete povolit trasování pomocí v jazyce C#, přidejte /d:TRACE příznak do příkazového řádku kompilátoru při kompilaci kódu nebo přidejte #define TRACE na začátek souboru. V jazyce Visual Basic přidejte /d:TRACE=True příznak do příkazového řádku kompilátoru.

Pokud chcete nastavit úroveň přepínače v aplikaci .NET Framework, upravte konfigurační soubor, který odpovídá názvu vaší aplikace. Do tohoto souboru můžete přidat přepínač a nastavit jeho hodnotu, odebrat přepínač nebo vymazat všechny přepínače, které aplikace předtím nastavila. Konfigurační soubor by měl být formátovaný jako v následujícím příkladu:

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

Tento ukázkový oddíl konfigurace definuje BooleanSwitch vlastnost s DisplayName vlastností nastavenou na mySwitch a hodnotou nastavenou Enabled na true. V aplikaci můžete použít nakonfigurovanou hodnotu přepínače tak, že vytvoříte BooleanSwitch objekt se stejným názvem, jak je znázorněno v následujícím příkladu kódu.

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

Poznámky pro implementátory

Pokud potřebujete úrovně trasování nebo mechanismy pro nastavení úrovní přepínače, které se liší od těch, které BooleanSwitchposkytují , SourceSwitch a TraceSwitch, můžete dědit z Switch. Při dědění z této třídy musíte implementovat metodu SwitchSetting .

Konstruktory

Switch(String, String)	Inicializuje novou instanci Switch třídy .
Switch(String, String, String)	Inicializuje novou instanci Switch třídy zadáním zobrazovaného názvu, popisu a výchozí hodnoty přepínače.

Vlastnosti

Attributes	Získá vlastní atributy přepínače definované v konfiguračním souboru aplikace.
DefaultValue	Získá výchozí hodnotu přiřazenou v konstruktoru.
Description	Získá popis přepínače.
DisplayName	Získá název sloužící k identifikaci přepínače.
SwitchSetting	Získá nebo nastaví aktuální nastavení pro tento přepínač.
Value	Získá nebo nastaví hodnotu přepínače.

Metody

Equals(Object)	Určí, zda se zadaný objekt rovná aktuálnímu objektu. (Zděděno od Object)
GetHashCode()	Slouží jako výchozí hashovací funkce. (Zděděno od Object)
GetSupportedAttributes()	Získá vlastní atributy podporované přepínačem.
GetType()	Type Získá z aktuální instance. (Zděděno od Object)
MemberwiseClone()	Vytvoří mělkou kopii aktuálního Objectsouboru . (Zděděno od Object)
OnSwitchSettingChanged()	Vyvolá se SwitchSetting při změně vlastnosti.
OnValueChanged()	Vyvolá se Value při změně vlastnosti.
Refresh()	Aktualizuje konfigurační data trasování.
ToString()	Vrátí řetězec, který představuje aktuální objekt. (Zděděno od Object)

Událost

Initializing

Vyvolá se, Switch když je potřeba inicializovat.

Platí pro