Switch (Clase)
TOC
Collapse the table of content
Expand the table of content

Switch (Clase)

Actualización: noviembre 2007

Proporciona una clase base abstracta para crear nuevos modificadores de depuración y traza.

Espacio de nombres:  System.Diagnostics
Ensamblado:  System (en System.dll)

public ref class Switch abstract
public abstract class Switch
public abstract class Switch

Los modificadores proporcionan un mecanismo eficaz para controlar los resultados del seguimiento y la depuración en tiempo de ejecución mediante una configuración externa. La clase Switch implementa el comportamiento predeterminado de los modificadores, permitiendo cambiar el nivel del modificador en tiempo de ejecución.

Ésta es la clase base de las clases BooleanSwitch, SourceSwitch y TraceSwitch. Estos modificadores satisfacen la mayoría de las necesidades de depuración y seguimiento. Para obtener más información sobre los modificadores de seguimiento, vea Modificadores de seguimiento.

Para utilizar modificadores, se debe habilitar el seguimiento o la depuración. La sintaxis siguiente es específica del compilador. Si se utilizan compiladores que no sean C# o Visual Basic, consulte la documentación del compilador.

  • Para habilitar la depuración en C#, agregue el indicador /d:DEBUG a la línea de comandos del compilador, al compilar el código, o agregue #define DEBUG al principio del archivo. En Visual Basic, agregue el indicador /d:DEBUG=True a la línea de comandos del compilador.

  • Para habilitar el seguimiento en C#, agregue el indicador /d:TRACE a la línea de comandos del compilador, al compilar el código, o agregue #define TRACE al principio del archivo. En Visual Basic, agregue el indicador /d:TRACE=True a la línea de comandos del compilador.

Para establecer el nivel del modificador, modifique el archivo de configuración correspondiente al nombre de la aplicación. En el archivo, se puede agregar un modificador y se puede establecer su valor, quitar un modificador o borrar todos los modificadores previamente establecidos por la aplicación. El archivo de configuración debería tener el formato que se muestra en el siguiente ejemplo:

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

En esta sección de configuración de ejemplo se define un objeto BooleanSwitch con la propiedad DisplayName establecida en mySwitch y el valor de Enabled establecido en true. Dentro de la aplicación, puede utilizar el valor del modificador configurado creando un objeto BooleanSwitch con el mismo nombre, tal como se muestra en el ejemplo de código siguiente:

No hay ningún ejemplo de código disponible o este idioma no es compatible.

Notas para los herederos:

Si se necesitan niveles de seguimiento o algún mecanismo para configurar niveles de modificador diferentes de los proporcionados por BooleanSwitch, SourceSwitch y TraceSwitch, es posible heredarlos de Switch. Al heredar de esta clase, es necesario implementar el método SwitchSetting.

En el ejemplo siguiente se muestra cómo definir una nueva clase Switch con cuatro niveles de seguimiento, que se pueden utilizar para hacer un seguimiento de una pila de llamadas. Es posible utilizar el modificador para instrumentar la aplicación en el registro cada vez que se entra o se sale del método.

En el primer ejemplo se crea la enumeración utilizada para establecer el nivel del modificador.

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


En el ejemplo siguiente se crea el nuevo modificador. El código implementa una propiedad Level para establecer el valor del nuevo modificador. Level llama a la propiedad protegida SwitchSetting que asigna el valor al nuevo modificador. En este ejemplo se implementan también dos propiedades de evaluación para obtener el valor asignado del modificador.

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


En el ejemplo siguiente se crea un nuevo modificador en Main. Se crea un nuevo modificador y se le asigna un valor. A continuación, y en función de la configuración del modificador, genera mensajes de depuración para entrar y salir del método.

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


Todos los miembros static (Shared en Visual Basic) públicos de este tipo son seguros para la ejecución de subprocesos. No se garantiza que los miembros de instancias sean seguros para la ejecución de subprocesos.

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

.NET Framework y .NET Compact Framework no admiten todas las versiones de cada plataforma. Para obtener una lista de las versiones compatibles, vea Requisitos de sistema de .NET Framework.

.NET Framework

Compatible con: 3.5, 3.0, 2.0, 1.1, 1.0

Adiciones de comunidad

AGREGAR
Mostrar:
© 2016 Microsoft