Optimale Nutzung des PropertyGrid-Steuerelements in .NET Framework

Veröffentlicht: 07. Aug 2002 | Aktualisiert: 22. Jun 2004
Von Mark Rideout

Dieser Artikel erläutert das PropertyGrid-Steuerelement im Microsoft .NET Framework und zeigt, wie Sie es für Ihre Anwendung anpassen können.

Betrifft:
Microsoft® .NET® Framework
Microsoft® Visual Studio® .NET

Auf dieser Seite

Einführung in das "PropertyGrid"-Steuerelement Einführung in das "PropertyGrid"-Steuerelement
Anlegen eines "PropertyGrid"-Steuerelements Anlegen eines "PropertyGrid"-Steuerelements
Verwendung des "PropertyGrid"-Steuerelements Verwendung des "PropertyGrid"-Steuerelements
Auswählen von Objekten Auswählen von Objekten
Anpassen des "PropertyGrid"-Steuerelements Anpassen des "PropertyGrid"-Steuerelements
Ändern visueller Aspekte von "PropertyGrid" Ändern visueller Aspekte von "PropertyGrid"
Ändern der Anzeige von Eigenschaften Ändern der Anzeige von Eigenschaften
Anzeigen komplexer Eigenschaften Anzeigen komplexer Eigenschaften
Unterstützung für bereitgestellte Typen Unterstützung für bereitgestellte Typen
Unterstützung für benutzerdefinierte Typen Unterstützung für benutzerdefinierte Typen
Anlegen einer benutzerdefinierten Oberfläche für Ihre Eigenschaften Anlegen einer benutzerdefinierten Oberfläche für Ihre Eigenschaften
Schlussfolgerung  Schlussfolgerung

Einführung in das "PropertyGrid"-Steuerelement

Wenn Sie mit Microsoft® Visual Basic® oder Microsoft Visual Studio .NET gearbeitet haben, kennen Sie den Eigenschaftenbrowser, um die Eigenschaften eines oder mehrerer Objekte durchzublättern, anzuzeigen oder zu bearbeiten. Das PropertyGrid-Steuerelement in .NET Framework ist der zentrale Eigenschaftenbrowser, der in Visual Studio .NET verwendet wird.

Das PropertyGrid-Steuerelement zeigt Eigenschaften für beliebige Objekte oder Typen an und ruft die Eigenschaften von Elementen vorwiegend unter Verwendung von Reflektion ab. ("Reflektion" bezeichnet eine Methode, die Typinformationen zur Laufzeit liefert.)
Der folgende Screenshot zeigt die Darstellung eines PropertyGrid-Steuerelements auf einem Formular.

Bild01

Abbildung 1. "PropertyGrid"-Steuerelement auf einem Formular

Das PropertyGrid-Steuerelement enthält die folgenden Komponenten:

  • Eigenschaften

  • Erweiterbare Eigenschaften

  • Titel für Eigenschaftenkategorien

  • Eigenschaftenbeschreibungen

  • Eigenschaften-Editoren

  • Eigenschaftenregisterkarten

  • Befehlsfenster (zeigt die Designerverben an, die vom Designer eines Steuerelements zur Verfügung gestellt werden)

Anlegen eines "PropertyGrid"-Steuerelements

Um ein PropertyGrid-Steuerelement mit Visual Studio .NET anzulegen, müssen Sie das PropertyGrid-Steuerelement zunächst der Toolbox hinzufügen, da dieses nicht standardmäß;ig enthalten ist. Klicken Sie im Menü Extras auf Toolbox anpassen. Öffnen Sie in diesem Dialogfeld die Registerkarte .NET Framework-Komponenten, und wählen Sie anschließ;end PropertyGrid aus.

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

Der folgende Code zeigt, wie ein PropertyGrid-Steuerelement erstellt und dem Formular hinzugefügt wird.

' 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 = "Optionen-Dialogfeld"
   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 = "Optionen-Dialogfeld";
   }
   [STAThread]
   static void Main() 
   {
      Application.Run(new OptionsDialog());
   }
}

Verwendung des "PropertyGrid"-Steuerelements

Es gibt eine Vielzahl von Stellen in einer Anwendung, an denen Sie bessere Bearbeitungsmöglichkeiten zur Verfügung stellen können, indem Benutzer mit einem PropertyGrid-Steuerelement interagieren. Ein Beispiel ist eine Anwendung, die über mehrere "Einstellungen" oder Optionen verfügt (einige davon komplex), die Benutzer festlegen können. Für die Darstellung dieser Optionen könnten Optionsfelder, Kombinationsfelder oder Textfelder verwendet werden.

Im Gegensatz dazu erläutert dieser Artikel die Verwendung eines PropertyGrid-Steuerelements, um ein Optionenfenster für das Festlegen von Anwendungsoptionen zu erzeugen. Das oben erstellte OptionsDialog-Formular bildet die Grundlage für das Optionenfenster. Sie legen nun eine Klasse mit der Bezeichnung AppSettings an, die alle Eigenschaften enthält, die den Anwendungseinstellungen zugeordnet werden. Die Einstellungen lassen sich viel einfacher verwalten, wenn Sie eine separate Klasse anlegen, anstatt einzelne Variablen zu verwenden.

