Procedura dettagliata: debug di controlli personalizzati WPF in fase di progettazione

In questa procedura dettagliata viene illustrato come eseguire il debug di uno strumento decorativo visuale Design-Time per un controllo WPF (Windows Presentation Foundation) personalizzato. Lo strumento decorativo visuale è una casella di controllo che fornisce una semplice funzionalità di dimensionamento automatico.

Questa procedura dettagliata prevede l'esecuzione delle attività seguenti:

  • Creare un progetto di libreria di controlli personalizzati WPF.

  • Creare un assembly distinto per i metadati Design-Time.

  • Implementare il provider di strumenti decorativi visuali.

  • Verificare il controllo in fase di progettazione.

  • Impostare il progetto per il debug in fase di progettazione.

  • Eseguire il debug del controllo in fase di progettazione.

Al termine, si sarà in grado di eseguire il debug di uno strumento decorativo visuale per un controllo personalizzato.

Nota

È possibile che le finestre di dialogo e i comandi di menu visualizzati siano diversi da quelli descritti nella Guida a seconda delle impostazioni attive o dell'edizione del programma. Per modificare le impostazioni, scegliere Importa/Esporta impostazioni dal menu Strumenti. Per ulteriori informazioni, vedere Gestione delle impostazioni.

Prerequisiti

Per completare la procedura dettagliata, è necessario disporre dei componenti seguenti:

  • Visual Studio 2010.

Creazione del controllo personalizzato

Il primo passaggio consiste nella creazione del progetto per il controllo personalizzato. Il controllo è un pulsante con una piccola quantità di codice Design-Time che utilizza il metodo GetIsInDesignMode per implementare un comportamento in fase di progettazione.

Per creare il controllo personalizzato

  1. In Visual Basic o Visual C# creare un nuovo progetto di libreria di controlli WPF personalizzati denominato AutoSizeButtonLibrary.

    Il codice per CustomControl1 verrà aperto nell'editor del codice.

  2. In Esplora soluzioni modificare il nome del file di codice in AutoSizeButton.cs o AutoSizeButton.vb. Se viene visualizzata una finestra di messaggio in cui si richiede se eseguire un'operazione di ridenominazione per tutti i riferimenti del progetto, fare clic su .

  3. Aprire AutoSizeButton.cs o AutoSizeButton.vb nell'editor del codice.

  4. Sostituire il codice generato automaticamente con il codice seguente. Questo codice eredita da Button e visualizza il testo "Design mode active" quando il pulsante viene visualizzato nella finestra di progettazione.

    Imports System
    Imports System.Collections.Generic
    Imports System.Text
    Imports System.Windows.Controls
    Imports System.Windows.Media
    Imports System.ComponentModel
    
    ' The AutoSizeButton control implements a button
    ' with a custom design-time experience. 
    Public Class AutoSizeButton
        Inherits Button
    
        Public Sub New()
            ' The following code enables custom design-mode logic.
            ' The GetIsInDesignMode check and the following design-time 
            ' code are optional and shown only for demonstration.
            If DesignerProperties.GetIsInDesignMode(Me) Then
                Content = "Design mode active"
            End If
    
        End Sub
    End Class
    
    using System;
    using System.Collections.Generic;
    using System.Text;
    using System.Windows.Controls;
    using System.Windows.Media;
    using System.ComponentModel;
    
    namespace AutoSizeButtonLibrary
    {
        // The AutoSizeButton control implements a button
        // with a custom design-time experience. 
        public class AutoSizeButton : Button
        {
            public AutoSizeButton()
            {
                // The following code enables custom design-mode logic.
                // The GetIsInDesignMode check and the following design-time 
                // code are optional and shown only for demonstration.
                if (DesignerProperties.GetIsInDesignMode(this))
                {
                    Content = "Design mode active";
                }
            }
        }
    }
    
  5. Impostare il percorso di output del progetto su "bin\".

  6. Compilare la soluzione.

Creazione dell'assembly di metadati Design-Time

