Nutzen des .NET Framework PropertyGrid-Steuerelements

Artikel
04/30/2007

Ausritt markieren
Microsoft Corporation

Gilt für:
Microsoft® .NET® Framework
Microsoft® Visual Studio® .NET

Zusammenfassung: Hilft Ihnen, das PropertyGrid-Steuerelement im Microsoft .NET Framework zu verstehen und es für Ihre Anwendung anzupassen. (37 gedruckte Seiten)

Inhalte

Einführung in das PropertyGrid-Steuerelement
Erstellen eines PropertyGrid-Steuerelements
Verwenden des PropertyGrid-Steuerelements
Auswählen eines Objekts
Anpassen des PropertyGrid-Steuerelements
Anzeigen komplexer Eigenschaften
Bereitstellen einer benutzerdefinierten Benutzeroberfläche für Ihre Eigenschaften
Zusammenfassung

Einführung in das PropertyGrid-Steuerelement

Wenn Sie Microsoft® Visual Basic® oder Microsoft Visual Studio .NET verwendet haben, haben Sie einen Eigenschaftenbrowser verwendet, um die Eigenschaften eines oder mehrerer Objekte zu durchsuchen, anzuzeigen und zu bearbeiten. Das .NET Framework PropertyGrid-Steuerelements ist der Kern des Eigenschaftenbrowsers, der sich in Visual Studio .NET befindet. Das PropertyGrid-Steuerelement zeigt Eigenschaften für jedes Objekt oder jeden Typ an, und es ruft die Eigenschaften des Elements ab, hauptsächlich mithilfe von Reflektion. (Reflektion ist eine Technologie, die Typinformationen zur Laufzeit bereitstellt.)

Der folgende Screenshot zeigt, wie ein PropertyGrid aussieht, wenn es auf einem Formular platziert wird.

Abbildung 1. PropertyGrid in einem Formular

Das PropertyGrid enthält die folgenden Teile:

Eigenschaften
Erweiterbare Eigenschaften
Überschriften der Eigenschaftskategorie
Eigenschaftsbeschreibungen
Eigenschaften-Editoren
Eigenschaftenregisterkarten
Befehlsbereich (zeigt Designerverben an, die der Designer eines Steuerelements verfügbar macht)

Erstellen eines PropertyGrid-Steuerelements

Um ein PropertyGrid-Steuerelement mit Visual Studio .NET zu erstellen, müssen Sie das PropertyGrid-Steuerelement der Toolbox hinzufügen, da es standardmäßig nicht enthalten ist. Wählen Sie im Menü Extras die Option Toolbox anpassen aus. Wählen Sie im Dialogfeld die Registerkarte Frameworkkomponenten und dann PropertyGrid aus.

Wenn Sie Ihren Code über die Befehlszeile kompilieren, verwenden Sie die Option /reference , und geben Sie System.Windows.Forms.dll an.

Der folgende Code veranschaulicht das Erstellen eines PropertyGrid-Steuerelements und das Hinzufügen zu einem Formular.

' Visual Basic

Imports System
Imports System.Drawing
Imports System.ComponentModel
Imports System.Windows.Forms
Imports System.Globalization

Public Class OptionsDialog
   Inherits System.Windows.Forms.Form

   Private OptionsPropertyGrid As System.Windows.Forms.PropertyGrid

   Public Sub New()
      MyBase.New()

      OptionsPropertyGrid = New PropertyGrid()
      OptionsPropertyGrid.Size = New Size(300, 250)

      Me.Controls.Add(OptionsPropertyGrid)
      Me.Text = "Options Dialog"
   End Sub
End Class


//C#

using System;
using System.Drawing;
using System.ComponentModel;
using System.Windows.Forms;
using System.Globalization;

public class OptionsDialog : System.Windows.Forms.Form
{
   private System.Windows.Forms.PropertyGrid OptionsPropertyGrid;
   public OptionsDialog()
   {
      OptionsPropertyGrid = new PropertyGrid();
      OptionsPropertyGrid.Size = new Size(300, 250);

      this.Controls.Add(OptionsPropertyGrid);
      this.Text = "Options Dialog";
   }

   [STAThread]
   static void Main() 
   {
      Application.Run(new OptionsDialog());
   }
}

Verwenden des PropertyGrid-Steuerelements

Es gibt zahlreiche Stellen in einer Anwendung, an denen Sie eine umfassendere Bearbeitungserfahrung bieten möchten, indem Sie den Benutzer mit einem PropertyGrid interagieren lassen. Ein Beispiel ist eine Anwendung, die über mehrere "Einstellungen" oder Optionen verfügt, von denen einige komplex sind, die ein Benutzer festlegen kann. Sie können Optionsfelder, Kombinationsfelder oder Textfelder verwenden, um diese Optionen darzustellen. Stattdessen werden Sie in diesem Artikel schritt für Schritt die Verwendung des PropertyGrid-Steuerelements durchlaufen, um ein Optionsfenster zum Festlegen von Anwendungsoptionen zu erstellen. Das OptionsDialog Formular, das Sie oben erstellt haben, ist der Anfang des Optionsfensters. Erstellen Sie nun eine Klasse namens AppSettings , die alle Eigenschaften enthält, die den Anwendungseinstellungen zugeordnet sind. Die Einstellungen sind viel einfacher zu verwalten und zu verwalten, wenn Sie eine separate Klasse erstellen, anstatt einzelne Variablen zu verwenden.

' Visual Basic

Public Class AppSettings
    Private _saveOnClose As Boolean = True
    Private _greetingText As String = "Welcome to your application!"
    Private _maxRepeatRate As Integer = 10
    Private _itemsInMRU As Integer = 4

    Private _settingsChanged As Boolean = False
    Private _appVersion As String = "1.0"

    Public Property SaveOnClose() As Boolean
        Get
            Return _saveOnClose
        End Get
        Set(ByVal Value As Boolean)
            SaveOnClose = Value
        End Set
    End Property

    Public Property GreetingText() As String
        Get
            Return _greetingText
        End Get
        Set(ByVal Value As String)
            _greetingText = Value
        End Set
    End Property

    Public Property ItemsInMRUList() As Integer
        Get
            Return _itemsInMRU
        End Get
        Set(ByVal Value As Integer)
            _itemsInMRU = Value
        End Set
    End Property

    Public Property MaxRepeatRate() As Integer
        Get
            Return _maxRepeatRate
        End Get
        Set(ByVal Value As Integer)
            _maxRepeatRate = Value
        End Set
    End Property

    Public Property SettingsChanged() As Boolean
        Get
            Return _settingsChanged
        End Get
        Set(ByVal Value As Boolean)
            _settingsChanged = Value
        End Set
    End Property

    Public Property AppVersion() As String
        Get
            Return _appVersion
        End Get
        Set(ByVal Value As String)
            _appVersion = Value
        End Set
    End Property
