Freigeben über

Switch-Klasse

  • Artikel

Stellt eine abstract-Basisklasse bereit, um neue Schalter für Debuggen und Ablaufverfolgung zu erstellen.

Namespace: System.Diagnostics
Assembly: System (in system.dll)

Syntax

'Declaration
Public MustInherit Class Switch
'Usage
Dim instance As Switch

public abstract class Switch

public ref class Switch abstract

public abstract class Switch

public abstract class Switch

Hinweise

Schalter stellen einen effizienten Mechanismus dar, mit dem anhand externer Einstellungen Ablaufverfolgungs- und Debugausgaben zur Laufzeit gesteuert werden können. Die Switch-Klasse implementiert das Standardverhalten für Schalter und ermöglicht Ihnen somit das Ändern der Schalterebene zur Laufzeit.

Diese Klasse ist die Basisklasse für die BooleanSwitch-Klasse, die SourceSwitch-Klasse und die TraceSwitch-Klasse. Die hiermit verfügbaren Schalter sind für die meisten Aufgaben beim Debuggen und der Ablaufverfolgung ausreichend. Wenn Sie eigene Schalter erstellen, müssen diese static sein.

Sie müssen die Ablaufverfolgung oder das Debuggen aktivieren, um einen Schalter zu verwenden. Die folgende Syntax ist compilerspezifisch. Wenn Sie einen anderen Compiler als C# oder Visual Basic verwenden, finden Sie entsprechende Informationen in der Dokumentation zum Compiler.

  • Wenn Sie das Debuggen in C# aktivieren möchten, fügen Sie in der Compilerbefehlszeile beim Kompilieren des Codes das /d:DEBUG-Flag hinzu, oder fügen Sie #define DEBUG am Anfang der Datei ein. Fügen Sie in Visual Basic in der Compilerbefehlszeile das /d:DEBUG=True-Flag hinzu.

  • Wenn Sie die Ablaufverfolgung in C# aktivieren möchten, fügen Sie in der Compilerbefehlszeile beim Kompilieren des Codes das /d:TRACE-Flag hinzu, oder fügen Sie #define TRACE am Anfang der Datei ein. Fügen Sie in Visual Basic in der Compilerbefehlszeile das /d:TRACE=True-Flag hinzu.

Bearbeiten Sie zum Festlegen der Ebene des Schalters die Konfigurationsdatei, die dem Namen der Anwendung entspricht. In dieser Datei können Sie einen Schalter hinzufügen und dessen Wert festlegen, einen Schalter entfernen oder alle Schalter löschen, die zuvor durch die Anwendung festgelegt wurden. Die Konfigurationsdatei sollte wie im folgenden Beispiel formatiert werden:

<configuration>
  <system.diagnostics>
    <switches>
      <add name="mySwitch" value="10" />
      <add name="myNewSwitch" value="20" />
      <remove name="mySwitch" />
      <clear/>
    </switches>
  </system.diagnostics>
</configuration>

Hinweis

Sie können Switch-Member in der Klasse als static festlegen, um die Leistung zu erhöhen.

Hinweise für Erben Wenn Sie zusätzliche Ablaufverfolgungsebenen oder Mechanismen zum Festlegen von Schalterebenen benötigen, die nicht über BooleanSwitch, SourceSwitch und TraceSwitch bereitgestellt werden, können Sie Switch vererben. Beim Vererben dieser Klasse müssen Sie die SwitchSetting-Methode implementieren.

Beispiel

Im folgenden Beispiel wird gezeigt, wie eine neue Switch-Klasse mit vier Ebenen für die Ablaufverfolgung definiert wird, über die eine Ablaufverfolgung für eine Aufrufliste bereitgestellt werden kann. Mit dem Schalter können Sie die Anwendung instrumentieren und so jeden Aufruf und jedes Verlassen der Methode protokollieren.

Im ersten Beispiel wird die Enumeration zum Festlegen der Schalterebene erstellt.

' The following are possible values for the new switch.
Public Enum MethodTracingSwitchLevel
    Off = 0
    EnteringMethod = 1
    ExitingMethod = 2
    Both = 3
End Enum 'MethodTracingSwitchLevel

// 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 class MethodTracingSwitchLevel
{
   Off = 0,
   EnteringMethod = 1,
   ExitingMethod = 2,
   Both = 3
};


// The following are possible values for the new switch.
public class MethodTracingSwitchLevel
{
    private int member;

    MethodTracingSwitchLevel()
    {
        member = 0;
    }//MethodTracingSwitchLevel

    MethodTracingSwitchLevel(int n)
    {
        member = n;
    }//MethodTracingSwitchLevel

    public int get_Member()
    {
        return member;
    }//get_Member

    public static int off = 0;
    public static int enteringMethod = 1;
    public static int exitingMethod = 2;
    public static int both = 3;
} //MethodTracingSwitchLevel

