Share via

Exemplarische Vorgehensweise: Debuggen von benutzerdefinierten WPF-Steuerelementen zur Entwurfszeit

  • Artikel

In dieser exemplarischen Vorgehensweise wird veranschaulicht, wie Sie einen Entwurfszeitadorner für ein benutzerdefiniertes WPF (Windows Presentation Foundation)-Steuerelement debuggen. Der Adorner ist ein Kontrollkästchen, das ein einfaches Feature zur automatischen Größenanpassung bereitstellt.

Im Verlauf dieser exemplarischen Vorgehensweise führen Sie folgende Aufgaben aus:

  • Erstellen eines benutzerdefinierten WPF-Steuerelementbibliothek-Projekts

  • Erstellen einer separaten Assembly für Entwurfszeitmetadaten

  • Implementieren des Adorneranbieters

  • Testen des Steuerelements zur Entwurfszeit

  • Einrichten des Projekts für das Entwurfszeitdebuggen

  • Debuggen des Steuerelements zur Entwurfszeit

Nach Abschluss wissen Sie, wie Sie einen Adorner für ein benutzerdefiniertes Steuerelement debuggen.

Tipp

Je nach den aktiven Einstellungen oder der Version unterscheiden sich die Dialogfelder und Menübefehle auf Ihrem Bildschirm möglicherweise von den in der Hilfe beschriebenen. Klicken Sie im Menü Extras auf Einstellungen importieren und exportieren, um die Einstellungen zu ändern. Weitere Informationen finden Sie unter Arbeiten mit Einstellungen.

Vorbereitungsmaßnahmen

Zum Durchführen dieser exemplarischen Vorgehensweise benötigen Sie die folgenden Komponenten:

  • Visual Studio 2010.

Erstellen des benutzerdefinierten Steuerelements

Zuerst wird das Projekt für das benutzerdefinierte Steuerelement erstellt. Bei dem Steuerelement handelt es sich um eine Schaltfläche mit wenig Entwurfszeitcode, für die eine GetIsInDesignMode-Methode zum Implementieren eines Entwurfszeitverhaltens verwendet wird.

So erstellen Sie das benutzerdefinierte Steuerelement

  1. Erstellen Sie ein neues benutzerdefiniertes WPF-Steuerelementbibliothek-Projekt in Visual Basic oder Visual C# mit dem Namen AutoSizeButtonLibrary.

    Der Code für CustomControl1 wird im Code-Editor geöffnet.

  2. Ändern Sie im Projektmappen-Explorer den Namen der Codedatei in AutoSizeButton.cs oder AutoSizeButton.vb. Wenn eine Meldung mit der Frage angezeigt wird, ob Sie eine Umbenennung für alle Verweise in diesem Projekt vornehmen möchten, klicken Sie auf Ja.

  3. Öffnen Sie AutoSizeButton.cs bzw. AutoSizeButton.vb im Code-Editor.

  4. Ersetzen Sie den automatisch generierten Code durch den folgenden Code. Dieser Code erbt von Button und zeigt den Text "Aktiver Entwurfsmodus" an, wenn die Schaltfläche im Designer angezeigt wird.

    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. Legen Sie den Ausgabepfad des Projekts auf "bin\" fest.

  6. Erstellen Sie die Projektmappe.

Erstellen der Entwurfszeit-Metadatenassembly

Entwurfszeitcode wird in speziellen Metadatenassemblys bereitgestellt. Bei dieser exemplarischen Vorgehensweise wird der benutzerdefinierte Adorner in einer Assembly mit dem Namen AutoSizeButtonLibrary.VisualStudio.Design bereitgestellt. Weitere Informationen finden Sie unter Bereitstellen von Entwurfszeitmetadaten.

So erstellen Sie die Entwurfszeit-Metadatenassembly

  1. Fügen Sie der Projektmappe ein neues Klassenbibliothek-Projekt in Visual Basic oder Visual C# mit dem Namen AutoSizeButtonLibrary.VisualStudio.Design hinzu.

  2. Legen Sie den Ausgabepfad des Projekts auf folgenden Pfad fest: ".. \AutoSizeButtonLibrary\bin\". Dadurch wird die Assembly des Steuerelements im selben Ordner wie die Metadatenassembly gespeichert, wodurch Designern die Metadatensuche ermöglicht wird.

  3. Fügen Sie Verweise auf die folgenden WPF-Assemblys hinzu.

    • PresentationCore

    • PresentationFramework

    • System.Xaml

    • WindowsBase

  4. Fügen Sie Verweise auf die folgenden WPF-Designer-Assemblys hinzu.

    • Microsoft.Windows.Design.Extensibility

    • Microsoft.Windows.Design.Interaction

  5. Fügen Sie einen Verweis auf das AutoSizeButtonLibrary-Projekt hinzu.

  6. Ändern Sie im Projektmappen-Explorer den Namen der Class1-Codedatei in Metadata.cs oder Metadata.vb. Wenn eine Meldung mit der Frage angezeigt wird, ob Sie eine Umbenennung für alle Verweise in diesem Projekt vornehmen möchten, klicken Sie auf Ja.

  7. Ersetzen Sie den automatisch generierten Code durch den folgenden Code. Durch diesen Code wird eine AttributeTable erstellt, mit der die benutzerdefinierte Entwurfszeitimplementierung an die AutoSizeButton-Klasse angefügt wird.

    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. Speichern Sie die Projektmappe.