End Class


//C#

public class AppSettings{
    private bool saveOnClose = true;
    private string greetingText = "Welcome to your application!";
    private int itemsInMRU = 4;
    private int maxRepeatRate = 10;
    private bool settingsChanged = false;
    private string appVersion = "1.0";
    
    public bool SaveOnClose
    {
        get { return saveOnClose; }
        set { saveOnClose = value;}
    }
    public string GreetingText
    {
        get { return greetingText; }
        set { greetingText = value; }
    }
    public int MaxRepeatRate
    {
        get { return maxRepeatRate; }
        set { maxRepeatRate = value; }
    }
    public int ItemsInMRUList
    {
        get { return itemsInMRU; }
        set { itemsInMRU = value; }
    }
    public bool SettingsChanged
    {
        get { return settingsChanged; }
        set { settingsChanged = value; }
    }
    public string AppVersion
    {
        get { return appVersion; }
        set { appVersion = value; }
    }
}

Das PropertyGrid im Optionsfenster bearbeitet diese Klasse. Fügen Sie also die Klassendefinition zu Ihrem Anwendungsprojekt hinzu, entweder in einer neuen Datei oder am unteren Rand des Quellcodes für das Formular.

Auswählen eines Objekts

Um zu identifizieren, was im PropertyGrid angezeigt wird, legen Sie die PropertyGrid.SelectedObject-Eigenschaft auf ein Objekt instance fest. Den Rest übernimmt Das PropertyGrid . Jedes Mal, wenn Sie SelectedObject festlegen, aktualisiert PropertyGrid die angezeigten Eigenschaften. Dies bietet eine einfache Möglichkeit, die Aktualisierung von Eigenschaften zu erzwingen oder zur Laufzeit zwischen Objekten zu wechseln. Sie können auch die PropertyGrid.Refresh-Methode aufrufen, um Eigenschaften zu aktualisieren.

Aktualisieren Sie zum Fortfahren den Code im OptionsDialog Konstruktor, um ein AppSettings Objekt zu erstellen, und legen Sie es auf die PropertyGrid.SelectedObject-Eigenschaft fest.

' Visual Basic

   Public Sub New()
      MyBase.New()

      OptionsPropertyGrid = New PropertyGrid()
      OptionsPropertyGrid.Size = New Size(300, 250)

      Me.Controls.Add(OptionsPropertyGrid)
      Me.Text = "Options Dialog"

      ' Create the AppSettings class and display it in the PropertyGrid.      Dim appset as AppSettings = New AppSettings()      OptionsPropertyGrid.SelectedObject = appset
   End Sub


//C#

   public OptionsDialog()
   {
      OptionsPropertyGrid = new PropertyGrid();
      OptionsPropertyGrid.Size = new Size(300, 250);

      this.Controls.Add(OptionsPropertyGrid);
      this.Text = "Options Dialog";

      // Create the AppSettings class and display it in the PropertyGrid.      AppSettings appset = new AppSettings();      OptionsPropertyGrid.SelectedObject = appset;
   }

Kompilieren Sie die Anwendung, und führen Sie sie aus. Der folgende Screenshot zeigt, wie es aussehen soll.

Abbildung 2. AppSettings-Klasse, die im PropertyGrid ausgewählt ist

Anpassen des PropertyGrid-Steuerelements

Sie können einige visuelle Aspekte von PropertyGrid an Ihre Anforderungen anpassen. Möglicherweise möchten Sie die Anzeige einiger Eigenschaften ändern und sogar einige Eigenschaften nicht anzeigen. Wie anpassbar ist das PropertyGrid?

Ändern visueller Aspekte des PropertyGrid

Viele visuelle Aspekte von PropertyGrid können angepasst werden. Im Anschluss finden Sie eine unvollständige Liste:

Ändern Sie die Hintergrundfarbe, ändern Sie die Schriftfarbe, oder blenden Sie den Beschreibungsbereich über die Eigenschaften HelpBackColor, HelpForeColor und HelpVisible aus .
Blenden Sie die Symbolleiste über die ToolbarVisible-Eigenschaft aus, ändern Sie ihre Farbe über die BackColor-Eigenschaft , und zeigen Sie große Symbolleistenschaltflächen über die LargeButtons-Eigenschaft an.
Sortieren Sie die Eigenschaften alphabetisch, und kategorisieren Sie sie mithilfe der PropertySort-Eigenschaft .
Ändern Sie die Splitterfarbe über die BackColor-Eigenschaft .
Ändern Sie die Rasterlinie und die Rahmen über die LineColor-Eigenschaft .

Für das Optionsfenster in diesem Beispiel ist die Symbolleiste nicht erforderlich, daher legen Sie SymbolleisteVisible auf false fest. Übernehmen Sie alle anderen Standardeinstellungen.

Ändern der Anzeige von Eigenschaften

Um die Anzeige einiger Eigenschaften zu ändern, können Sie verschiedene Attribute auf die Eigenschaften anwenden. Attribute sind deklarative Tags, die zum Kommentieren von Programmierelementen wie Typen, Feldern, Methoden und Eigenschaften verwendet werden, die zur Laufzeit mithilfe von Reflektion abgerufen werden können. Im Anschluss finden Sie eine unvollständige Liste:

DescriptionAttribute. Legt den Text für die Eigenschaft fest, die im Hilfebereich beschreibung unterhalb der Eigenschaften angezeigt wird. Dies ist eine nützliche Möglichkeit, Hilfetext für die aktive Eigenschaft (die Eigenschaft mit Fokus) bereitzustellen. Wenden Sie dieses Attribut auf die MaxRepeatRate -Eigenschaft an.
CategoryAttribute. Legt die Kategorie fest, unter der sich die Eigenschaft im Raster befindet. Dies ist nützlich, wenn Eine Eigenschaft nach einem Kategorienamen gruppiert werden soll. Wenn für eine Eigenschaft keine Kategorie angegeben ist, wird sie der Kategorie "Misc " zugewiesen. Wenden Sie dieses Attribut auf alle Eigenschaften an.
BrowsableAttribute : Gibt an, ob die Eigenschaft im Raster angezeigt wird. Dies ist nützlich, wenn Sie eine Eigenschaft im Raster ausblenden möchten. Standardmäßig wird im Raster immer eine öffentliche Eigenschaft angezeigt. Wenden Sie dieses Attribut auf die SettingsChanged -Eigenschaft an.
ReadOnlyAttribute : Gibt an, ob die Eigenschaft schreibgeschützt ist. Dies ist nützlich, wenn Sie sicherstellen möchten, dass eine Eigenschaft nicht im Raster bearbeitet werden kann. Standardmäßig kann eine öffentliche Eigenschaft mit den Accessorfunktionen get und set im Raster bearbeitet werden. Wenden Sie dieses Attribut auf die AppVersion -Eigenschaft an.
DefaultValueAttribute : Gibt den Standardwert der Eigenschaft an. Dies ist nützlich, wenn Sie einen Standardwert für eine Eigenschaft angeben und später ermitteln möchten, ob sich der Wert der Eigenschaft vom Standardwert unterscheidet. Wenden Sie dieses Attribut auf alle Eigenschaften an.
DefaultPropertyAttribute : Gibt die Standardeigenschaft für die -Klasse an. Die Standardeigenschaft für eine Klasse ruft zuerst den Fokus ab, wenn die Klasse im Raster ausgewählt ist. Wenden Sie dieses Attribut auf die AppSettings -Klasse an.

Wenden Sie nun einige dieser Attribute auf die AppSettings -Klasse an, um die Anzeige der Eigenschaften in PropertyGrid zu ändern.

' Visual Basic

<DefaultPropertyAttribute("SaveOnClose")> _
Public Class AppSettings
    Private _saveOnClose As Boolean = True
    Private _greetingText As String = "Welcome to your application!"
    Private _maxRepeatRate As Integer = 10
    Private _itemsInMRU As Integer = 4

    Private _settingsChanged As Boolean = False
    Private _appVersion As String = "1.0"

    <CategoryAttribute("Document Settings"), _     DefaultValueAttribute(True)> _
    Public Property SaveOnClose() As Boolean
        Get
            Return _saveOnClose
        End Get
        Set(ByVal Value As Boolean)
            SaveOnClose = Value
        End Set
    End Property

    <CategoryAttribute("Global Settings"), _    ReadOnlyAttribute(True), _    DefaultValueAttribute("Welcome to your application!")> _
    Public Property GreetingText() As String
        Get
            Return _greetingText
        End Get
        Set(ByVal Value As String)
            _greetingText = Value
        End Set
    End Property

    <CategoryAttribute("Global Settings"), _    DefaultValueAttribute(4)> _
    Public Property ItemsInMRUList() As Integer
        Get
            Return _itemsInMRU
        End Get
        Set(ByVal Value As Integer)
            _itemsInMRU = Value
        End Set
    End Property

    <DescriptionAttribute("The rate in milliseconds that the text will repeat."), _    CategoryAttribute("Global Settings"), _    DefaultValueAttribute(10)> _
    Public Property MaxRepeatRate() As Integer
        Get
            Return _maxRepeatRate
        End Get
        Set(ByVal Value As Integer)
            _maxRepeatRate = Value
        End Set
    End Property

    <BrowsableAttribute(False),     DefaultValueAttribute(False)> _
    Public Property SettingsChanged() As Boolean
        Get
            Return _settingsChanged
        End Get
        Set(ByVal Value As Boolean)
            _settingsChanged = Value
        End Set
    End Property

    <CategoryAttribute("Version"), _    DefaultValueAttribute("1.0"), _    ReadOnlyAttribute(True)> _
    Public Property AppVersion() As String
        Get
            Return _appVersion
        End Get
        Set(ByVal Value As String)
            _appVersion = Value
        End Set
    End Property
End Class


//C#[DefaultPropertyAttribute("SaveOnClose")]
public class AppSettings{
    private bool saveOnClose = true;
    private string greetingText = "Welcome to your application!";
    private int maxRepeatRate = 10;
    private int itemsInMRU = 4;

    private bool settingsChanged = false;
    private string appVersion = "1.0";

    [CategoryAttribute("Document Settings"),    DefaultValueAttribute(true)]
    public bool SaveOnClose
    {
        get { return saveOnClose; }
        set { saveOnClose = value;}
    }

    [CategoryAttribute("Global Settings"),    ReadOnlyAttribute(true),    DefaultValueAttribute("Welcome to your application!")]
    public string GreetingText
    {
        get { return greetingText; }
        set { greetingText = value; }
    }

    [CategoryAttribute("Global Settings"),    DefaultValueAttribute(4)]
    public int ItemsInMRUList
    {
        get { return itemsInMRU; }
        set { itemsInMRU = value; }
    }

    [DescriptionAttribute("The rate in milliseconds that the text will repeat."),    CategoryAttribute("Global Settings"),    DefaultValueAttribute(10)]
    public int MaxRepeatRate
    {
        get { return maxRepeatRate; }
        set { maxRepeatRate = value; }
    }

    [BrowsableAttribute(false),    DefaultValueAttribute(false)]
    public bool SettingsChanged
    {
        get { return settingsChanged; }
        set { settingsChanged = value; }
    }

    [CategoryAttribute("Version"),    DefaultValueAttribute("1.0"),    ReadOnlyAttribute(true)]
    public string AppVersion
    {
        get { return appVersion; }
        set { appVersion = value; }
    }
}

Wenn diese Attribute auf dieAppSettings -Klasse angewendet werden, kompilieren Sie die Anwendung, und führen Sie sie aus. Der folgende Screenshot zeigt, wie es aussehen sollte.

Abbildung 3. Eigenschaften, die mit Kategorien und Standardwerten im PropertyGrid angezeigt werden

Nachdem Sie mit dieser Version des Optionsfensters gearbeitet haben, bemerken Sie möglicherweise Folgendes:

Die SaveOnClose Eigenschaft erhält den Fokus, wenn das Fenster angezeigt wird.
Die MaxRepeatRate -Eigenschaft zeigt "Die Rate in Millisekunden, die der Text wiederholt" im Hilfebereich der Beschreibung an, wenn sie ausgewählt ist.
Die SaveOnClose -Eigenschaft wird unter der Kategorie "Dokumenteinstellungen" angezeigt. Die anderen Eigenschaften werden unter zwei anderen Kategorien namens "Globale Einstellungen" und "Version" angezeigt.
Die SettingsChanged -Eigenschaft wird nicht mehr angezeigt.
Die AppVersion-Eigenschaft ist schreibgeschützt. Schreibgeschützte Eigenschaften werden mit abgeblendeten Text angezeigt.
Wenn die SaveOnClose Eigenschaft einen anderen Wert als true hat, wird sie fett formatiert angezeigt. PropertyGrid verwendet fett formatierten Text, um Eigenschaften anzugeben, die einen Nicht-Standardwert aufweisen.