Il codice Design-Time viene distribuito in speciali assembly di metadati. Per questa procedura dettagliata, lo strumento decorativo visuale personalizzato viene distribuito in un assembly denominato AutoSizeButtonLibrary.VisualStudio.Design. Per ulteriori informazioni, vedere Aggiunta di metadati della fase di progettazione.

Per creare l'assembly di metadati Design-Time

  1. In Visual Basic o Visual C# aggiungere un nuovo progetto di libreria di classi denominato AutoSizeButtonLibrary.VisualStudio.Design alla soluzione.

  2. Impostare il percorso di output del progetto su ".. \AutoSizeButtonLibrary\bin\". In questo modo l'assembly del controllo e l'assembly dei metadati verranno mantenuti nella stessa cartella, consentendo l'individuazione di metadati per le finestre di progettazione.

  3. Aggiungere riferimenti agli assembly WPF riportati di seguito.

    • PresentationCore

    • PresentationFramework

    • System.Xaml

    • WindowsBase

  4. Aggiungere riferimenti agli assembly WPF Designer riportati di seguito.

    • Microsoft.Windows.Design.Extensibility

    • Microsoft.Windows.Design.Interaction

  5. Aggiungere un riferimento al progetto AutoSizeButtonLibrary.

  6. In Esplora soluzioni modificare il nome del file di codice Class1 in Metadata.cs o Metadata.vb. Se viene visualizzata una finestra di messaggio in cui si richiede se eseguire un'operazione di ridenominazione per tutti i riferimenti del progetto, fare clic su .

  7. Sostituire il codice generato automaticamente con il codice seguente. Con questo codice viene creato un oggetto AttributeTable che connette l'implementazione in fase di progettazione personalizzata alla classe AutoSizeButton.

    Imports System
    Imports System.Collections.Generic
    Imports System.Text
    Imports System.ComponentModel
    Imports System.Windows.Media
    Imports System.Windows.Controls
    Imports System.Windows
    
    Imports AutoSizeButtonLibrary
    Imports Microsoft.Windows.Design.Features
    Imports Microsoft.Windows.Design.Metadata
    Imports AutoSizeButtonLibrary.VisualStudio.Design
    
    ' The ProvideMetadata assembly-level attribute indicates to designers
    ' that this assembly contains a class that provides an attribute table. 
    <Assembly: ProvideMetadata(GetType(AutoSizeButtonLibrary.VisualStudio.Design.Metadata))> 
    
    ' Container for any general design-time metadata to initialize.
    ' Designers look for a type in the design-time assembly that 
    ' implements IProvideAttributeTable. If found, designers instantiate
    ' this class and access its AttributeTable property automatically.
    Friend Class Metadata
        Implements IProvideAttributeTable
    
        ' Accessed by the designer to register any design-time metadata.
        Public ReadOnly Property AttributeTable() As AttributeTable _
            Implements IProvideAttributeTable.AttributeTable
            Get
                Dim builder As New AttributeTableBuilder()
    
                builder.AddCustomAttributes( _
                    GetType(AutoSizeButton), _
                    New FeatureAttribute(GetType(AutoSizeAdornerProvider)))
    
                Return builder.CreateTable()
            End Get
        End Property
    End Class
    
    using System;
    using System.Collections.Generic;
    using System.Text;
    using System.ComponentModel;
    using System.Windows.Media;
    using System.Windows.Controls;
    using System.Windows;
    
    using AutoSizeButtonLibrary;
    using Microsoft.Windows.Design.Features;
    using Microsoft.Windows.Design.Metadata;
    using AutoSizeButtonLibrary.VisualStudio.Design;
    
    // The ProvideMetadata assembly-level attribute indicates to designers
    // that this assembly contains a class that provides an attribute table. 
    [assembly: ProvideMetadata(typeof(AutoSizeButtonLibrary.VisualStudio.Design.Metadata))]
    namespace AutoSizeButtonLibrary.VisualStudio.Design
    {
        // Container for any general design-time metadata to initialize.
        // Designers look for a type in the design-time assembly that 
        // implements IProvideAttributeTable. If found, designers instantiate 
        // this class and access its AttributeTable property automatically.
        internal class Metadata : IProvideAttributeTable
        {
            // Accessed by the designer to register any design-time metadata.
            public AttributeTable AttributeTable
            {
                get 
                {
                    AttributeTableBuilder builder = new AttributeTableBuilder();
    
                    builder.AddCustomAttributes(
                        typeof(AutoSizeButton),
                        new FeatureAttribute(typeof(AutoSizeAdornerProvider)));
    
                    return builder.CreateTable();
                }
            }
        }
    }
    
  8. Salvare la soluzione.

