Switch Classe

Definizione

public ref class Switch abstract

public abstract class Switch

type Switch = class

Public MustInherit Class Switch

Ereditarietà

Object

Switch

Derivato

System.Diagnostics.BooleanSwitch

System.Diagnostics.SourceSwitch

System.Diagnostics.TraceSwitch

Esempio

Nell'esempio seguente viene illustrato come definire una nuova Switch classe con quattro livelli di traccia che possono essere usati per tracciare uno stack di chiamate. È possibile usare l'opzione per instrumentare l'applicazione per registrare ogni volta che il metodo viene immesso o chiuso.

Il primo esempio crea l'enumerazione usata per impostare il livello dell'opzione.

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

Nell'esempio seguente viene creata la nuova opzione. Il codice implementa una Level proprietà per impostare il valore del nuovo commutatore. Level chiama la proprietà SwitchSetting protetta che assegna il valore al nuovo commutatore. In questo esempio vengono implementate anche due proprietà di assessore per ottenere il valore assegnato dell'opzione.

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

Nell'esempio seguente viene creata una nuova opzione in Main. Crea un nuovo commutatore e lo assegna a un valore. Quindi, a seconda delle impostazioni del commutatore, restituisce i messaggi di debug per l'immissione e l'uscita del metodo.

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

Commenti

Un commutatore fornisce un meccanismo efficiente per controllare l'output di traccia e debug in fase di esecuzione usando le impostazioni esterne. La Switch classe implementa il comportamento predefinito per le opzioni, consentendo di modificare il livello di cambio in fase di esecuzione.

Questa classe è la classe di base per le BooleanSwitchclassi , SourceSwitche TraceSwitch . Queste opzioni soddisfano la maggior parte delle esigenze di debug e traccia. Per altre informazioni sulle opzioni di traccia, vedere Commutatori di traccia.

È necessario abilitare la traccia o il debug per usare un commutatore. La sintassi seguente è specifica del compilatore. Se si usano compilatori diversi da C# o Visual Basic, vedere la documentazione del compilatore.

• Per abilitare il debug in C#, aggiungere il flag alla riga di comando del compilatore quando si compila il /d:DEBUG codice oppure aggiungere #define DEBUG alla parte superiore del file. In Visual Basic aggiungere il /d:DEBUG=True flag alla riga di comando del compilatore.

• Per abilitare la traccia usando in C#, aggiungere il flag alla riga di comando del compilatore quando si compila il /d:TRACE codice o aggiungere #define TRACE alla parte superiore del file. In Visual Basic aggiungere il /d:TRACE=True flag alla riga di comando del compilatore.

Per impostare il livello del commutatore in un'app .NET Framework, modificare il file di configurazione corrispondente al nome dell'applicazione. All'interno di questo file è possibile aggiungere un commutatore e impostarne il valore, rimuovere un'opzione o cancellare tutte le opzioni impostate in precedenza dall'applicazione. Il file di configurazione deve essere formattato come l'esempio seguente:

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

Questa sezione di configurazione di esempio definisce un BooleanSwitch oggetto con la DisplayName proprietà impostata su mySwitch e il Enabled valore impostato su true. All'interno dell'applicazione è possibile usare il valore del commutatore configurato creando un BooleanSwitch oggetto con lo stesso nome, come illustrato nell'esempio di codice seguente.

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

Note per gli implementatori

Se sono necessari livelli di traccia o meccanismi per impostare i livelli di cambio diversi da quelli forniti da BooleanSwitchSourceSwitch e TraceSwitch, è possibile ereditare da Switch. Quando si eredita da questa classe, è necessario implementare il SwitchSetting metodo.

Costruttori

Proprietà

Metodi

Eventi

Si applica a

Vedi anche

• BooleanSwitch
• TraceSwitch
• Debug
• Trace
• Opzioni di traccia