Anzeigen komplexer Eigenschaften

Bisher wurden im Optionsfenster einfache Typen wie ganze Zahlen, Boolesche Werte und Zeichenfolgen angezeigt. Was ist mit komplexeren Typen? Was geschieht, wenn Ihre Anwendung etwa Fenstergröße, Dokumentschriftart oder Symbolleistenfarbe nachverfolgen muss? Einige Datentypen, die vom .NET Framework bereitgestellt werden, verfügen über spezielle Anzeigefunktionen, die dazu beitragen, dass sie in PropertyGrid besser verwendet werden können.

Unterstützung für bereitgestellte Typen

Aktualisieren Sie zunächst die AppSettings -Klasse, um neue Eigenschaften für die Fenstergröße (Größentyp ), die Fensterschriftart (Schriftart ) und die Symbolleistenfarbe (Farbtyp ) hinzuzufügen.

' Visual Basic

<DefaultPropertyAttribute("SaveOnClose")> _
Public Class AppSettings
    Private _saveOnClose As Boolean = True
    Private _greetingText As String = "Welcome to your application!"
    Private _maxRepeatRate As Integer = 10
    Private _itemsInMRU As Integer = 4

    Private _settingsChanged As Boolean = False
    Private _appVersion As String = "1.0"

    Private _windowSize As Size = New Size(100, 100)    Private _windowFont As Font = New Font("Arial", 8, FontStyle.Regular)    Private _toolbarColor As Color = SystemColors.Control

    <CategoryAttribute("Document Settings"), _
     DefaultValueAttribute(True)> _
    Public Property SaveOnClose() As Boolean
        Get
            Return _saveOnClose
        End Get
        Set(ByVal Value As Boolean)
            SaveOnClose = Value
        End Set
    End Property

    <CategoryAttribute("Document Settings")> _    Public Property WindowSize() As Size        Get            Return _windowSize        End Get        Set(ByVal Value As Size)            _windowSize = Value        End Set    End Property    <CategoryAttribute("Document Settings")> _    Public Property WindowFont() As Font        Get            Return _windowFont        End Get        Set(ByVal Value As Font)            _windowFont = Value        End Set    End Property    <CategoryAttribute("Global Settings")> _    Public Property ToolbarColor() As Color        Get            Return _toolbarColor        End Get        Set(ByVal Value As Color)            _toolbarColor = Value        End Set    End Property

    <CategoryAttribute("Global Settings"), _
    ReadOnlyAttribute(True), _
    DefaultValueAttribute("Welcome to your application!")> _
    Public Property GreetingText() As String
        Get
            Return _greetingText
        End Get
        Set(ByVal Value As String)
            _greetingText = Value
        End Set
    End Property

    <CategoryAttribute("Global Settings"), _
    DefaultValueAttribute(4)> _
    Public Property ItemsInMRUList() As Integer
        Get
            Return _itemsInMRU
        End Get
        Set(ByVal Value As Integer)
            _itemsInMRU = Value
        End Set
    End Property

    <DescriptionAttribute("The rate in milliseconds that the text will repeat."), _
    CategoryAttribute("Global Settings"), _
    DefaultValueAttribute(10)> _
    Public Property MaxRepeatRate() As Integer
        Get
            Return _maxRepeatRate
        End Get
        Set(ByVal Value As Integer)
            _maxRepeatRate = Value
        End Set
    End Property

    <BrowsableAttribute(False),
     DefaultValueAttribute(False)> _
    Public Property SettingsChanged() As Boolean
        Get
            Return _settingsChanged
        End Get
        Set(ByVal Value As Boolean)
            _settingsChanged = Value
        End Set
    End Property

    <CategoryAttribute("Version"), _
    DefaultValueAttribute("1.0"), _
    ReadOnlyAttribute(True)> _
    Public Property AppVersion() As String
        Get
            Return _appVersion
        End Get
        Set(ByVal Value As String)
            _appVersion = Value
        End Set
    End Property
End Class


//C#

[DefaultPropertyAttribute("SaveOnClose")]
public class AppSettings{
    private bool saveOnClose = true;
    private string greetingText = "Welcome to your application!";
    private int maxRepeatRate = 10;
    private int itemsInMRU = 4;

    private bool settingsChanged = false;
    private string appVersion = "1.0";
    
    private Size windowSize = new Size(100,100);    private Font windowFont = new Font("Arial", 8, FontStyle.Regular);    private Color toolbarColor = SystemColors.Control;

    [CategoryAttribute("Document Settings"),
    DefaultValueAttribute(true)]
    public bool SaveOnClose
    {
        get { return saveOnClose; }
        set { saveOnClose = value;}
    }

    [CategoryAttribute("Document Settings")]    public Size WindowSize     {        get { return windowSize; }        set { windowSize = value;}    }    [CategoryAttribute("Document Settings")]    public Font WindowFont     {        get {return windowFont; }        set { windowFont = value;}    }    [CategoryAttribute("Global Settings")]    public Color ToolbarColor    {        get { return toolbarColor; }        set { toolbarColor = value; }    }

    [CategoryAttribute("Global Settings"),
    ReadOnlyAttribute(true),
    DefaultValueAttribute("Welcome to your application!")]
    public string GreetingText
    {
        get { return greetingText; }
        set { greetingText = value; }
    }

    [CategoryAttribute("Global Settings"),
    DefaultValueAttribute(4)]
    public int ItemsInMRUList
    {
        get { return itemsInMRU; }
        set { itemsInMRU = value; }
    }

    [DescriptionAttribute("The rate in milliseconds that the text will repeat."),
    CategoryAttribute("Global Settings"),
    DefaultValueAttribute(10)]
    public int MaxRepeatRate
    {
        get { return maxRepeatRate; }
        set { maxRepeatRate = value; }
    }

    [BrowsableAttribute(false),
    DefaultValueAttribute(false)]
    public bool SettingsChanged
    {
        get { return settingsChanged; }
        set { settingsChanged = value; }
    }

    [CategoryAttribute("Version"),
    DefaultValueAttribute("1.0"),
    ReadOnlyAttribute(true)]
    public string AppVersion
    {
        get { return appVersion; }
        set { appVersion = value; }
    }
}