' Visual Basic
Public Class AppSettings
    Private _saveOnClose As Boolean = True
    Private _greetingText As String = "Willkommen bei Ihrer Anwendung!"
    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 = "Willkommen bei Ihrer Anwendung!";
    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; }
    }
}

Da das PropertyGrid-Steuerelement diese Klasse verändert, fügen Sie die Klassendefinition dem Anwendungsprojekt hinzu, entweder in einer neuen Datei oder am Ende des Quellcodes für das Formular.

Auswählen von Objekten

Um zu kennzeichnen, was das PropertyGrid-Steuerelement anzeigt, setzen Sie die PropertyGrid.SelectedObject-Eigenschaft auf eine Objektinstanz. Das PropertyGrid-Steuerelement kümmert sich um den Rest. Bei jedem Setzen von SelectedObject aktualisiert PropertyGrid die angezeigten Eigenschaften.

Dies bietet eine einfache Möglichkeit, um das Aktualisieren von Eigenschaften zu erzwingen oder zwischen Objekten zur Laufzeit zu wechseln. Für die Aktualisierung von Eigenschaften können Sie auch die PropertyGrid.Refresh-Methode aufrufen.

Fahren Sie fort, indem Sie den Code im OptionsDialog-Konstruktor aktualisieren, um ein AppSettings-Objekt anzulegen, und legen Sie dafür 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 = "Optionen-Dialogfeld"
      ' AppSettings-Klasse erstellen und im PropertyGrid anzeigen. 
      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 = "Optionen-Dialogfeld";
      // AppSettings-Klasse erstellen und im PropertyGrid anzeigen. 
      AppSettings appset = new AppSettings();
      OptionsPropertyGrid.SelectedObject = appset;
   }

Kompilieren Sie die Anwendung, und führen Sie diese aus. Der folgende Screenshot zeigt, wie dies aussehen sollte.

Bild02

Abbildung 2. Die "AppSettings"-Klasse ist im "PropertyGrid" ausgewählt

Anpassen des "PropertyGrid"-Steuerelements

Sie können einige visuelle Aspekte des PropertyGrid-Steuerelements an Ihre Bedürfnisse anpassen. So möchten Sie beispielsweise die Darstellung einiger Eigenschaften ändern, oder sogar einige Eigenschaften ausblenden. Wie gut lässt sich also das PropertyGrid-Steuerelement anpassen?

Ändern visueller Aspekte von "PropertyGrid"

Eine Vielzahl der visuellen Aspekte des PropertyGrid-Steuerelements lassen sich anpassen. Hier eine Auswahl:

  • Ändern der Hintergrundfarbe bzw. der Schriftartfarbe oder Ausblenden des Beschreibungsbereichs über die HelpBackColor-, HelpForeColor- und HelpVisible-Eigenschaften.

  • Ausblenden der Symbolleiste über die ToolbarVisible-Eigenschaft, Ändern ihrer Farbe über die BackColor-Eigenschaft und Anzeigen groß;er Symbolleistenschaltflächen über die LargeButtons-Eigenschaft.

  • Alphabetisches Sortieren und Kategorisieren der Eigenschaften mit der PropertySort-Eigenschaft.

  • Ändern der Aufteilungsfarbe über die BackColor-Eigenschaft.

  • Ändern der Rasterlinien und -ränder über die LineColor-Eigenschaft.

Für das Optionenfenster in diesem Beispiel ist keine Symbolleiste erforderlich, weshalb Sie ToolbarVisible auf den Wert FALSE setzen können. Lassen Sie die anderen Standardeinstellungen unverändert.

Ändern der Anzeige von Eigenschaften

