Tutorial: Depurar controles personalizados de formularios Windows Forms en tiempo de diseñoWalkthrough: Debugging Custom Windows Forms Controls at Design Time

Cuando se crea un control personalizado, a menudo encontrará lo necesario para depurar su comportamiento en tiempo de diseño.When you create a custom control, you will often find it necessary to debug its design-time behavior. Esto es especialmente cierto si va a crear un diseñador personalizado para el control personalizado.This is especially true if you are authoring a custom designer for your custom control. Para obtener más información, consulte Tutorial: Crear un Windows Forms Control que aprovecha las características de tiempo de diseño de Visual Studio.For details, see Walkthrough: Creating a Windows Forms Control That Takes Advantage of Visual Studio Design-Time Features.

Puede depurar sus controles personalizados mediante Visual Studio, simplemente como lo haría cualquier otras clases de .NET Framework.You can debug your custom controls using Visual Studio, just as you would debug any other .NET Framework classes. La diferencia es que desea depurar una instancia independiente de Visual Studio que se está ejecutando código del control personalizadoThe difference is that you will debug a separate instance of Visual Studio that is running your custom control's code

Las tareas ilustradas en este tutorial incluyen:Tasks illustrated in this walkthrough include:

  • Crear un proyecto de Windows Forms para hospedar el control personalizadoCreating a Windows Forms project to host your custom control

  • Crear un proyecto de biblioteca de controlesCreating a control library project

  • Agregar una propiedad al control personalizadoAdding a property to your custom control

  • Agregar el control personalizado al formulario de hostAdding your custom control to the host form

  • Configurar el proyecto para la depuración de tiempo de diseñoSetting up the project for design-time debugging

  • Depurar el control personalizado en tiempo de diseñoDebugging your custom control at design time

Cuando haya terminado, tendrá una comprensión de las tareas necesarias para depurar el comportamiento en tiempo de diseño de un control personalizado.When you are finished, you will have an understanding of the tasks necessary for debugging the design-time behavior of a custom control.

Crear el proyectoCreate the project

El primer paso es crear el proyecto de aplicación.The first step is to create the application project. Este proyecto se utilizará para compilar la aplicación que hospeda el control personalizado.You will use this project to build the application that hosts the custom control.