Der folgende Screenshot zeigt, wie die neuen Eigenschaften in PropertyGrid aussehen.

Abbildung 4. .NET Framework Datentypen, die im PropertyGrid angezeigt werden

Beachten Sie, dass die WindowFont Eigenschaft über eine Schaltfläche mit den Auslassungspunkten ("...") verfügt, die beim Drücken ein Dialogfeld zur Schriftartauswahl anzeigt. Darüber hinaus kann die -Eigenschaft erweitert werden, um weitere Schriftarteigenschaften anzuzeigen. Einige der Schriftarteigenschaften bieten eine Dropdownliste mit Werten und Details zur Schriftart. Die WindowSize -Eigenschaft kann erweitert werden, um weitere Eigenschaften des Typs Größe anzuzeigen. Beachten Sie schließlich, dass die ToolbarColor -Eigenschaft über ein Farbfeld der ausgewählten Farbe und eine benutzerdefinierte Dropdownliste zum Auswählen verschiedener Farben verfügt. Für diese und andere Datentypen stellt die .NET Framework zusätzliche Klassen bereit, um die Bearbeitung in PropertyGrid zu vereinfachen.

Unterstützung für benutzerdefinierte Typen

Fügen Sie der AppSettings -Klasse nun zwei weitere Eigenschaften hinzu, eine mit dem Namen DefaultFileName und die andere mit dem Namen SpellCheckOptions. Die DefaultFileName -Eigenschaft ruft eine Zeichenfolge ab oder legt sie fest, und die SpellCheckOptions -Eigenschaft ruft einen instance der -Klasse ab oder legt sie SpellingOptions fest.

Die SpellingOptions -Klasse ist eine neue Klasse, die die Eigenschaften der Rechtschreibprüfung der Anwendung verwaltet. Es gibt keine feste und schnelle Regel darüber, wann eine separate Klasse zum Verwalten der Eigenschaften eines Objekts erstellt werden soll. Dies hängt von Ihrem allgemeinen Klassenentwurf ab. Fügen Sie die SpellingOptions Klassendefinition ihrem Anwendungsprojekt hinzu, entweder in einer neuen Datei oder am Unteren Rand des Quellcodes für das Formular.

' Visual Basic

<DescriptionAttribute("Expand to see the spelling options for the application.")> _
Public Class SpellingOptions
    Private _spellCheckWhileTyping As Boolean = True
    Private _spellCheckCAPS As Boolean = False
    Private _suggestCorrections As Boolean = True

    <DefaultValueAttribute(True)> _
    Public Property SpellCheckWhileTyping() As Boolean
        Get
            Return _spellCheckWhileTyping
        End Get
        Set(ByVal Value As Boolean)
            _spellCheckWhileTyping = Value
        End Set
    End Property

    <DefaultValueAttribute(False)> _
    Public Property SpellCheckCAPS() As Boolean
        Get
            Return _spellCheckCAPS
        End Get
        Set(ByVal Value As Boolean)
            _spellCheckCAPS = Value
        End Set
    End Property

    <DefaultValueAttribute(True)> _
    Public Property SuggestCorrections() As Boolean
        Get
            Return _suggestCorrections
        End Get
        Set(ByVal Value As Boolean)
            _suggestCorrections = Value
        End Set
    End Property
End Class


//C#

[DescriptionAttribute("Expand to see the spelling options for the application.")]
public class SpellingOptions{
    private bool spellCheckWhileTyping = true;
    private bool spellCheckCAPS = false;
    private bool suggestCorrections = true;

    [DefaultValueAttribute(true)]
    public bool SpellCheckWhileTyping 
    {
        get { return spellCheckWhileTyping; }
        set { spellCheckWhileTyping = value; }
    }

    [DefaultValueAttribute(false)]
    public bool SpellCheckCAPS 
    {
        get { return spellCheckCAPS; }
        set { spellCheckCAPS = value; }
    }
    [DefaultValueAttribute(true)]
    public bool SuggestCorrections 
    {
        get { return suggestCorrections; }
        set { suggestCorrections = value; }
    }
}

Kompilieren Sie die Optionsfensteranwendung, und führen Sie sie erneut aus. Der folgende Screenshot zeigt, wie es aussehen sollte.

Abbildung 5. Benutzerdefinierte Datentypen ohne Typkonverter, die in PropertyGrid angezeigt werden

Beachten Sie, wie die SpellcheckOptions -Eigenschaft aussieht. Im Gegensatz zu den .NET Framework-Typen wird keine benutzerdefinierte Zeichenfolgendarstellung erweitert oder angezeigt. Was geschieht, wenn Sie die gleiche Bearbeitungserfahrung wie die .NET Framework-Typen für Ihren eigenen komplexen Typ bereitstellen möchten? Die .NET Framework Typen verwenden die TypeConverter- und UITypeEditor-Klassen, um den Größten Teil der PropertyGrid-Bearbeitungsunterstützung bereitzustellen, und Sie können sie auch verwenden.

Hinzufügen von Unterstützung für erweiterbare Eigenschaften

Um propertyGrid zum Erweitern der SpellingOptions Eigenschaft abzurufen, müssen Sie einen TypeConverter erstellen. Ein TypeConverter bietet eine Möglichkeit zum Konvertieren von einem Typ in einen anderen. PropertyGrid verwendet den TypeConverter, um Ihren Objekttyp in eine Zeichenfolge zu konvertieren, die zum Anzeigen des Objektwerts im Raster verwendet wird. Während der Bearbeitung konvertiert der TypeConverter aus einer Zeichenfolge wieder in Ihren Objekttyp. Die .NET Framework stellt die ExpandableObjectConverter-Klasse bereit, um dies zu vereinfachen.

So stellen Sie erweiterbare Objektunterstützung bereit

Erstellen Sie eine Klasse, die von ExpandableObjectConverter erbt.

' Visual Basic

Public Class SpellingOptionsConverter
    Inherits ExpandableObjectConverter
End Class


//C#

public class SpellingOptionsConverter:ExpandableObjectConverter 
{  }

Überschreiben Sie die CanConvertTo-Methode , und geben Sie true zurück, wenn der destinationType Parameter denselben Typ wie die Klasse aufweist, die diesen Typkonverter verwendet (die SpellingOptions Klasse in Ihrem Beispiel). Andernfalls wird der Wert der CanConvertTo-Basisklasse-Methode zurückgegeben.

' Visual Basic

Public Overloads Overrides Function CanConvertTo( _
                              ByVal context As ITypeDescriptorContext, _
                              ByVal destinationType As Type) As Boolean
    If (destinationType Is GetType(SpellingOptions)) Then
        Return True
    End If
    Return MyBase.CanConvertFrom(context, destinationType)