Wenn Sie die Anzeige einiger Eigenschaften ändern möchten, können Sie diesen unterschiedliche Attribute zuweisen. Bei Attributen handelt es sich um deklarative Tags zur Kommentierung von Programmierelementen, z.B. Typen, Felder, Methoden und Eigenschaften, die zur Laufzeit unter Verwendung von Reflektion abgerufen werden können. Hier eine Auswahl:

  • DescriptionAttribute - Dieses Attribut legt den Text für die Eigenschaft fest, der im Beschreibungs-Hilfebereich unter den Eigenschaften angezeigt wird. Dies ist eine einfache Methode, um Hilfetext für die aktive Eigenschaft (die Eigenschaft mit Fokus) zur Verfügung zu stellen. Weisen Sie dieses Attribut der MaxRepeatRate-Eigenschaft zu.

  • CategoryAttribute - Diese Eigenschaft legt die Kategorie fest, unter der sich die Eigenschaft im Raster befindet. Dies ist nützlich, wenn Sie eine Eigenschaft nach einem Kategorienamen gruppieren möchten. Verfügt eine Eigenschaft nicht über die Angabe einer Kategorie, wird dieser die Misc-Kategorie zugewiesen. Weisen Sie dieses Attribut allen Eigenschaften zu.

  • BrowsableAttribute - Dieses Attribut 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 Public-Eigenschaft angezeigt. Weisen Sie dieses Attribut der SettingsChanged-Eigenschaft zu.

  • ReadOnlyAttribute - Dieses Attribut gibt an, ob die Eigenschaft schreibgeschützt ist. Dies ist nützlich, wenn Sie die Bearbeitung einer Eigenschaft im Raster verhindern möchten. Standardmäß;ig kann eine Public-Eigenschaft mit Get- und Set-Accesorfunktionen im Raster bearbeitet werden. Weisen Sie dieses Attribut der AppVersion-Eigenschaft zu.

  • DefaultValueAttribute - Diese Eigenschaft gibt den Standardwert der Eigenschaft an. Dies ist nützlich, wenn Sie einen Standardwert für eine Eigenschaft angeben möchten und erst später entscheiden, ob sich der Wert der Eigenschaft vom Standardwert unterscheidet. Weisen Sie dieses Attribut allen Eigenschaften zu.

  • DefaultPropertyAttribute - Dieses Attribut gibt die Standardeigenschaft für die Klasse an. Die Standardeigenschaft für die Klasse erhält zuerst den Fokus, sobald die Klasse im Raster ausgewählt wird. Weisen Sie dieses Attribut der AppSettings-Klasse zu.

Weisen Sie nun einige dieser Attribute der AppSettings-Klasse zu, um die Art und Weise zu verändern, wie Eigenschaften im PropertyGrid angezeigt werden.