Implementieren des Adorneranbieters

Der Adorneranbieter wird in einem Typ mit dem Namen AutoSizeAdornerProvider implementiert. Mit diesem Adorner-FeatureProvider kann die Height-Eigenschaft und die Width-Eigenschaft des Steuerelements zur Entwurfszeit festgelegt werden.

So implementieren Sie den Adorneranbieter

  1. Fügen Sie dem AutoSizeButtonLibrary.VisualStudio.Design-Projekt eine neue Klasse mit dem Namen AutoSizeAdornerProvider hinzu.

  2. Ersetzen Sie im Code-Editor für AutoSizeAdornerProvider den automatisch generierten Code durch den folgenden Code. Mit diesem Code wird ein PrimarySelectionAdornerProvider implementiert, der einen auf einem CheckBox-Steuerelement basierenden Adorner bereitstellt.

    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. Erstellen Sie die Projektmappe.

Testen der Entwurfszeitimplementierung

Sie können das AutoSizeButton-Steuerelement auf dieselbe Art wie jedes andere WPF-Steuerelement verwenden. Der WPF-Designer verwaltet die Erstellung aller Entwurfszeitobjekte.

So testen Sie die Entwurfszeitimplementierung

  1. Fügen Sie der Projektmappe ein neues WPF-Anwendungsprojekt mit dem Namen DemoApplication hinzu.

    Die Datei MainWindow.xaml wird im WPF-Designer geöffnet.

  2. Fügen Sie einen Verweis auf das AutoSizeButtonLibrary-Projekt hinzu.

  3. Ersetzen Sie in der XAML-Ansicht den automatisch generierten Code durch den folgenden Code. Mit diesem XAML werden ein Verweis auf den AutoSizeButtonLibrary-Namespace sowie das benutzerdefinierte AutoSizeButton-Steuerelement hinzugefügt. Die Schaltfläche wird in der Entwurfsansicht mit dem Text "Design mode active" angezeigt, was darauf hindeutet, dass sie sich im Entwurfsmodus befindet. Wenn die Schaltfläche nicht angezeigt wird, müssen Sie möglicherweise auf die Informationsleiste am oberen Rand des Designers klicken, um die Ansicht zu aktualisieren.

    <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. Klicken Sie in der Entwurfsansicht auf das AutoSizeButton-Steuerelement, um es auszuwählen.

    Ein CheckBox-Steuerelement wird über dem AutoSizeButton-Steuerelement angezeigt.

  5. Deaktivieren Sie den Kontrollkästchenadorner.

    Das Steuerelement wird verkleinert. Der Kontrollkästchenadorner wird verschoben, um seine Position relativ zum erweiterten Steuerelement beizubehalten.

Einrichten des Projekts zum Entwurfszeitdebuggen

Zu diesem Zeitpunkt haben Sie die Entwurfszeitimplementierung abgeschlossen. Jetzt können Sie Visual Studio verwenden, um Haltepunkte festzulegen und den Entwurfszeitcode in Einzelschritten auszuführen. Um die Entwurfszeitimplementierung zu debuggen, fügen Sie eine weitere Instanz von Visual Studio an die aktuelle Visual Studio-Sitzung an.

So richten Sie das Projekt zum Entwurfszeitdebuggen ein

  1. Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf das Projekt DemoApplication, und wählen Sie Als Startprojekt festlegen.

  2. Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf das DemoApplication-Projekt, und klicken Sie dann auf Eigenschaften.

  3. Klicken Sie im DemoApplication-Projekt-Designer auf die Registerkarte Debuggen.

  4. Wählen Sie im Abschnitt Startaktion die Option Externes Programm starten aus. Sie debuggen eine separate Instanz von Visual Studio.

  5. Klicken Sie auf die Schaltfläche mit den Auslassungszeichen (VisualStudioEllipsesButton-Bildschirmabbildung), um das Dialogfeld Datei auswählen zu öffnen.

  6. Suchen Sie nach Visual Studio Der Name der ausführbaren Datei lautet devenv.exe. Wenn Visual Studio am Standardspeicherort installiert wurde, lautet der Pfad "%programfiles%\Microsoft Visual Studio 9.0\Common7\IDE\devenv.exe".

  7. Klicken Sie auf Öffnen, um devenv.exe auszuwählen.