End Function

//C#

public override bool CanConvertTo(ITypeDescriptorContext context,
                                  System.Type destinationType) 
{
    if (destinationType == typeof(SpellingOptions))
        return true;

    return base.CanConvertTo(context, destinationType);
}

Überschreiben Sie die ConvertTo-Methode , und stellen Sie sicher, dass der destinationType Parameter ein String ist und dass der Wert der gleiche Typ wie die Klasse ist, die diesen Typkonverter verwendet (die SpellingOptions -Klasse in Ihrem Beispiel). Wenn in beiden Fällen false angegeben ist, geben Sie den Wert der ConvertTo-Methode der Basisklasse zurück. Gibt andernfalls eine Zeichenfolgendarstellung des Wertobjekts zurück. Die Zeichenfolgendarstellung muss jede Eigenschaft ihrer Klasse durch ein eindeutiges Trennzeichen trennen. Da die gesamte Zeichenfolge im PropertyGrid angezeigt wird, sollten Sie ein Trennzeichen auswählen, das die Lesbarkeit nicht beeinträchtigt. Kommas funktionieren in der Regel gut.

' Visual Basic

Public Overloads Overrides Function ConvertTo( _
                              ByVal context As ITypeDescriptorContext, _
                              ByVal culture As CultureInfo, _
                              ByVal value As Object, _
                              ByVal destinationType As System.Type) _
                     As Object
    If (destinationType Is GetType(System.String) _
        AndAlso TypeOf value Is SpellingOptions) Then

        Dim so As SpellingOptions = CType(value, SpellingOptions)

        Return "Check while typing: " & so.SpellCheckWhileTyping & _
               ", check CAPS: " & so.SpellCheckCAPS & _
               ", suggest corrections: " & so.SuggestCorrections
    End If
    Return MyBase.ConvertTo(context, culture, value, destinationType)
End Function

//C#

public override object ConvertTo(ITypeDescriptorContext context,
                               CultureInfo culture, 
                               object value, 
                               System.Type destinationType) 
{
    if (destinationType == typeof(System.String) && 
         value is SpellingOptions){

        SpellingOptions so = (SpellingOptions)value;

        return "Check while typing:" + so.SpellCheckWhileTyping + 
               ", check CAPS: " + so.SpellCheckCAPS +
               ", suggest corrections: " + so.SuggestCorrections;
    }
    return base.ConvertTo(context, culture, value, destinationType);
}

(Optional) Sie können die Bearbeitung der Zeichenfolgendarstellung des Objekts im Raster aktivieren, indem Sie angeben, dass ihr Typkonverter aus einer Zeichenfolge konvertieren kann. Dazu überschreiben Sie zunächst die CanConvertFrom-Methode und geben true zurück, wenn der Source Type-Parameter vom Typ String ist. Andernfalls wird der Wert der CanConvertFrom-Basisklasse zurückgegeben.

' Visual Basic

Public Overloads Overrides Function CanConvertFrom( _
                           ByVal context As ITypeDescriptorContext, _
                           ByVal sourceType As System.Type) As Boolean
    If (sourceType Is GetType(String)) Then
        Return True
    End If
    Return MyBase.CanConvertFrom(context, sourceType)
End Function

//C#

public override bool CanConvertFrom(ITypeDescriptorContext context,
                              System.Type sourceType) 
{
    if (sourceType == typeof(string))
        return true;

    return base.CanConvertFrom(context, sourceType);
}

Um die Bearbeitung der Basisklasse des Objekts zu ermöglichen, müssen Sie auch die ConvertFrom-Methode überschreiben und sicherstellen, dass der value-Parameter ein String ist. Wenn es sich nicht um einen String-Wert handelt, geben Sie den Wert der ConvertFrom-Basisklasse zurück. Andernfalls wird basierend auf dem value-Parameter eine neue instance Ihrer Klasse (die SpellingOptions -Klasse in Ihrem Beispiel) zurückgegeben. Sie müssen die Werte für jede Eigenschaft Ihrer Klasse aus dem value-Parameter analysieren. Wenn Sie das Format der durch Trennzeichen getrennten Zeichenfolge kennen, die Sie in der ConvertTo-Methode erstellt haben, können Sie die Analyse durchführen.

' Visual Basic

Public Overloads Overrides Function ConvertFrom( _
                              ByVal context As ITypeDescriptorContext, _
                              ByVal culture As CultureInfo, _
                              ByVal value As Object) As Object

    If (TypeOf value Is String) Then
        Try
            Dim s As String = CStr(value)
            Dim colon As Integer = s.IndexOf(":")
            Dim comma As Integer = s.IndexOf(",")

            If (colon <> -1 AndAlso comma <> -1) Then
                Dim checkWhileTyping As String = s.Substring(colon + 1, _
                                                (comma - colon - 1))

                colon = s.IndexOf(":", comma + 1)
                comma = s.IndexOf(",", comma + 1)

                Dim checkCaps As String = s.Substring(colon + 1, _
                                                (comma - colon - 1))

                colon = s.IndexOf(":", comma + 1)

                Dim suggCorr As String = s.Substring(colon + 1)

                Dim so As SpellingOptions = New SpellingOptions()

                so.SpellCheckWhileTyping = Boolean.Parse(checkWhileTyping)
                so.SpellCheckCAPS = Boolean.Parse(checkCaps)
                so.SuggestCorrections = Boolean.Parse(suggCorr)

                Return so
            End If
        Catch
            Throw New ArgumentException( _
                "Can not convert '" & CStr(value) & _ 
                                  "' to type SpellingOptions")

        End Try
    End If
    Return MyBase.ConvertFrom(context, culture, value)
End Function

//C#

public override object ConvertFrom(ITypeDescriptorContext context,
                              CultureInfo culture, object value) 
{
    if (value is string) {
        try {
            string s = (string) value;
            int colon = s.IndexOf(':');
            int comma = s.IndexOf(',');

            if (colon != -1 && comma != -1) {
                string checkWhileTyping = s.Substring(colon + 1 ,
                                                (comma - colon - 1));

                colon = s.IndexOf(':', comma + 1);
                comma = s.IndexOf(',', comma + 1);

                string checkCaps = s.Substring(colon + 1 , 
                                                (comma - colon -1));

                colon = s.IndexOf(':', comma + 1);

                string suggCorr = s.Substring(colon + 1);

                SpellingOptions so = new SpellingOptions();

                so.SpellCheckWhileTyping =Boolean.Parse(checkWhileTyping);
                so.SpellCheckCAPS = Boolean.Parse(checkCaps);
                so.SuggestCorrections = Boolean.Parse(suggCorr);

                return so;
            }
        }
        catch {
            throw new ArgumentException(
                "Can not convert '" + (string)value + 
                                   "' to type SpellingOptions");
        }
    }  
    return base.ConvertFrom(context, culture, value);
}