' Visual Basic
<DefaultPropertyAttribute("SaveOnClose")> _
Public Class AppSettings
    Private _saveOnClose As Boolean = True
    Private _greetingText As String = "Willkommen bei Ihrer Anwendung!"
    Private _maxRepeatRate As Integer = 10
    Private _itemsInMRU As Integer = 4
    Private _settingsChanged As Boolean = False
    Private _appVersion As String = "1.0"
    <CategoryAttribute("Dokumenteinstellungen"), _
     DefaultValueAttribute(True)> _
    Public Property SaveOnClose() As Boolean
        Get
            Return _saveOnClose
        End Get
        Set(ByVal Value As Boolean)
            SaveOnClose = Value
        End Set
    End Property
    <CategoryAttribute("Globale Einstellungen"), _
    ReadOnlyAttribute(True), _
    DefaultValueAttribute("Willkommen bei Ihrer Anwendung!")> _
    Public Property GreetingText() As String
        Get
            Return _greetingText
        End Get
        Set(ByVal Value As String)
            _greetingText = Value
        End Set
    End Property
    <CategoryAttribute("Globale Einstellungen"), _
    DefaultValueAttribute(4)> _
    Public Property ItemsInMRUList() As Integer
        Get
            Return _itemsInMRU
        End Get
        Set(ByVal Value As Integer)
            _itemsInMRU = Value
        End Set
    End Property
    <DescriptionAttribute("Die Frequenz (in Millisekunden), in der der Text wiederholt wird."), _
    CategoryAttribute("Globale Einstellungen"), _
    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 = "Willkommen bei Ihrer Anwendung!";
    private int maxRepeatRate = 10;
    private int itemsInMRU = 4;
    private bool settingsChanged = false;
    private string appVersion = "1.0";
    [CategoryAttribute("Dokumenteinstellungen"),
    DefaultValueAttribute(true)]
    public bool SaveOnClose
    {
        get { return saveOnClose; }
        set { saveOnClose = value;}
    }
    [CategoryAttribute("Globale Einstellungen"),
    ReadOnlyAttribute(true),
    DefaultValueAttribute("Willkommen bei Ihrer Anwendung!")] 
    public string GreetingText
    {
        get { return greetingText; }
        set { greetingText = value; }
    }
    [CategoryAttribute("Globale Einstellungen"),
    DefaultValueAttribute(4)]
    public int ItemsInMRUList
    {
        get { return itemsInMRU; }
        set { itemsInMRU = value; }
    }
    [DescriptionAttribute("Die Frequenz (in Millisekunden), in der der Text wiederholt wird."),
    CategoryAttribute("Globale Einstellungen"),
    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 Sie diese Attribute der AppSettings-Klasse zugewiesen haben, kompilieren Sie die Anwendung, und führen Sie diese aus. Der folgende Screenshot zeigt, wie dies aussehen sollte.

Bild03

Abbildung 3. Anzeige der Eigenschaften mit Kategorien und Standardwerten im "PropertyGrid"

Nachdem Sie einige Zeit mit dieser Version des Optionenfensters gearbeitet haben, werden Sie Folgendes bemerken:

  • Die SaveOnClose-Eigenschaft erhält den Fokus, sobald das Fenster angezeigt wird.

  • Die MaxRepeatRate-Eigenschaft zeigt bei Auswahl im Beschreibungs-Hilfebereich folgenden Text an: "Die Frequenz (in Millisekunden), in der der Text wiederholt wird."

  • Die SaveOnClose-Eigenschaft wird unter der Kategorie Dokumenteinstellungen angezeigt. Die anderen Eigenschaften werden unter zwei weiteren Kategorien mit der Bezeichnung Globale Einstellungen und Version angezeigt.

  • Die SettingsChanged-Eigenschaft wird nicht mehr angezeigt.

  • Die AppVersion-Eigenschaft ist schreibgeschützt. Schreibgeschützte Eigenschaften werden mit abgeblendetem Text angezeigt.

  • Sobald die SaveOnClose-Eigenschaft einen anderen Wert als TRUE hat, wird sie in Fettschrift angezeigt. Das PropertyGrid-Steuerelement kennzeichnet Eigenschaften, die keinen Standardwert besitzen, mit Fettschrift.

Anzeigen komplexer Eigenschaften

Bisher hat das Optionenfenster einfache Typen, wie etwa ganze Zahlen, boolesche Werte und Zeichenfolgen angezeigt. Wie sieht es mit komplexeren Typen aus, z.B. wenn Ihre Anwendung Eigenschaften wie Fenstergröß;e, Dokumentschriftart und Symbolleistenfarbe verwalten muss? Einige Datentypen im .NET Framework verfügen über spezielle Anzeigefunktionen, die eine verbesserte Anwendung im PropertyGrid-Steuerelement ermöglichen.

Unterstützung für bereitgestellte Typen

Aktualisieren Sie zunächst die AppSettings-Klasse, um neue Eigenschaften für die Fenstergröß;e (Size-Typ), Fensterschriftart (Font-Typ) und die Symbolleistenfarbe (Color-Typ) hinzuzufügen.

' Visual Basic
<DefaultPropertyAttribute("SaveOnClose")> _
Public Class AppSettings
    Private _saveOnClose As Boolean = True
    Private _greetingText As String = "Willkommen bei Ihrer Anwendung!"
    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("Dokumenteinstellungen"), _
     DefaultValueAttribute(True)> _
    Public Property SaveOnClose() As Boolean
        Get
            Return _saveOnClose
        End Get
        Set(ByVal Value As Boolean)
            SaveOnClose = Value
        End Set
    End Property
    <CategoryAttribute("Dokumenteinstellungen")> _
    Public Property WindowSize() As Size
        Get
            Return _windowSize
        End Get
        Set(ByVal Value As Size)
            _windowSize = Value
        End Set
    End Property
    <CategoryAttribute("Dokumenteinstellungen")> _
    Public Property WindowFont() As Font
        Get
            Return _windowFont
        End Get
        Set(ByVal Value As Font)
            _windowFont = Value
        End Set
    End Property
    <CategoryAttribute("Globale Einstellungen")> _
    Public Property ToolbarColor() As Color
        Get
            Return _toolbarColor
        End Get
        Set(ByVal Value As Color)
            _toolbarColor = Value
        End Set
    End Property
    <CategoryAttribute("Globale Einstellungen"), _
    ReadOnlyAttribute(True), _
    DefaultValueAttribute("Willkommen bei Ihrer Anwendung!")> _
    Public Property GreetingText() As String
        Get
            Return _greetingText
        End Get
        Set(ByVal Value As String)
            _greetingText = Value
        End Set
    End Property
    <CategoryAttribute("Globale Einstellungen"), _
    DefaultValueAttribute(4)> _
    Public Property ItemsInMRUList() As Integer
        Get
            Return _itemsInMRU
        End Get
        Set(ByVal Value As Integer)
            _itemsInMRU = Value
        End Set
    End Property
    <DescriptionAttribute("Die Frequenz (in Millisekunden), in der der Text wiederholt wird.") , _
    CategoryAttribute("Globale Einstellungen"), _
    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 = "Willkommen bei Ihrer Anwendung!";
    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("Dokumenteinstellungen"),
    DefaultValueAttribute(true)]
    public bool SaveOnClose
    {
        get { return saveOnClose; }
        set { saveOnClose = value;}
    }
    [CategoryAttribute("Dokumenteinstellungen")]
    public Size WindowSize 
    {
        get { return windowSize; }
        set { windowSize = value;}
    }
    [CategoryAttribute("Dokumenteinstellungen")]
    public Font WindowFont 
    {
        get {return windowFont; }
        set { windowFont = value;}
    }
    [CategoryAttribute("Globale Einstellungen")]
    public Color ToolbarColor
    {
        get { return toolbarColor; }
        set { toolbarColor = value; }
    }
    [CategoryAttribute("Globale Einstellungen"),
    ReadOnlyAttribute(true),
    DefaultValueAttribute("Willkommen bei Ihrer Anwendung!")]
    public string GreetingText
    {
        get { return greetingText; }
        set { greetingText = value; }
    }
    [CategoryAttribute("Globale Einstellungen"),
    DefaultValueAttribute(4)]
    public int ItemsInMRUList
    {
        get { return itemsInMRU; }
        set { itemsInMRU = value; }
    }
    [DescriptionAttribute("Die Frequenz (in Millisekunden), in der der Text wiederholt wird."),
    CategoryAttribute("Globale Einstellungen"),
    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 im PropertyGrid-Steuerelement aussehen.

Bild04

Abbildung 4. Anzeige von .NET Framework-Datentypen im "PropertyGrid"-Steuerelement

Beachten Sie, dass die WindowFont-Eigenschaft über eine Ellipse-Schaltfläche ("...") verfügt, mit der ein Dialogfeld zur Schriftartauswahl angezeigt werden kann. Auß;erdem kann die Eigenschaft erweitert werden, um weitere Font-Eigenschaften anzuzeigen. Einige der Font-Eigenschaften enthalten eine Dropdownliste mit Werten und Details über die Schriftart.

Die WindowSize-Eigenschaft kann erweitert werden, um weitere Eigenschaften des Size-Typs anzuzeigen. Beachten Sie schließ;lich, dass die ToolbarColor-Eigenschaft über eine Vorschau der ausgewählten Farbe verfügt sowie über eine benutzerdefinierte Dropdownliste zur Auswahl unterschiedlicher Farben. Für diese und weitere Datentypen liefert das .NET Framework zusätzliche Klassen, um die Bearbeitung im PropertyGrid-Steuerelement zu vereinfachen.

Unterstützung für benutzerdefinierte Typen

Sie fügen nun der AppSettings-Klasse zwei weitere Eigenschaften hinzu, eine mit der Bezeichnung DefaultFileName und eine weitere mit der Bezeichnung SpellCheckOptions. Die DefaultFileName-Eigenschaft ermittelt oder legt eine Zeichenfolge fest, und die SpellCheckOptions-Eigenschaft ermittelt oder legt eine Instanz der SpellingOptions-Klasse fest.
Bei SpellingOptions handelt es sich um eine neue Klasse, die Rechtschreibprüfungs-Eigenschaften der Anwendung verwaltet. Es gibt keine allgemeingültige Regel über den Zeitpunkt der Erstellung einer separaten Klasse zur Verwaltung der Eigenschaften eines Objekts. Vielmehr hängt dieser vom allgemeinen Klassenentwurf ab. Fügen Sie Ihrem Anwendungsprojekt die SpellingOptions-Klasse hinzu, entweder in einer neuen Datei oder am Ende des Quellcodes für das Formular.

' Visual Basic
<DescriptionAttribute("Erweitern, um die Rechtschreiboptionen für die Anwendung anzuzeigen.")> _
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("Erweitern, um die Rechtschreiboptionen für die Anwendung anzuzeigen.")]
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 Optionenfenster-Anwendung, und führen Sie sie erneut aus. Der folgende Screenshot zeigt, wie das Optionenfenster jetzt aussehen sollte.

