Switch Klasse
Definition
Wichtig
Einige Informationen beziehen sich auf Vorabversionen, die vor dem Release ggf. grundlegend überarbeitet werden. Microsoft übernimmt hinsichtlich der hier bereitgestellten Informationen keine Gewährleistungen, seien sie ausdrücklich oder konkludent.
Stellt eine abstrakte Basisklasse zum Erstellen neuer Schalter für Debuggen und Ablaufverfolgung bereit.
public ref class Switch abstract
public abstract class Switch
type Switch = class
Public MustInherit Class Switch
- Vererbung
-
Switch
- Abgeleitet
Beispiele
Das folgende Beispiel zeigt, wie Sie eine neue Switch Klasse mit vier Ablaufverfolgungsebenen definieren, die zum Nachverfolgen eines Aufrufstapels verwendet werden können. Sie können die Option verwenden, um Ihre Anwendung zu instrumentieren, um jedes Mal zu protokollieren, wenn die Methode eingegeben oder beendet wird.
Im ersten Beispiel wird die Aufzählung erstellt, mit der die Ebene des Schalters festgelegt wird.
// 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
Im folgenden Beispiel wird der neue Switch erstellt. Der Code implementiert eine Level
Eigenschaft, um den Wert des neuen Schalters festzulegen. Level
ruft die geschützte Eigenschaft SwitchSetting auf, die dem neuen Switch den Wert zuweist. In diesem Beispiel werden auch zwei Bewertungseigenschaften implementiert, um den zugewiesenen Wert des Switchs abzurufen.
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
Im folgenden Beispiel wird ein neuer Schalter in Main
. Er erstellt einen neuen Switch und weist ihm einen Wert zu. Abhängig von den Schaltereinstellungen gibt es dann Debuggingnachrichten aus, um die Methode einzugeben und die Methode zu verlassen.
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
Hinweise
Ein Schalter bietet einen effizienten Mechanismus zum Steuern der Ablaufverfolgung und debugging-Ausgabe zur Laufzeit mithilfe externer Einstellungen. Die Switch Klasse implementiert das Standardverhalten für Schalter, sodass Sie die Switchebene zur Laufzeit ändern können.
Diese Klasse ist die Basisklasse für die BooleanSwitchSourceSwitchKlassen , und TraceSwitch Klassen. Diese Schalter erfüllen die meisten Debugging- und Ablaufverfolgungsanforderungen. Weitere Informationen zu Ablaufverfolgungsschaltern finden Sie unter Trace Switches.
Sie müssen die Ablaufverfolgung oder das Debuggen aktivieren, um einen Switch zu verwenden. Die folgende Syntax ist compilerspezifisch. Wenn Sie andere Compiler als C# oder Visual Basic verwenden, lesen Sie die Dokumentation für Ihren Compiler.
Um das Debuggen in C# zu aktivieren, fügen Sie beim Kompilieren des Codes das
/d:DEBUG
Flag zur Compiler-Befehlszeile hinzu, oder Sie können oben in der Datei hinzufügen#define DEBUG
. Fügen Sie in Visual Basic der Compilerbefehlszeile das/d:DEBUG=True
Kennzeichen hinzu.Um die Ablaufverfolgung mithilfe von C# zu aktivieren, fügen Sie beim Kompilieren des Codes das
/d:TRACE
Flag zur Befehlszeile des Compilers hinzu, oder fügen Sie oben in der Datei hinzu#define TRACE
. Fügen Sie in Visual Basic der Compilerbefehlszeile das/d:TRACE=True
Kennzeichen hinzu.
Um die Ebene Ihres Schalters in einer .NET Framework-App festzulegen, bearbeiten Sie die Konfigurationsdatei, die dem Namen Ihrer Anwendung entspricht. In dieser Datei können Sie einen Schalter hinzufügen und seinen Wert festlegen, einen Schalter entfernen oder alle zuvor von der Anwendung festgelegten Schalter löschen. Die Konfigurationsdatei sollte wie im folgenden Beispiel formatiert werden:
<configuration>
<system.diagnostics>
<switches>
<add name="mySwitch" value="true" />
</switches>
</system.diagnostics>
</configuration>
In diesem Beispielkonfigurationsabschnitt wird ein BooleanSwitch Wert definiert, auf den die DisplayName Eigenschaft festgelegt mySwitch
ist und auf den Enabled Wert festgelegt true
ist. In Ihrer Anwendung können Sie den konfigurierten Switchwert verwenden, indem Sie einen BooleanSwitch mit demselben Namen erstellen, wie im folgenden Codebeispiel gezeigt.
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)
{
//...
}
}
Hinweise für Ausführende
Wenn Sie Ablaufverfolgungsstufen oder Mechanismen zum Festlegen von Schalterebenen benötigen, die von denen bereitgestellt BooleanSwitchwerden, SourceSwitch und TraceSwitchSie können von erben Switch. Wenn Sie von dieser Klasse erben, müssen Sie die SwitchSetting Methode implementieren.
Konstruktoren
Switch(String, String) |
Initialisiert eine neue Instanz der Switch-Klasse. |
Switch(String, String, String) |
Initialisiert eine neue Instanz der Switch-Klasse und gibt den Anzeigenamen, die Beschreibung und den Standardwert für den Schalter an. |
Eigenschaften
Attributes |
Ruft die benutzerdefinierten Schalterattribute ab, die in der Anwendungskonfigurationsdatei definiert sind. |
Description |
Ruft eine Beschreibung des Schalters ab. |
DisplayName |
Ruft einen Namen zum Bezeichnen des Schalters ab. |
SwitchSetting |
Ruft die aktuelle Einstellung des Schalters ab oder legt diese fest. |
Value |
Ruft den Wert des Schalters ab oder legt diesen fest. |
Methoden
Equals(Object) |
Bestimmt, ob das angegebene Objekt gleich dem aktuellen Objekt ist. (Geerbt von Object) |
GetHashCode() |
Fungiert als Standardhashfunktion. (Geerbt von Object) |
GetSupportedAttributes() |
Ruft die benutzerdefinierten Attribute ab, die vom Schalter unterstützt werden. |
GetType() |
Ruft den Type der aktuellen Instanz ab. (Geerbt von Object) |
MemberwiseClone() |
Erstellt eine flache Kopie des aktuellen Object. (Geerbt von Object) |
OnSwitchSettingChanged() |
Wird aufgerufen, wenn die SwitchSetting-Eigenschaft geändert wird. |
OnValueChanged() |
Wird aufgerufen, wenn die Value-Eigenschaft geändert wird. |
ToString() |
Gibt eine Zeichenfolge zurück, die das aktuelle Objekt darstellt. (Geerbt von Object) |