Nachdem Sie nun über eine Typkonverterklasse verfügen, müssen Sie die Zielklasse identifizieren, von der sie verwendet wird. Dazu wenden Sie das TypeConverterAttribute auf die Zielklasse (die SpellingOptions -Klasse in Ihrem Beispiel) an.

' Visual Basic

' The TypeConverter attribute applied to the SpellingOptions class.
<TypeConverter(GetType(SpellingOptionsConverter)), _
DescriptionAttribute("Expand to see the spelling options for the application.")> _
Public Class SpellingOptions
   ...
End Class


//C#

// The TypeConverter attribute applied to the SpellingOptions class.
 [TypeConverterAttribute(typeof(SpellingOptionsConverter)),
DescriptionAttribute("Expand to see the spelling options for the application.")]
public class SpellingOptions{ ... }

Kompilieren Sie die Optionsfensteranwendung, und führen Sie sie erneut aus. Der folgende Screenshot zeigt, wie das Optionsfenster jetzt aussehen sollte.

Abbildung 6. Benutzerdefinierte Datentypen mit einem Typkonverter, der in PropertyGrid angezeigt wird

**Hinweis ** Wenn Sie nur die erweiterbare Objektunterstützung, aber nicht die benutzerdefinierte Zeichenfolgendarstellung möchten, können Sie das TypeConverterAttribute einfach auf Ihre Klasse anwenden. Geben Sie ExpandableObjectConverter als Typkonvertertyp an.

Hinzufügen von Domänenlisten und Unterstützung für einfache Dropdowneigenschaften

Für Eigenschaften, die eine Enumeration basierend auf dem Enum-Typ zurückgeben, zeigt PropertyGrid automatisch die Enumerationswerte in einer Dropdownliste an. Der EnumConverter stellt diese Funktionalität ebenfalls bereit. Für Ihre eigenen Eigenschaften können Sie dem Benutzer eine Liste gültiger Werte bereitstellen, die manchmal auch als Auswahlliste oder Domänenliste bezeichnet werden, mit Typen, die nicht auf Enum basieren. Dies ist der Fall, wenn die Domänenwerte erst zur Laufzeit bekannt sind oder wenn sich die Werte ändern können.

Ändern Sie das Optionsfenster, um eine Domänenliste mit Standarddateinamen bereitzustellen, aus denen der Benutzer auswählen kann. Sie haben die DefaultFileName -Eigenschaft bereits der AppSettings -Klasse hinzugefügt. Der nächste Schritt besteht darin, die Dropdownliste für die Eigenschaft im PropertyGrid anzuzeigen, um die Domänenliste bereitzustellen.

So stellen Sie einfache Unterstützung für Dropdowneigenschaften bereit

Erstellen Sie eine Klasse, die von einer Typkonverterklasse erbt. Da die DefaultFileName Eigenschaft vom Typ String ist, können Sie von StringConverter erben. Wenn kein Typkonverter für den Typ Ihrer Eigenschaft vorhanden ist, können Sie von TypeConverter erben. in diesem Fall ist dies nicht erforderlich.
```
' Visual Basic

Public Class FileNameConverter
    Inherits StringConverter
End Class


//C#

public class FileNameConverter: StringConverter 
{  } 
```

Überschreiben Sie die GetStandardValuesSupported-Methode , und geben Sie true zurück, um anzugeben, dass dieses Objekt einen Standardsatz von Werten unterstützt, die aus einer Liste ausgewählt werden können.

' Visual Basic

Public Overloads Overrides Function GetStandardValuesSupported( _
                    ByVal context As ITypeDescriptorContext) As Boolean
    Return True
End Function


//C#

public override bool GetStandardValuesSupported(
                           ITypeDescriptorContext context) 
{
    return true;
}

Überschreiben Sie die GetStandardValues-Methode , und geben Sie eine StandardValuesCollection zurück, die mit Ihren Standardwerten gefüllt ist. Eine Möglichkeit zum Erstellen einer StandardValuesCollection besteht darin, ein Array von Werten im Konstruktor bereitzustellen. Für die Optionsfensteranwendung können Sie ein Zeichenfolgenarray verwenden, das mit den vorgeschlagenen Standarddateinamen gefüllt ist.

' Visual Basic

Public Overloads Overrides Function GetStandardValues( _
                     ByVal context As ITypeDescriptorContext) _
                  As StandardValuesCollection

    Return New StandardValuesCollection(New String() {"New File", _
                                                      "File1", _
                                                      "Document1"})
End Function 


//C#

public override StandardValuesCollection
                     GetStandardValues(ITypeDescriptorContext context) 
{
    return new StandardValuesCollection(new string[]{"New File", 
                                                     "File1", 
                                                     "Document1"});
}

(Optional) Wenn sie möchten, dass der Benutzer einen Wert eingeben kann, der nicht in der Dropdownliste enthalten ist, überschreiben Sie die GetStandardValuesExclusive-Methode , und geben Sie false zurück. Dadurch wird das Dropdownlistenformat im Wesentlichen in ein Kombinationsfeldformat geändert.

' Visual Basic

Public Overloads Overrides Function GetStandardValuesExclusive( _
               ByVal context As ITypeDescriptorContext) As Boolean
    Return False
End Function


//C#

public override bool GetStandardValuesExclusive(
                           ITypeDescriptorContext context) 
{
    return false;
}

Nachdem Sie nun über eine eigene Typkonverterklasse zum Anzeigen einer Dropdownliste verfügen, müssen Sie das Ziel identifizieren, das es verwenden wird. In diesem Fall ist das Ziel die DefaultFileName -Eigenschaft, da der Typkonverter spezifisch für die -Eigenschaft ist. Wenden Sie das TypeConverterAttribute auf die Zieleigenschaft an.

' Visual Basic

' The TypeConverter attribute applied to the DefaultFileName property.
<TypeConverter(GetType(FileNameConverter)),_
 CategoryAttribute("Document Settings")> _
Public Property DefaultFileName() As String
    Get
        Return _defaultFileName
    End Get
    Set(ByVal Value As String)
        _defaultFileName = Value
    End Set