Debuggen des benutzerdefinierten Steuerelements zur Entwurfszeit

Nun kann das benutzerdefinierte Steuerelement debuggt werden, während es im Entwurfsmodus ausgeführt wird. Wenn Sie die Debugsitzung starten, wird eine neue Instanz von Visual Studio erstellt, die Sie zum Laden der Projektmappe "AutoSizeButtonLibrary" verwenden. Wenn Sie MainWindow.xaml im WPF-Designer öffnen, wird eine Instanz des benutzerdefinierten Steuerelements erstellt und ausgeführt.

So debuggen Sie das benutzerdefinierte Steuerelement zur Entwurfszeit

  1. Öffnen Sie die AutoSizeButton-Codedatei im Code-Editor, und fügen Sie im Konstruktor einen Haltepunkt hinzu.

  2. Öffnen Sie Metadata.cs oder Metadata.vb im Code-Editor, und fügen Sie in der AttributeTable-Eigenschaft einen Haltepunkt hinzu.

  3. Öffnen Sie AutoSizeAdornerProvider.cs oder AutoSizeAdornerProvider.vb im Code-Editor, und fügen Sie im Konstruktor einen Haltepunkt hinzu.

  4. Fügen Sie Haltepunkte in den übrigen Methoden für die AutoSizeAdornerProvider-Klasse hinzu.

  5. Drücken Sie F5, um die Debugsitzung zu starten.

    Es wird eine zweite Instanz von Visual Studio erstellt. Sie können auf zwei Arten zwischen der Debuginstanz und der zweiten Instanz unterscheiden:

    • Die Debuginstanz enthält in der Titelleiste das Wort Aktiv.

    • In der Debuginstanz ist die Schaltfläche Starten auf der Symbolleiste Debuggen deaktiviert.

    Der Haltepunkt ist in der Debuginstanz festgelegt.

  6. Öffnen Sie in der zweiten Instanz von Visual Studio die Projektmappe AutoSizeButtonLibrary.

  7. Öffnen Sie im WPF-Designer die Datei MainWindow.xaml.

    Die Debuginstanz von Visual Studio wird aktiviert und die Ausführung am Haltepunkt in der AttributeTable-Eigenschaft beendet.

  8. Drücken Sie F5, um mit dem Debuggen fortzufahren.

    Die Ausführung hält am Haltepunkt im AutoSizeButton-Konstruktor an.

  9. Drücken Sie F5, um mit dem Debuggen fortzufahren.

    Die zweite Instanz von Visual Studio wird aktiviert, und der WPF-Designer wird angezeigt.

  10. Klicken Sie in der Entwurfsansicht auf das AutoSizeButton-Steuerelement, um es auszuwählen.

    Die Debuginstanz von Visual Studio wird aktiviert und die Ausführung am Haltepunkt im AutoSizeAdornerProvider-Konstruktor beendet.

  11. Drücken Sie F5, um mit dem Debuggen fortzufahren.

    Die Ausführung hält am Haltepunkt in der Activate-Methode an.

  12. Drücken Sie F5, um mit dem Debuggen fortzufahren.

    Die zweite Instanz von Visual Studio wird aktiviert, und der WPF-Designer wird angezeigt. Der Kontrollkästchenadorner wird links oberhalb vom AutoSizeButton-Element angezeigt.

  13. Nach Abschluss des Verfahrens können Sie die Debugsitzung beenden, indem Sie die zweite Instanz von Visual Studio schließen oder in der Debuginstanz auf die Schaltfläche Debuggen beenden klicken.

Nächste Schritte

Sie können benutzerdefinierten Steuerelementen weitere benutzerdefinierte Entwurfszeitfeatures hinzufügen.

Siehe auch

Aufgaben

Exemplarische Vorgehensweise: Debuggen einer WPF-Anwendung

Referenz

PrimarySelectionAdornerProvider

SkewTransform

Konzepte

Problembehandlung bei Ladefehlern im WPF- und Silverlight-Designer

Weitere Ressourcen

Gewusst wie: Debuggen eines Designerladefehlers

Fortgeschrittene Erweiterungskonzepte

WPF-Designer-Erweiterbarkeit