Implementazione del provider di strumenti decorativi visuali

Il provider di strumenti decorativi visuali viene implementato in un tipo denominato AutoSizeAdornerProvider. Lo strumento decorativo visuale FeatureProvider consente di impostare le proprietà Height e Width del controllo in fase di progettazione.

Per implementare il provider di strumenti decorativi visuali

  1. Aggiungere una nuova classe denominata AutoSizeAdornerProvider al progetto AutoSizeButtonLibrary.VisualStudio.Design.

  2. Nell'editor del codice per AutoSizeAdornerProvider sostituire il codice generato automaticamente con il codice seguente. Questo codice implementa un PrimarySelectionAdornerProvider che fornisce uno strumento decorativo visuale basato su un controllo CheckBox.

    Imports System
    Imports System.Collections.Generic
    Imports System.Text
    Imports System.Windows.Input
    Imports System.Windows
    Imports System.Windows.Automation
    Imports System.Windows.Controls
    Imports System.Windows.Media
    Imports System.Windows.Shapes
    Imports Microsoft.Windows.Design.Interaction
    Imports Microsoft.Windows.Design.Model
    
    ' The following class implements an adorner provider for the 
    ' AutoSizeButton control. The adorner is a CheckBox control, which 
    ' changes the Height and Width of the AutoSizeButton to "Auto",
    ' which is represented by Double.NaN.
    Public Class AutoSizeAdornerProvider
        Inherits PrimarySelectionAdornerProvider
    
        Private settingProperties As Boolean
        Private adornedControlModel As ModelItem
        Private autoSizeCheckBox As CheckBox
        Private autoSizeAdornerPanel As AdornerPanel
    
        ' The constructor sets up the adorner control. 
        Public Sub New()
            autoSizeCheckBox = New CheckBox()
            autoSizeCheckBox.Content = "AutoSize"
            autoSizeCheckBox.IsChecked = True
            autoSizeCheckBox.FontFamily = AdornerFonts.FontFamily
            autoSizeCheckBox.FontSize = AdornerFonts.FontSize
            autoSizeCheckBox.Background = CType( _
                AdornerResources.FindResource(AdornerColors.RailFillBrushKey),  _
                Brush)
        End Sub
    
        ' The following method is called when the adorner is activated.
        ' It creates the adorner control, sets up the adorner panel,
        ' and attaches a ModelItem to the AutoSizeButton.
        Protected Overrides Sub Activate(ByVal item As ModelItem)
    
            ' Save the ModelItem and hook into when it changes.
            ' This enables updating the slider position when 
            ' a new background value is set.
            adornedControlModel = item
            AddHandler adornedControlModel.PropertyChanged, AddressOf AdornedControlModel_PropertyChanged
    
            ' All adorners are placed in an AdornerPanel
            ' for sizing and layout support.
            Dim panel As AdornerPanel = Me.Panel
    
            ' Set up the adorner's placement.
            AdornerPanel.SetAdornerHorizontalAlignment(autoSizeCheckBox, AdornerHorizontalAlignment.OutsideLeft)
            AdornerPanel.SetAdornerVerticalAlignment(autoSizeCheckBox, AdornerVerticalAlignment.OutsideTop)
    
            ' Listen for changes to the checked state.
            AddHandler autoSizeCheckBox.Checked, AddressOf autoSizeCheckBox_Checked
            AddHandler autoSizeCheckBox.Unchecked, AddressOf autoSizeCheckBox_Unchecked
    
            ' Run the base implementation.
            MyBase.Activate(item)
    
        End Sub
    
        ' The Panel utility property demand-creates the 
        ' adorner panel and adds it to the provider's 
        ' Adorners collection.
        Public ReadOnly Property Panel() As AdornerPanel
            Get
                If Me.autoSizeAdornerPanel Is Nothing Then
                    Me.autoSizeAdornerPanel = New AdornerPanel()
    
                    ' Add the adorner to the adorner panel.
                    Me.autoSizeAdornerPanel.Children.Add(autoSizeCheckBox)
    
                    ' Add the panel to the Adorners collection.
                    Adorners.Add(autoSizeAdornerPanel)
    
                End If
    
                Return Me.autoSizeAdornerPanel
            End Get
        End Property
    
        ' The following code handles the Checked event.
        ' It autosizes the adorned control's Height and Width.
        Sub autoSizeCheckBox_Checked(ByVal sender As Object, ByVal e As RoutedEventArgs) 
            Me.SetHeightAndWidth(True)
        End Sub
    
    
        ' The following code handles the Unchecked event.
        ' It sets the adorned control's Height and Width to a hard-coded value.
        Sub autoSizeCheckBox_Unchecked(ByVal sender As Object, ByVal e As RoutedEventArgs) 
            Me.SetHeightAndWidth(False)
        End Sub
    
        ' The SetHeightAndWidth utility method sets the Height and Width
        ' properties through the model and commits the change.
        Private Sub SetHeightAndWidth(ByVal [auto] As Boolean) 
    
            settingProperties = True
    
            Dim batchedChange As ModelEditingScope = adornedControlModel.BeginEdit()
            Try
                Dim widthProperty As ModelProperty = adornedControlModel.Properties("Width")
    
                Dim heightProperty As ModelProperty = adornedControlModel.Properties("Height")
    
                If [auto] Then
                    widthProperty.ClearValue()
                    heightProperty.ClearValue()
                Else
                    widthProperty.SetValue(20.0)
                    heightProperty.SetValue(20.0)
                End If
    
                batchedChange.Complete()
            Finally
                batchedChange.Dispose()
                settingProperties = False
            End Try
    
        End Sub
    
        ' The following method deactivates the adorner.
        Protected Overrides Sub Deactivate()
    
            RemoveHandler adornedControlModel.PropertyChanged, _
                AddressOf AdornedControlModel_PropertyChanged
    
            MyBase.Deactivate()
    
        End Sub
    
    
        ' The following method handles the PropertyChanged event.
        Sub AdornedControlModel_PropertyChanged( _
            ByVal sender As Object, _
            ByVal e As System.ComponentModel.PropertyChangedEventArgs)
    
            If settingProperties Then Return
    
            If e.PropertyName = "Height" Or e.PropertyName = "Width" Then
                Dim h As Double = CType(adornedControlModel.Properties("Height").ComputedValue, Double)
                Dim w As Double = CType(adornedControlModel.Properties("Width").ComputedValue, Double)
    
                If Double.IsNaN(h) And Double.IsNaN(w) Then
                    autoSizeCheckBox.IsChecked = True
                Else
                    autoSizeCheckBox.IsChecked = False
                End If
            End If
    
        End Sub
    End Class
    
    using System;
    using System.Collections.Generic;
    using System.Text;
    using System.Windows.Input;
    using System.Windows;
    using System.Windows.Automation;
    using System.Windows.Controls;
    using System.Windows.Media;
    using System.Windows.Shapes;
    using Microsoft.Windows.Design.Interaction;
    using Microsoft.Windows.Design.Model;
    
    namespace AutoSizeButtonLibrary.VisualStudio.Design
    {
        // The following class implements an adorner provider for the 
        // AutoSizeButton control. The adorner is a CheckBox control, which 
        // changes the Height and Width of the AutoSizeButton to "Auto",
        // which is represented by double.NaN.
        public class AutoSizeAdornerProvider : PrimarySelectionAdornerProvider
        {
            bool settingProperties;
            private ModelItem adornedControlModel;
            CheckBox autoSizeCheckBox;
            AdornerPanel autoSizeAdornerPanel;
    
            // The constructor sets up the adorner control. 
            public AutoSizeAdornerProvider()
            {
                autoSizeCheckBox = new CheckBox();
                autoSizeCheckBox.Content = "AutoSize";
                autoSizeCheckBox.IsChecked = true;
                autoSizeCheckBox.FontFamily = AdornerFonts.FontFamily;
                autoSizeCheckBox.FontSize = AdornerFonts.FontSize;
                autoSizeCheckBox.Background = AdornerResources.FindResource(
                    AdornerColors.RailFillBrushKey) as Brush;
            }
    
            // The following method is called when the adorner is activated.
            // It creates the adorner control, sets up the adorner panel,
            // and attaches a ModelItem to the AutoSizeButton.
            protected override void Activate(ModelItem item)
            {
                // Save the ModelItem and hook into when it changes.
                // This enables updating the slider position when 
                // a new background value is set.
                adornedControlModel = item;
                adornedControlModel.PropertyChanged += 
                    new System.ComponentModel.PropertyChangedEventHandler(
                        AdornedControlModel_PropertyChanged);
    
                // All adorners are placed in an AdornerPanel
                // for sizing and layout support.
                AdornerPanel panel = this.Panel;
    
                // Set up the adorner's placement.
                AdornerPanel.SetAdornerHorizontalAlignment(autoSizeCheckBox, AdornerHorizontalAlignment.OutsideLeft);
                AdornerPanel.SetAdornerVerticalAlignment(autoSizeCheckBox, AdornerVerticalAlignment.OutsideTop);
    
                // Listen for changes to the checked state.
                autoSizeCheckBox.Checked += new RoutedEventHandler(autoSizeCheckBox_Checked);
                autoSizeCheckBox.Unchecked += new RoutedEventHandler(autoSizeCheckBox_Unchecked);
    
                // Run the base implementation.
                base.Activate(item);
            }
    
            // The Panel utility property demand-creates the 
            // adorner panel and adds it to the provider's 
            // Adorners collection.
            private AdornerPanel Panel
            {
                get
                {
                    if (this.autoSizeAdornerPanel == null)
                    {
                        autoSizeAdornerPanel = new AdornerPanel();
    
                        // Add the adorner to the adorner panel.
                        autoSizeAdornerPanel.Children.Add(autoSizeCheckBox);
    
                        // Add the panel to the Adorners collection.
                        Adorners.Add(autoSizeAdornerPanel);
                    }
    
                    return this.autoSizeAdornerPanel;
                }
            }
    
            // The following code handles the Checked event.
            // It autosizes the adorned control's Height and Width.
            void autoSizeCheckBox_Checked(object sender, RoutedEventArgs e)
            {
                this.SetHeightAndWidth(true);
            }
    
            // The following code handles the Unchecked event.
            // It sets the adorned control's Height and Width to a hard-coded value.
            void autoSizeCheckBox_Unchecked(object sender, RoutedEventArgs e)
            {
                this.SetHeightAndWidth(false);
            }
    
            // The SetHeightAndWidth utility method sets the Height and Width
            // properties through the model and commits the change.
            private void SetHeightAndWidth(bool autoSize)
            {
                settingProperties = true;
    
                try
                {
                using (ModelEditingScope batchedChange = adornedControlModel.BeginEdit())
                {
                    ModelProperty widthProperty =
                        adornedControlModel.Properties["Width"];
    
                    ModelProperty heightProperty =
                        adornedControlModel.Properties["Height"];
    
                    if (autoSize)
                    {
                        widthProperty.ClearValue();
                        heightProperty.ClearValue();
                    }
                    else
                    {
                        widthProperty.SetValue(20d);
                        heightProperty.SetValue(20d);
                    }
    
                    batchedChange.Complete();
                }
                }
                finally { settingProperties = false; }
            }
    
            // The following method deactivates the adorner.
            protected override void Deactivate()
            {
                adornedControlModel.PropertyChanged -= 
                    new System.ComponentModel.PropertyChangedEventHandler(
                        AdornedControlModel_PropertyChanged);
    
                base.Deactivate();
            }
    
            // The following method handles the PropertyChanged event.
            void AdornedControlModel_PropertyChanged(
                object sender, 
                System.ComponentModel.PropertyChangedEventArgs e)
            {
                if (settingProperties)
                {
                    return;
                }
    
                if (e.PropertyName == "Height" || e.PropertyName == "Width")
                {
                    double h = (double)adornedControlModel.Properties["Height"].ComputedValue;
                    double w = (double)adornedControlModel.Properties["Width"].ComputedValue;
    
                    autoSizeCheckBox.IsChecked = (h == double.NaN && w == double.NaN) ? true : false;
                }
            }
        }
    }
    
  3. Compilare la soluzione.