Bild05

Abbildung 5. Anzeige von benutzerdefinierten Datentypen ohne einen Typkonverter im "PropertyGrid"-Steuerelement

Beachten Sie die Darstellung der SpellcheckOptions-Eigenschaft. Im Gegensatz zu .NET Framework-Typen lässt sie sich nicht erweitern und enthält keine benutzerdefinierte Zeichenfolgendarstellung. Angenommen, Sie möchten für Ihre eigenen komplexen Typen die gleichen Bearbeitungsmöglichkeiten nutzen, über die .NET Framework-Typen verfügen. Die .NET Framework-Typen verwenden die TypeConverter- und UITypeEditor-Klassen für den Groß;teil der Bearbeitungsunterstützung des PropertyGrid-Steuerelements, und Sie können diese ebenfalls nutzen.

Hinzufügen von Unterstützung für erweiterbare Eigenschaften
Damit das PropertyGrid-Steuerelement die SpellingOptions-Eigenschaft erweitert, müssen Sie einen TypeConverter erstellen. Ein TypeConverter bietet die Möglichkeit, von einem Typ in einen anderen zu konvertieren. Das PropertyGrid-Steuerelement verwendet den TypeConverter, um Ihren Objekttyp in eine Zeichenfolge zu konvertieren, mit dem der Objektwert im Raster konvertiert wird. Während der Bearbeitung konvertiert der TypeConverter die Zeichenfolge wieder zurück in Ihren Objekttyp. Das .NET Framework vereinfacht diesen Vorgang mit der ExpandableObjectConverter-Klasse.