End Property


//C#

// The TypeConverter attribute applied to the DefaultFileName property.
 [TypeConverter(typeof(FileNameConverter)),
 CategoryAttribute("Document Settings")]
public string DefaultFileName
{
    get{ return defaultFileName; }
    set{ defaultFileName = value; }
}

Kompilieren Sie die Optionsfensteranwendung, und führen Sie sie erneut aus. Der folgende Screenshot zeigt, wie das Optionsfenster jetzt aussehen sollte. Beachten Sie, wie die DefaultFileName -Eigenschaft angezeigt wird.

Abbildung 7. Anzeigen einer Dropdown-Domänenliste im PropertyGrid

Bereitstellen einer benutzerdefinierten Benutzeroberfläche für Ihre Eigenschaften

Wie bereits erwähnt, verwenden die .NET Framework-Typen die Klassen TypeConverter und UITypeEditor (zusammen mit anderen Klassen), um PropertyGrid-Bearbeitungsunterstützung bereitzustellen. Im Abschnitt Unterstützung für benutzerdefinierte Typen wurde die Verwendung eines TypeConverters behandelt. Sie können auch die UITypeEditor-Klasse verwenden, um Ihre eigene PropertyGrid-Anpassung durchzuführen.

Sie können eine kleine grafische Darstellung zusammen mit dem Eigenschaftswert im PropertyGrid bereitstellen, ähnlich wie für die Klassen Image und Color . Um dies für Ihre Anpassung zu tun, erben Sie von UITypeEditor, überschreiben Sie GetPaintValueSupported , und geben Sie true zurück. Überschreiben Sie als Nächstes die UITypeEditor.PaintValue-Methode , und verwenden Sie in ihrer Methode den Parameter PaintValueEventArgs.Graphics , um Ihre Grafik zu zeichnen. Wenden Sie schließlich das Editor-Attribut auf die Klasse oder Eigenschaft an, die Ihre UITypeEditor-Klasse verwendet.

Der folgende Screenshot zeigt, wie Ihre Ergebnisse aussehen könnten.

Abbildung 8. Anzeigen einer benutzerdefinierten Grafik für eine Eigenschaft im PropertyGrid

Sie können auch ein eigenes Dropdownlistensteuerelement bereitstellen, ähnlich dem, was die Control.Dock-Eigenschaft verwendet, um dem Benutzer andocken zu können. Erben Sie dazu von UITypeEditor, überschreiben Sie GetEditStyle und geben einen UITypeEditorEditStyle-Enumerationswert zurück, z. B. DropDown. Ihr benutzerdefiniertes Dropdown-Steuerelement muss von Control oder einer von Control abgeleiteten Klasse (z. B. UserControl) erben. Überschreiben Sie als Nächstes die UITypeEditor.EditValue-Methode . Verwenden Sie den IServiceProvider-Parameter, um die IServiceProvider.GetService-Methode aufzurufen, um eine IWindowsFormsEditorService-instance abzurufen. Rufen Sie schließlich die IWindowsFormsEditorService.DropDownControl-Methode auf, um Ihr benutzerdefiniertes Dropdownlistensteuerelement anzuzeigen. Denken Sie daran, das Editor-Attribut auf die Klasse oder Eigenschaft anzuwenden, die Ihre UITypeEditor-Klasse verwendet.

Der folgende Screenshot zeigt, wie Ihre Ergebnisse aussehen könnten.

Abbildung 9. Anzeigen eines benutzerdefinierten Dropdownsteuerelements für eine Eigenschaft im PropertyGrid

Zusätzlich zur Verwendung der TypeEditor - und UITypeEditor-Klassen kann PropertyGrid auch angepasst werden, um zusätzliche Eigenschaftenregisterkarten anzuzeigen. Eigenschaftenregisterkarten erben von der PropertyTab-Klasse . Möglicherweise haben Sie ein benutzerdefiniertes PropertyTab gesehen, wenn Sie den Eigenschaftenbrowser in Microsoft Visual C# ™ .NET verwendet haben. Die Registerkarte Ereignisse (die Schaltfläche mit Blitz) ist ein benutzerdefiniertes Eigenschaftenregister. Der folgende Screenshot zeigt ein weiteres Beispiel für ein benutzerdefiniertes Eigenschaftenregister unten . Dieses Eigenschaftenregister bietet die Möglichkeit, ein benutzerdefiniertes Schaltflächen-Shape durch Bearbeiten der Begrenzungspunkte einer Schaltfläche zu erstellen.

Abbildung 10. Anzeigen einer benutzerdefinierten Registerkarte im PropertyGrid

Weitere Informationen zur Verwendung der UITypeEditor-Klasse zum Anpassen von PropertyGrid sowie Codebeispiele der oben genannten benutzerdefinierten Benutzeroberflächen finden Sie im Artikel Make Your Components Really RAD with Visual Studio .NET Property Browser von Shawn Burke.

Zusammenfassung

Das vom .NET Framework bereitgestellte ProperyGrid-Steuerelement bietet eine umfassende Bearbeitungserfahrung, mit der Sie Ihre Benutzeroberfläche verbessern können. Mit Ihrem neuen Wissen darüber, wie einfach propertyGrid angepasst werden kann, verwenden Sie PropertyGrid in Allen Ihren Anwendungen. Da der Visual Studio .NET-Eigenschaftenbrowser auf PropertyGrid basiert, können Sie diese Techniken auch verwenden, um eine umfassendere Entwurfszeiterfahrung bereitzustellen.

Nutzen des .NET Framework PropertyGrid-Steuerelements

Inhalte

Einführung in das PropertyGrid-Steuerelement

Erstellen eines PropertyGrid-Steuerelements

Verwenden des PropertyGrid-Steuerelements

Auswählen eines Objekts

Anpassen des PropertyGrid-Steuerelements

Ändern visueller Aspekte des PropertyGrid

Ändern der Anzeige von Eigenschaften

Anzeigen komplexer Eigenschaften

Unterstützung für bereitgestellte Typen

Unterstützung für benutzerdefinierte Typen

Hinzufügen von Unterstützung für erweiterbare Eigenschaften

So stellen Sie erweiterbare Objektunterstützung bereit

Hinzufügen von Domänenlisten und Unterstützung für einfache Dropdowneigenschaften

So stellen Sie einfache Unterstützung für Dropdowneigenschaften bereit

Bereitstellen einer benutzerdefinierten Benutzeroberfläche für Ihre Eigenschaften

Zusammenfassung

Zusätzliche Ressourcen