Test dell'implementazione in fase di progettazione

È possibile utilizzare il controllo AutoSizeButton come qualsiasi altro controllo WPF. In WPF Designer viene gestita la creazione di tutti gli oggetti in fase di progettazione.

Per eseguire il test dell'implementazione in fase di progettazione

  1. Aggiungere un nuovo progetto di applicazione WPF denominato DemoApplication alla soluzione.

    MainWindow.xaml viene aperto in WPF Designer.

  2. Aggiungere un riferimento al progetto AutoSizeButtonLibrary.

  3. In visualizzazione XAML sostituire il codice generato automaticamente con il seguente codice. Con questo codice XAML viene aggiunto un riferimento allo spazio dei nomi AutoSizeButtonLibrary e viene aggiunto il controllo personalizzato AutoSizeButton. Il pulsante viene visualizzato in visualizzazione Progettazione con il testo "Design mode active", per indicare che si trova in modalità progettazione. Se il pulsante non viene visualizzato, può essere necessario fare clic sulla barra informazioni nella parte superiore della finestra di progettazione per ricaricare la visualizzazione.

    <Window x:Class="DemoApplication.MainWindow"
        xmlns="https://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="https://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:ab="clr-namespace:AutoSizeButtonLibrary;assembly=AutoSizeButtonLibrary"
        Title="Window1" Height="300" Width="300">
        <Grid>
            <ab:AutoSizeButton Height="Auto" Width="Auto" />
        </Grid>
    </Window>
    
  4. In visualizzazione Progettazione fare clic sul controllo AutoSizeButton per selezionarlo.

    Verrà visualizzato un controllo CheckBox sopra il controllo AutoSizeButton.

  5. Deselezionare lo strumento decorativo visuale della casella di controllo.

    Verranno ridotte le dimensioni del controllo. Lo strumento decorativo visuale della casella di controllo viene spostato in modo da mantenere la posizione in relazione al controllo decorato.

