Switch Klass

Definition

public ref class Switch abstract

public abstract class Switch

type Switch = class

Public MustInherit Class Switch

Arv

Object

Switch

Härledda

System.Diagnostics.BooleanSwitch

System.Diagnostics.SourceSwitch

System.Diagnostics.TraceSwitch

Exempel

I följande exempel visas hur du definierar en ny Switch klass med fyra nivåer av spårning som kan användas för att spåra en anropsstack. Du kan använda växeln för att instrumentera programmet för att logga varje gång metoden anges eller avslutas.

I det första exemplet skapas den uppräkning som används för att ange växelns nivå.

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

I följande exempel skapas den nya växeln. Koden implementerar en Level egenskap för att ange värdet för den nya växeln. Level anropar den skyddade egenskapen SwitchSetting som tilldelar värdet till den nya växeln. Det här exemplet implementerar också två utvärderaregenskaper för att hämta det tilldelade värdet för växeln.

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

I följande exempel skapas en ny växel i Main. Den skapar en ny växel och tilldelar den ett värde. Beroende på växelinställningarna matar den sedan ut felsökningsmeddelanden för att ange och lämna metoden.

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

Kommentarer

En växel ger en effektiv mekanism för att kontrollera spårning och felsökning av utdata vid körning med hjälp av externa inställningar. Klassen Switch implementerar standardbeteendet för växlar, så att du kan ändra växelnivån vid körning.

Den här klassen är basklassen för klasserna BooleanSwitch, SourceSwitchoch TraceSwitch . Dessa växlar uppfyller de flesta felsöknings- och spårningsbehov. Mer information om spårningsväxlar finns i Spårningsväxlar.

Du måste aktivera spårning eller felsökning för att kunna använda en växel. Följande syntax är kompilatorspecifik. Om du använder andra kompilatorer än C# eller Visual Basic läser du dokumentationen för kompilatorn.

• Om du vill aktivera felsökning i C# lägger du till /d:DEBUG flaggan på kommandoraden för kompilatorn när du kompilerar koden, eller så kan du lägga till #define DEBUG överst i filen. I Visual Basic lägger du till flaggan /d:DEBUG=True på kommandoraden för kompilatorn.

• Om du vill aktivera spårning med hjälp av i C# lägger du till /d:TRACE flaggan på kommandoraden för kompilatorn när du kompilerar koden eller lägger till #define TRACE den överst i filen. I Visual Basic lägger du till flaggan /d:TRACE=True på kommandoraden för kompilatorn.

Om du vill ange nivån för växeln i en .NET Framework-app redigerar du konfigurationsfilen som motsvarar namnet på ditt program. I den här filen kan du lägga till en växel och ange dess värde, ta bort en växel eller rensa alla växlar som tidigare angetts av programmet. Konfigurationsfilen ska formateras som i följande exempel:

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

Det här exempelkonfigurationsavsnittet definierar en BooleanSwitch med egenskapen DisplayName inställd på mySwitch och värdet Enabled inställt på true. I ditt program kan du använda det konfigurerade växelvärdet genom att skapa ett BooleanSwitch med samma namn, som du ser i följande kodexempel.

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

Anteckningar till implementerare

Om du behöver spårningsnivåer eller mekanismer för att ställa in växelnivåer som skiljer sig från de som tillhandahålls av BooleanSwitch, SourceSwitch och TraceSwitch, kan du ärva från Switch. När du ärver från den här klassen måste du implementera SwitchSetting metoden.

Se även

• BooleanSwitch
• TraceSwitch
• Debug
• Trace
• Trace-omkopplare