So ermöglichen Sie Unterstützung für erweiterbare Objekte

  1. Erstellen Sie eine Klasse, die von ExpandableObjectConverter vererbt wird.

    ' Visual Basic
    Public Class SpellingOptionsConverter
        Inherits ExpandableObjectConverter
    End Class
    //C#
    public class SpellingOptionsConverter:ExpandableObjectConverter 
    {  }
    
  2. Überschreiben Sie die CanConvertTo-Methode, und geben Sie TRUE zurück, falls der destinationType-Parameter vom selben Typ ist wie die Klasse, die diesen Typkonverter verwendet (die SpellingOptions-Klasse in Ihrem Beispiel). Geben Sie andernfalls den Wert der CanConvertTo-Basisklassenmethode zurück.

    ' 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.CanConvertTo(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);
    }
    
  3. Überschreiben Sie die ConvertTo-Methode, und stellen Sie sicher, dass der destinationType-Parameter eine Zeichenfolge ist, und der Wert vom selben Typ ist wie die Klasse, die diesen Typkonverter verwendet (die SpellingOptions-Klasse in unserem Beispiel). Falls in beiden Fällen der Wert FALSE ist, geben Sie den Wert der ConvertTo-Basisklassenmethode zurück.
    Geben Sie andernfalls eine Zeichenfolgendarstellung des Wertobjekts zurück. In der Zeichenfolgendarstellung muss jede Eigenschaft Ihrer Klasse mit einem eindeutigen Trennzeichen abgegrenzt werden. Da die gesamte Zeichenfolge im PropertyGrid-Steuerelement angezeigt wird, sollten Sie ein Trennzeichen wählen, das nicht von der Lesbarkeit ablenkt. In der Regel eignen sich Kommata 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 "Überprüfung während der Eingabe: " & so.SpellCheckWhileTyping & _
                   ", GROSSBUCHSTABEN überprüfen: " & so.SpellCheckCAPS & _
                   ", Korrekturen vorschlagen: " & 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 "Überprüfung während der Eingabe:" + so.SpellCheckWhileTyping + 
    ", GROSSBUCHSTABEN überprüfen: " + so.SpellCheckCAPS +
    ", Korrekturen vorschlagen: " + so.SuggestCorrections;
    }
    return base.ConvertTo(context, culture, value, destinationType);
    }
    
  4. (Optional) Sie können die Bearbeitung der Zeichenfolgendarstellung des Objekts im Raster aktivieren, indem Sie angeben, dass Ihr Typkonverter Zeichenfolgen konvertieren kann. Überschreiben Sie dafür zunächst die CanConvertFrom-Methode, und geben Sie den Wert TRUE zurück, falls der Quell-Typ-Parameter vom Typ String ist. Geben Sie andernfalls den Wert der CanConvertFrom-Basisklassenmethode zurück.

    ' 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);
    }
    
  5. Um die Bearbeitung der Basisklasse des Objekts zu aktivieren, müssen Sie ebenfalls die ConvertFrom-Methode überschreiben und sicherstellen, dass der Wertparameter eine Zeichenfolge ist. Falls dieser keine Zeichenfolge ist, geben Sie den Wert der ConvertFrom-Basisklassenmethode zurück. Geben Sie andernfalls eine neue Instanz Ihrer Klasse (der SpellingOptions-Klasse in unseren Beispiel) auf der Basis des Wertparameters zurück. Sie müssen die Werte für jede Eigenschaft der Klasse anhand dieses Wertparameters analysieren. Bei der Durchführung der Analyse ist es hilfreich, wenn Sie das Format des Trennzeichens kennen, das in der ConvertTo-Methode erstellt wurde.

    ' 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( _
                    "'" & CStr(Wert) & kann nicht _ 
                                      "' in Typ SpellingOptions konvertiert werden")
            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(
                    " '" + (string)Wert + kann nicht 
                                       "' in Typ SpellingOptions konvertiert werden");
            }
        }  
        return base.ConvertFrom(context, culture, value);
    }
    
  6. Nachdem Sie nun über eine Typkonverterklasse verfügen, müssen Sie die Zielklasse identifizieren, die diese verwendet. Sie erledigen dies, indem Sie das TypeConverterAttribute der Zielklasse zuweisen (der SpellingOptions-Klasse in unserem Beispiel).

    ' Visual Basic
    ' Das TypeConverter-Attribut auf die SpellingOptions-Klasse angewendet.
    <TypeConverter(GetType(SpellingOptionsConverter)), _
    DescriptionAttribute("Erweitern, um die Rechtschreiboptionen für die Anwendung anzuzeigen.")> _
    Public Class SpellingOptions
       ...
    End Class
    //C#
    // Das TypeConverter-Attribut auf die SpellingOptions-Klasse angewendet 
     [TypeConverterAttribute(typeof(SpellingOptionsConverter)),
    DescriptionAttribute("Erweitern, um die Rechtschreiboptionen für die Anwendung anzuzeigen.")]
    public class SpellingOptions{ ... }
    

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

Bild06

Abbildung 6. Anzeige von benutzerdefinierten Datentypen mit einem Typkonverter im "PropertyGrid"-Steuerelement

Anmerkung Wenn Sie nur die Unterstützung für erweiterbare Objekte wünschen, jedoch nicht die benutzerdefinierte Zeichenfolgendarstellung, können Sie Ihrer Klasse einfach das TypeConverterAttribute zuweisen. Geben Sie ExpandableObjectConverter als den Typkonvertertyp an.