Impostazione del progetto per il debug in fase di progettazione

A questo punto, l'implementazione della fase di progettazione è stata completata. È ora possibile utilizzare Visual Studioper impostare dei punti di interruzione ed eseguire le istruzioni nel codice Design-Time. Per eseguire il debug dell'implementazione della fase di progettazione, allegare un'altra istanza di Visual Studio alla sessione Visual Studio corrente.

Per impostare il progetto per il debug in fase di progettazione

  1. In Esplora soluzioni fare clic con il pulsante destro del mouse sul progetto DemoApplication, quindi scegliere Imposta come progetto di avvio.

  2. In Esplora soluzioni, fare clic con il pulsante destro del mouse sul progetto denominato DemoApplication, quindi scegliere Proprietà.

  3. Nella finestra di progettazione del progetto DemoApplication, fare clic sulla scheda Debug.

  4. Nella sezione Azione di avvio, selezionare Avvia programma esterno. Verrà eseguito il debug di un'istanza separata di Visual Studio.

  5. Fare clic sul pulsante con i puntini di sospensione (Schermata VisualStudioEllipsesButton) per visualizzare la finestra di dialogo Seleziona file.

  6. Sfogliare le cartelle fino a visualizzare Visual Studio. Il nome del file eseguibile è devenv.exe e, se Visual Studio è stato installato nel percorso predefinito, il relativo percorso "%programfiles%\Microsoft Visual Studio 9.0\Common7\IDE\devenv.exe".

  7. Fare clic su Apri per selezionare devenv.exe.