En Visual Studio, cree un proyecto de aplicación de Windows denominado "DebuggingExample" (archivo > New > proyecto > Visual C# o Visual Basic > escritorio clásico de > deaplicacióndeformulariosdeWindows).In Visual Studio, create a Windows Application project called "DebuggingExample" (File > New > Project > Visual C# or Visual Basic > Classic Desktop > Windows Forms Application).

Crear el proyecto de biblioteca de controlesCreate the control library project

  1. Agregar un biblioteca de controles de Windows proyecto a la solución.Add a Windows Control Library project to the solution.

  2. Agregue un nuevo UserControl al proyecto DebugControlLibrary.Add a new UserControl item to the DebugControlLibrary project. Para obtener más detalles, vea Cómo: Agregar nuevos elementos de proyecto.For details, see How to: Add New Project Items. Asigne el nuevo archivo de origen en un nombre de base de "DebugControl".Give the new source file a base name of "DebugControl".

  3. Mediante el el Explorador de soluciones, elimine el control predeterminado del proyecto eliminando el archivo de código con el nombre de base "UserControl1".Using the Solution Explorer, delete the project's default control by deleting the code file with a base name of "UserControl1". Para obtener más detalles, vea Cómo: Quitar, eliminar y excluir elementos.For details, see How to: Remove, Delete, and Exclude Items.

  4. Compile la solución.Build the solution.

Punto de controlCheckpoint

En este momento, podrá ver el control personalizado en el cuadro de herramientas.At this point, you will be able to see your custom control in the Toolbox.

Para comprobar el progreso, busque la nueva ficha denominada DebugControlLibrary componentes y haga clic para seleccionarlo.To check your progress, find the new tab called DebugControlLibrary Components and click to select it. Cuando se abre, verá el control aparece como DebugControl con el icono predeterminado junto a él.When it opens, you will see your control listed as DebugControl with the default icon beside it.

Agregar una propiedad al control personalizadoAdd a property to your custom control

Para demostrar que se está ejecutando código del control personalizado en tiempo de diseño, agregará una propiedad y establecer un punto de interrupción en el código que implementa la propiedad.To demonstrate that your custom control's code is running at design-time, you will add a property and set a breakpoint in the code that implements the property.

  1. Abra DebugControl en el Editor de código.Open DebugControl in the Code Editor. Agregue el código siguiente a la definición de clase:Add the following code to the class definition:

    Private demoStringValue As String = Nothing
    <BrowsableAttribute(true)>
    Public Property DemoString() As String
    
        Get
            Return Me.demoStringValue
        End Get
    
        Set(ByVal value As String)
            Me.demoStringValue = value
        End Set
    
    End Property
    
    private string demoStringValue = null;
    [Browsable(true)]
    public string DemoString
    {
        get
        {
            return this.demoStringValue;
        }
        set
        {
            demoStringValue = value;
        }
    }
    
  2. Compile la solución.Build the solution.

Agregar el control personalizado al formulario de hostAdd your custom control to the host form

Para depurar el comportamiento en tiempo de diseño del control personalizado, colocará una instancia de la clase de control personalizado en un formulario de host.To debug the design-time behavior of your custom control, you will place an instance of the custom control class on a host form.

  1. En el proyecto "DebuggingExample", abra Form1 en el Diseñador de Windows Forms.In the "DebuggingExample" project, open Form1 in the Windows Forms Designer.

  2. En el cuadro de herramientas, abra el DebugControlLibrary componentes pestaña y arrastre un DebugControl instancia hasta el formulario.In the Toolbox, open the DebugControlLibrary Components tab and drag a DebugControl instance onto the form.

  3. Buscar el DemoString propiedad personalizada en el propiedades ventana.Find the DemoString custom property in the Properties window. Tenga en cuenta que puede cambiar su valor como lo haría con cualquier otra propiedad.Note that you can change its value as you would any other property. Tenga en cuenta también que, cuando el DemoString propiedad está seleccionada, la cadena de descripción de la propiedad aparece en la parte inferior de la propiedades ventana.Also note that when the DemoString property is selected, the property's description string appears at the bottom of the Properties window.

Configurar el proyecto para la depuración de tiempo de diseñoSet up the project for design-time debugging

Para depurar el comportamiento en tiempo de diseño del control personalizado, que desea depurar una instancia independiente de Visual Studio que se está ejecutando código del control personalizado.To debug your custom control's design-time behavior, you will debug a separate instance of Visual Studio that is running your custom control's code.

  1. Haga doble clic en el DebugControlLibrary del proyecto en el el Explorador de soluciones y seleccione propiedades.Right-click on the DebugControlLibrary project in the Solution Explorer and select Properties.

  2. En el DebugControlLibrary hoja de propiedades, seleccione la depurar ficha.In the DebugControlLibrary property sheet, select the Debug tab.

    En el acción de inicio sección, seleccione iniciar programa externo.In the Start Action section, select Start external program. Puede depurar una instancia independiente de Visual Studio, haga clic en el botón de puntos suspensivos (los puntos suspensivos (...) en la ventana Propiedades de Visual Studio.) botón para buscar el IDE de Visual Studio.You will be debugging a separate instance of Visual Studio, so click the ellipsis (The Ellipsis button (...) in the Properties window of Visual Studio.) button to browse for the Visual Studio IDE. El nombre del archivo ejecutable es devenv.exe, y si ha instalado en la ubicación predeterminada, su ruta de acceso es %programfiles%\Microsoft Visual Studio 9.0\Common7\IDE\devenv.exe.The name of the executable file is devenv.exe, and if you installed to the default location, its path is %programfiles%\Microsoft Visual Studio 9.0\Common7\IDE\devenv.exe.

  3. Haga clic en Aceptar para cerrar el cuadro de diálogo.Click OK to close the dialog box.

  4. Haga clic en el DebugControlLibrary del proyecto y seleccione establecer como proyecto de inicio para habilitar esta configuración de depuración.Right-click the DebugControlLibrary project and select Set as StartUp Project to enable this debugging configuration.

Depurar el control personalizado en tiempo de diseñoDebug your custom control at design time

Ahora está listo para depurar el control personalizado mientras se ejecuta en modo de diseño.Now you are ready to debug your custom control as it runs in design mode. Al iniciar la sesión de depuración, se creará una nueva instancia de Visual Studio y se usará para cargar la solución "DebuggingExample".When you start the debugging session, a new instance of Visual Studio will be created, and you will use it to load the "DebuggingExample" solution. Cuando se abre Form1 en el Diseñador de formularios, una instancia del control personalizado se crea y se volverá a ejecutarse.When you open Form1 in the Forms Designer, an instance of your custom control will be created and will start running.

  1. Abra el DebugControl archivo de código fuente en el Editor de código y coloque un punto de interrupción en el Set descriptor de acceso de la DemoString propiedad.Open the DebugControl source file in the Code Editor and place a breakpoint on the Set accessor of the DemoString property.

  2. Presione F5 para iniciar la sesión de depuración.Press F5 to start the debugging session. Tenga en cuenta que se crea una nueva instancia de Visual Studio.Note that a new instance of Visual Studio is created. Puede distinguir entre las instancias de dos maneras:You can distinguish between the instances in two ways:

    • La instancia de depuración con la palabra ejecutando en su barra de títuloThe debugging instance has the word Running in its title bar

    • La instancia de depuración tiene el iniciar situado en su depurar deshabilitado de la barra de herramientasThe debugging instance has the Start button on its Debug toolbar disabled

    El punto de interrupción se establece en la instancia de depuración.Your breakpoint is set in the debugging instance.

  3. En la nueva instancia de Visual Studio, abra la solución "DebuggingExample".In the new instance of Visual Studio, open the "DebuggingExample" solution. Puede encontrar fácilmente la solución seleccionando proyectos recientes desde el archivo menú.You can easily find the solution by selecting Recent Projects from the File menu. El archivo de solución "DebuggingExample.sln" se mostrará como los archivos usados recientemente.The "DebuggingExample.sln" solution file will be listed as the most recently used file.

  4. Abra Form1 en el Diseñador de formularios y seleccione el DebugControl control.Open Form1 in the Forms Designer and select the DebugControl control.

  5. Cambie el valor de la propiedad DemoString .Change the value of the DemoString property. Tenga en cuenta que cuando se confirma el cambio, la instancia de depuración de Visual Studio adquiere el foco y la ejecución se detiene en el punto de interrupción.Note that when you commit the change, the debugging instance of Visual Studio acquires focus and execution stops at your breakpoint. Puede paso a paso a través del descriptor de acceso de propiedad al igual que su cualquier otro código.You can single-step through the property accessor just as your would any other code.

  6. Cuando haya terminado con la sesión de depuración, puede salir descartando la instancia hospedada de Visual Studio o haciendo clic en el Detener depuración botón en la instancia de depuración.When you are finished with your debugging session, you can exit by dismissing the hosted instance of Visual Studio or by clicking the Stop Debugging button in the debugging instance.

Pasos siguientesNext steps

Ahora que puede depurar controles personalizados en tiempo de diseño, hay muchas posibilidades para expandir la interacción del control con el IDE de Visual Studio.Now that you can debug your custom controls at design time, there are many possibilities for expanding your control's interaction with the Visual Studio IDE.

Vea tambiénSee also