Hinzufügen von Unterstützung für Domänenlisten und einfache Dropdowneigenschaften
Für Eigenschaften, die eine Enumeration auf der Basis des Enum-Typs zurückgeben, zeigt das PropertyGrid-Steuerelement automatisch die Enumerationswerte in einer Dropdownliste an. Der EnumConverter stellt diese Funktionalität ebenfalls zur Verfügung.

Für Ihre eigenen Eigenschaften möchten Sie eventuell Benutzern eine Liste mit gültigen Werten zur Verfügung stellen, die manchmal als Auswahlliste oder Domänenliste bezeichnet wird und Typen enthält, die nicht auf Enum basieren. Dies ist immer dann der Fall, wenn die Domänenwerte zur Laufzeit nicht bekannt sind, oder wenn sich die Werte ändern können.

Ändern Sie das Optionenfenster, um eine Domänenliste mit Standarddateinamen zur Verfügung zu stellen, aus denen Benutzer auswählen können. Sie haben bereits die DefaultFileName-Eigenschaft der AppSettings-Klasse hinzugefügt. Der nächste Schritt ist die Darstellung der Dropdownliste im PropertyGrid-Steuerelement, um die Domänenliste zur Verfügung zu stellen.

Unterstützung für einfache Dropdown-Eigenschaft

  1. Legen Sie Sie eine Klasse an, die von einer Typkonverterklasse vererbt wird. Da die DefaultFileName-Eigenschaft vom Typ String ist, kann von StringConverter vererbt werden. Falls ein Typkonverter für den Typ Ihrer Eigenschaft nicht existiert, kann von TypeConverter vererbt werden. In diesem Fall ist dies jedoch nicht notwendig.

    ' Visual Basic
    Public Class FileNameConverter
        Inherits StringConverter
    End Class
    //C#
    public class FileNameConverter: StringConverter 
    {  }
    

  2. Überschreiben Sie die GetStandardValuesSupported-Methode, und geben Sie TRUE zurück, um anzugeben, dass dieses Objekt eine Reihe von Standardwerten 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;
    }
    
  3. Überschreiben Sie die GetStandardValues-Methode, und geben Sie eine StandardValuesCollection-Auflistung zurück, die mit Ihren Standardwerten gefüllt ist. Eine Möglichkeit für die Erstellung einer StandardValuesCollection besteht darin, ein Array mit Werten im Konstruktor zur Verfügung zu stellen. Für die Optionenfenster-Anwendung können Sie ein Zeichenfolgen-Array verwenden, das mit den vorgegebenen Dateinamen gefüllt ist.

    ' Visual Basic
    Public Overloads Overrides Function GetStandardValues( _
                         ByVal context As ITypeDescriptorContext) _
                      As StandardValuesCollection
        Return New StandardValuesCollection(New String() {"Neue Datei", _
                                                          "Datei1", _
                                                          "Dokument1"})
    End Function 
    //C#
    public override StandardValuesCollection
                         GetStandardValues(ITypeDescriptorContext context) 
    {
        return new StandardValuesCollection(new string[]{"Neue Datei", 
                                                         "Datei1", 
                                                         "Dokument1"});
    } 
    
  4. (Optional) Falls Benutzer in der Lage sein sollen, einen Wert einzugeben, der sich nicht in der Dropdownliste befindet, überschreiben Sie die GetStandardValuesExclusive-Methode, und geben Sie FALSE zurück. Dadurch wird die Dropdownliste praktisch in ein Kombinationsfeld umgewandelt.

    ' 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;
    }
    
  5. Da Sie nun über Ihre eigene Typkonverterklasse für die Anzeige einer Dropdownliste verfügen, müssen Sie die Zielklasse identifizieren, die diese verwendet. In diesem Fall ist das Ziel die DefaultFileName-Eigenschaft, da der Typkonverter spezifisch für die Eigenschaft gilt. Wenden Sie das TypeConverterAttribute auf die Zieleigenschaft an.

    ' Visual Basic
    ' Das TypeConverter-Attribut auf die DefaultFileName-Eigenschaft angewendet.
    <TypeConverter(GetType(FileNameConverter)), _
     CategoryAttribute("Dokumenteinstellungen")> _
    Public Property DefaultFileName() As String
        Get
            Return _defaultFileName
        End Get
        Set(ByVal Value As String)
            _defaultFileName = Value
        End Set
    End Property
    //C#
    // Das TypeConverter-Attribut auf die DefaultFileName-Eigenschaft angewendet.
     [TypeConverter(typeof(FileNameConverter)), 
     CategoryAttribute("Dokumenteinstellungen")]
    public string DefaultFileName
    {
        get{ return defaultFileName; }
        set{ defaultFileName = value; }
    }
    

    Kompilieren Sie die Optionenfenster-Anwendung, und führen Sie sie erneut aus. Der folgende Screenshot zeigt, wie das Optionenfenster jetzt aussehen sollte. Beachten Sie die Darstellung der DefaultFileName-Eigenschaft.

Bild07

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