Debug del controllo personalizzato in fase di progettazione

A questo punto è possibile eseguire il debug del controllo personalizzato come fosse in esecuzione in modalità di progettazione. Quando si avvia la sessione di debug, viene creata una nuova istanza di Visual Studio, che dovrà essere utilizzata per caricare la soluzione del progetto AutoSizeButtonLibrary. All'apertura del file MainWindow.xaml in WPF Designer, verrà creata ed eseguita un'istanza del controllo personalizzato.

Per eseguire il debug del controllo personalizzato in fase di progettazione

  1. Aprire il file di codice di AutoSizeButton nell'editor del codice e aggiungere un punto di interruzione nel costruttore.

  2. Aprire il file Metadata.cs o il file Metadata.vb nell'editor del codice e aggiungere un punto di interruzione nella proprietà AttributeTable.

  3. Aprire AutoSizeAdornerProvider.cs o AutoSizeAdornerProvider.vb nell'Editor del codice e aggiungere un punto di interruzione nel costruttore.

  4. Aggiungere punti di interruzione nei metodi rimanenti per la classe AutoSizeAdornerProvider.

  5. Premere F5 per avviare la sessione di debug.

    Verrà creata una seconda istanza di Visual Studio. È possibile distinguere tra l'istanza di debug e la seconda istanza in due modi:

    • L'istanza di debug contiene la parola In esecuzione nella barra del titolo.

    • Il pulsante Avvia dell'istanza di debug è disabilitato nella barra degli strumenti Debug.

    Il punto di interruzione è impostato nell'istanza di debug.

  6. Nella seconda istanza di Visual Studio aprire la soluzione di AutoSizeButtonLibrary.

  7. Aprire MainWindow.xaml in WPF Designer.

    L'istanza di debug di Visual Studio acquisisce lo stato attivo e l'esecuzione si ferma in corrispondenza del punto di interruzione nella proprietà AttributeTable.

  8. Premere F5 per continuare il debug.

    L'esecuzione si ferma in corrispondenza del punto di interruzione nel costruttore AutoSizeButton.

  9. Premere F5 per continuare il debug.

    La seconda istanza di Visual Studio acquisisce lo stato attivo e viene visualizzato WPF Designer.

  10. In visualizzazione Progettazione fare clic sul controllo AutoSizeButton per selezionarlo.

    L'istanza di debug di Visual Studio acquisisce lo stato attivo e l'esecuzione si ferma in corrispondenza del punto di interruzione nel costruttore AutoSizeAdornerProvider.

  11. Premere F5 per continuare il debug.

    L'esecuzione si ferma in corrispondenza del punto di interruzione nel metodo Activate.

  12. Premere F5 per continuare il debug.

    La seconda istanza di Visual Studio acquisisce lo stato attivo e viene visualizzato WPF Designer. Lo strumento decorativo visuale della casella di controllo appare sopra e a sinistra di AutoSizeButton.

  13. Al termine, è possibile arrestare la sessione di debug chiudendo la seconda istanza di Visual Studio oppure facendo clic sul pulsante Termina debug nell'istanza di debug.

Passaggi successivi

È possibile aggiungere altre funzionalità in fase di progettazione ai controlli personalizzati.

Vedere anche

Attività

Procedura dettagliata: debug di un'applicazione WPF

Riferimenti

PrimarySelectionAdornerProvider

SkewTransform

Concetti

Risoluzione dei problemi relativi agli errori di caricamento di WPF e Silverlight Designer

Altre risorse

Procedura: eseguire il debug di un errore di caricamento della finestra di progettazione

Concetti avanzati sulla estensibilità

Estensibilità di Progettazione WPF