Switch Classe

Référence

Définition

Espace de noms:: System.Diagnostics

Assembly:: System.Diagnostics.TraceSource.dll

Assembly:: System.dll

Assembly:: netstandard.dll

Source:: Switch.cs

Source:: Switch.cs

Source:: Switch.cs

Important

Certaines informations portent sur la préversion du produit qui est susceptible d’être en grande partie modifiée avant sa publication. Microsoft exclut toute garantie, expresse ou implicite, concernant les informations fournies ici.

Fournit une classe de base abstraite pour créer des commutateurs de débogage et de traçage.

public ref class Switch abstract

public abstract class Switch

type Switch = class

Public MustInherit Class Switch

Héritage: Object
Switch

Dérivé: System.Diagnostics.BooleanSwitch

System.Diagnostics.SourceSwitch

System.Diagnostics.TraceSwitch

Exemples

L’exemple suivant montre comment définir une nouvelle Switch classe avec quatre niveaux de suivi qui peuvent être utilisés pour tracer une pile d’appels. Vous pouvez utiliser le commutateur pour instrumenter votre application afin de journaliser chaque fois que la méthode est entrée ou sortie.

Le premier exemple crée l’énumération utilisée pour définir le niveau du commutateur.

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

L’exemple suivant crée le commutateur. Le code implémente une Level propriété pour définir la valeur du nouveau commutateur. Level appelle la propriété SwitchSetting protégée qui affecte la valeur au nouveau commutateur. Cet exemple implémente également deux propriétés d’évaluateur pour obtenir la valeur affectée du commutateur.

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

L’exemple suivant crée un commutateur dans Main. Il crée un commutateur et lui attribue une valeur. Ensuite, en fonction des paramètres du commutateur, il génère des messages de débogage pour entrer et quitter la méthode.

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

Remarques

Un commutateur fournit un mécanisme efficace pour contrôler le suivi et le débogage de la sortie au moment de l’exécution à l’aide de paramètres externes. La Switch classe implémente le comportement par défaut pour les commutateurs, ce qui vous permet de modifier le niveau du commutateur au moment de l’exécution.

Cette classe est la classe de base pour les BooleanSwitchclasses , SourceSwitchet TraceSwitch . Ces commutateurs répondent à la plupart des besoins de débogage et de suivi. Pour plus d’informations sur les commutateurs de trace, consultez Commutateurs de trace.

Vous devez activer le suivi ou le débogage pour utiliser un commutateur. La syntaxe suivante est propre au compilateur. Si vous utilisez des compilateurs autres que C# ou Visual Basic, reportez-vous à la documentation de votre compilateur.

Pour activer le débogage en C#, ajoutez l’indicateur /d:DEBUG à la ligne de commande du compilateur lorsque vous compilez votre code, ou vous pouvez ajouter #define DEBUG en haut de votre fichier. En Visual Basic, ajoutez l’indicateur /d:DEBUG=True à la ligne de commande du compilateur.
Pour activer le suivi à l’aide de en C#, ajoutez l’indicateur /d:TRACE à la ligne de commande du compilateur lorsque vous compilez votre code, ou ajoutez #define TRACE en haut de votre fichier. En Visual Basic, ajoutez l’indicateur /d:TRACE=True à la ligne de commande du compilateur.

Pour définir le niveau de votre commutateur dans une application .NET Framework, modifiez le fichier de configuration qui correspond au nom de votre application. Dans ce fichier, vous pouvez ajouter un commutateur et définir sa valeur, supprimer un commutateur ou effacer tous les commutateurs précédemment définis par l’application. Le fichier de configuration doit être mis en forme comme dans l’exemple suivant :

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

Cet exemple de section de configuration définit un BooleanSwitch avec la DisplayName propriété définie sur mySwitch et la Enabled valeur définie sur true. Dans votre application, vous pouvez utiliser la valeur de commutateur configurée en créant un BooleanSwitch avec le même nom, comme illustré dans l’exemple de code suivant.

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

Notes pour les responsables de l’implémentation

Si vous avez besoin de niveaux de trace ou de mécanismes pour définir des niveaux de commutateur différents de ceux fournis par BooleanSwitch, SourceSwitch et TraceSwitch, vous pouvez hériter de Switch. Lorsque vous héritez de cette classe, vous devez implémenter la SwitchSetting méthode .

Constructeurs

Switch(String, String)	Initialise une nouvelle instance de la classe Switch.
Switch(String, String, String)	Initialise une nouvelle instance de la classe Switch et spécifie le nom complet, la description et la valeur par défaut pour le commutateur.

Propriétés

Attributes	Obtient les attributs de commutateur personnalisés définis dans le fichier de configuration de l'application.
DefaultValue	Obtient la valeur par défaut affectée dans le constructeur.
Description	Obtient une description du commutateur.
DisplayName	Obtient un nom utilisé pour identifier le commutateur.
SwitchSetting	Obtient ou définit le paramètre en cours pour ce commutateur.
Value	Obtient ou définit la valeur du commutateur.

Méthodes

Equals(Object)	Détermine si l'objet spécifié est égal à l'objet actuel. (Hérité de Object)
GetHashCode()	Fait office de fonction de hachage par défaut. (Hérité de Object)
GetSupportedAttributes()	Obtient les attributs personnalisés pris en charge par le commutateur.
GetType()	Obtient le Type de l'instance actuelle. (Hérité de Object)
MemberwiseClone()	Crée une copie superficielle du Object actuel. (Hérité de Object)
OnSwitchSettingChanged()	Appelé lorsque la propriété SwitchSetting a été modifiée.
OnValueChanged()	Appelé lorsque la propriété Value a été modifiée.
Refresh()	Actualise les données de configuration de suivi.
ToString()	Retourne une chaîne qui représente l'objet actuel. (Hérité de Object)

Événements

Initializing

Se produit lorsqu’un Switch doit être initialisé.

S’applique à

Partager via