Im folgenden Beispiel wird der neue Schalter erstellt. Der Code implementiert eine Level-Eigenschaft, um den Wert des neuen Schalters festzulegen. Level ruft die geschützte SwitchSetting-Eigenschaft auf, die dem neuen Schalter den Wert zuweist. In diesem Beispiel werden außerdem zwei Accessoreigenschaften implementiert, um den zugeordneten Wert des Schalters abzurufen.

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 'New
    
    
    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 'SetSwitchSetting
    
    
    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 'MyMethodTracingSwitch

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 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 extends Switch
{
    protected boolean outExit;
    protected boolean outEnter;
    protected MethodTracingSwitchLevel level;

    public MyMethodTracingSwitch(String displayName, String description)
    {
      super(displayName, description);
    } //MyMethodTracingSwitch

    /** @property
     */
    public MethodTracingSwitchLevel get_Level()
    {
        return level;
    }//get_Level

    /** @property 
     */
    public void set_Level(MethodTracingSwitchLevel value)
    {
        SetSwitchSetting(value.get_Member());
    }//set_Level

    protected void SetSwitchSetting(int value)
    {
        if (value < 0) {
            value = 0;
        }
        if (value > 3) {
            value = 3;
        }

        level = new 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;
        }
    } //SetSwitchSetting

    /** @property 
     */
    public boolean get_OutputExit()
    {
        return outExit;
    }//get_OutputExit

    /** @property 
     */
    public boolean get_OutputEnter()
    {
        return outEnter;
    }//get_OutputEnter
} //MyMethodTracingSwitch

Im folgenden Beispiel wird ein neuer Schalter in Main erstellt. Es wird ein neuer Schalter erstellt und diesem ein Wert zugewiesen. Anschließend werden abhängig von den Schaltereinstellungen Debugmeldungen für das Aufrufen oder Verlassen der Methode ausgegeben.

Public Class Class1
    ' Create an instance of MyMethodTracingSwitch. 
    Private Shared mySwitch As New _
        MyMethodTracingSwitch("Methods", "Trace entering and exiting method")
    
    Public Shared Sub Main()
        ' Write a diagnostic message if the switch is set to entering.
        Debug.WriteLineIf(mySwitch.OutputEnter, "Entering Main")
        
        ' Insert code to handle processing.
        ' Write another diagnostic message if the switch is set to exiting.
        Debug.WriteLineIf(mySwitch.OutputExit, "Exiting Main")
    End Sub
End Class 'MyClass

public class MyClass {
    /* Create an instance of MyMethodTracingSwitch.*/
    static MyMethodTracingSwitch mySwitch = 
       new MyMethodTracingSwitch("Methods", "Trace entering and exiting method");
 
    public static int Main(string[] args) {
       // Write a diagnostic message if the switch is set to entering.
       Debug.WriteLineIf(mySwitch.OutputEnter, "Entering Main");
 
       // Insert code to handle processing.
 
       // Write another diagnostic message if the switch is set to exiting.
       Debug.WriteLineIf(mySwitch.OutputExit, "Exiting Main");
       return 0;
    }
 }

public ref class MyClass
{
private:

   /* Create an instance of MyMethodTracingSwitch.*/
   static MyMethodTracingSwitch^ mySwitch = gcnew MyMethodTracingSwitch( "Methods","Trace entering and exiting method" );

public:
   static int main()
   {
      
      // Write a diagnostic message if the switch is set to entering.
      Debug::WriteLineIf( mySwitch->OutputEnter, "Entering Main" );
      
      // Insert code to handle processing.
      // Write another diagnostic message if the switch is set to exiting.
      Debug::WriteLineIf( mySwitch->OutputExit, "Exiting Main" );
      return 0;
   }

};


public class MyClass
{
    /* Create an instance of MyMethodTracingSwitch.
    */
    private static MyMethodTracingSwitch mySwitch = new MyMethodTracingSwitch(
        "Methods", "Trace entering and exiting method");

    public static void main(String[] args)
    {
        // Write a diagnostic message if the switch is set to entering.
        Debug.WriteLineIf(mySwitch.get_OutputEnter(), "Entering main");
        // Insert code to handle processing.
        // Write another diagnostic message if the switch is set to exiting.
        Debug.WriteLineIf(mySwitch.get_OutputExit(), "Exiting main");
        return;
    } //main
} //MyClass

Vererbungshierarchie

System.Object
  System.Diagnostics.Switch
     System.Diagnostics.BooleanSwitch
     System.Diagnostics.SourceSwitch
     System.Diagnostics.TraceSwitch

Threadsicherheit

Alle öffentlichen statischen (Shared in Visual Basic) Member dieses Typs sind threadsicher. Bei Instanzmembern ist die Threadsicherheit nicht gewährleistet.

Plattformen

Windows 98, Windows 2000 SP4, Windows Millennium Edition, Windows Server 2003, Windows XP Media Center Edition, Windows XP Professional x64 Edition, Windows XP SP2, Windows XP Starter Edition

.NET Framework unterstützt nicht alle Versionen sämtlicher Plattformen. Eine Liste der unterstützten Versionen finden Sie unter Systemanforderungen.

Versionsinformationen

.NET Framework

Unterstützt in: 2.0, 1.1, 1.0

Siehe auch

Referenz

Switch-Member
System.Diagnostics-Namespace
BooleanSwitch-Klasse
TraceSwitch
Debug-Klasse
Trace