Anlegen einer benutzerdefinierten Oberfläche für Ihre Eigenschaften

Wie bereits erwähnt, verwenden die .NET-Framework-Typen die TypeConverter- und UITypeEditor-Klassen (zusammen mit anderen Klassen), um die Berarbeitungsunterstützung für das PropertyGrid-Steuerelement zur Verfügung zu stellen. Im Abschnitt Unterstützung für bereitgestellte Typen wurde die Verwendung einer TypeConverter-Klasse untersucht. Sie können auch die UITypeEditor-Klasse verwenden, um Ihre eigene Anpassung des PropertyGrid-Steuerelements durchzuführen.
Sie haben die Möglichkeit, eine kleine grafische Darstellung zusammen mit der Eigenschaft im PropertyGrid-Steuerelement einzufügen, ähnlich wie dies bei den Image- und Color-Klassen der Fall ist. Um diese Funktion für Ihre Anpassung zu nutzen, vererben Sie UITypeEditor, überschreiben GetPaintValueSupported und geben TRUE zurück.

Überschreiben Sie als nächstes die UITypeEditor.PaintValue-Methode, und verwenden Sie in Ihrer Methode den PaintValueEventArgs.Graphics-Parameter zum Zeichnen Ihrer Grafik. Weisen Sie schließ;lich das Editor-Attribut der Klasse oder Eigenschaft zu, die Ihre UITypeEditor-Klasse verwendet.

Der folgende Screenshot zeigt, wie das Ergebnis aussehen könnte:

Bild08

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

Sie können auch Ihr eigenes Dropdownlisten-Steuerelement zur Verfügung stellen, das dem von der Control.Dock-Eigenschaft verwendeten ähnlich ist, um Benutzern eine Andockauswahl zu ermöglichen. Vererben Sie dazu UITypeEditor, überschreiben Sie GetEditStyle, und geben Sie einen UITypeEditorEditStyle-Enumerationswert zurück, z.B. DropDown.

Ihr benutzerdefiniertes Dropdownsteuerelement muss von Control oder einer von Control abgeleiteten Klasse (wie etwa UserControl) vererbt werden. Überschreiben Sie als nächstes die UITypeEditor.EditValue-Methode. Rufen Sie mit dem IServiceProvider-Parameter die IServiceProvider.GetService-Methode auf, um eine Instanz von IWindowsFormsEditorService zu erhalten. Rufen Sie schließ;lich die IWindowsFormsEditorService.DropDownControl-Methode auf, um Ihr benutzerdefiniertes Dropdownlisten-Steuerelement anzuzeigen. Denken Sie daran, das Editor-Attribut der Klasse oder Eigenschaft zuzuweisen, die Ihre UITypeEditor-Klasse verwendet.
Der folgende Screenshot zeigt, wie das Ergebnis aussehen könnte:

Bild09

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

Neben Verwendung der TypeEditor- und UITypeEditor-Klassen kann PropertyGrid auch für die Anzeige zusätzlicher Eigenschaftenregisterkarten angepasst werden. Eigenschaftenregisterkarten werden von der PropertyTab-Klasse vererbt. Sie haben eventuell bereits ein benutzerdefiniertes PropertyTab-Steuerelement gesehen, wenn Sie den Eigenschaftenbrowser in Microsoft Visual C#T .NET verwendet haben - die Registerkarte Ereignisse (die Schaltfläche mit dem Blitzsymbol) ist ein benutzerdefiniertes PropertyTab-Steuerelement. Der nachfolgende Screenshot zeigt ein weiteres Beispiel eines benutzerdefinierten PropertyTab-Steuerelements. Diese Art von PropertyTab bietet die Möglichkeit zur Erstellung benutzerdefinierter Schaltflächenformen, indem die Begrenzungspunkte einer Schaltfläche bearbeitet werden.

Bild10

Abbildung 10. Anzeigen einer benutzerdefinierten Registerkarte im "PropertyGrid"-Steuerelement

Weitere Informationen über die Verwendung der UITypeEditor-Klasse zur Anpassung des PropertyGrid-Steuerelements, zusammen mit Codebeispielen der oben genannten benutzerdefinierten Benutzeroberflächen, finden Sie im Artikel von Shawn Burke mit dem Titel Make Your Components Really RAD with Visual Studio .NET Property Browser (in Englisch).

Schlussfolgerung

Das PropertyGrid-Steuerelement in .NET Framework bietet eine Vielzahl von Bearbeitungsmöglichkeiten, mit denen Sie Ihre Benutzeroberfläche verbessern können. Mit Ihren neuen Kenntnissen über die einfache Anpassung des PropertyGrid-Steuerelements sind Sie in der Lage, dieses in Ihren Anwendungen global einzusetzen. Da darüber hinaus der Visual-Studio-.NET-Eigenschaftenbrowser auf dem PropertyGrid-Steuerelement basiert, können Sie mit diesen Verfahren vielfältigere Möglichkeiten zur Entwurfszeit zur Verfügung stellen.


Anzeigen: