Share via

Exemplarische Vorgehensweise: Serialisieren von Sammlungen von Standardtypen

  • Artikel

Ihre benutzerdefinierten Steuerelemente werden manchmal eine Sammlung als Eigenschaft verfügbar machen. Dieser Walkthrough veranschaulicht die Verwendung der DesignerSerializationVisibilityAttribute-Klasse, um zu steuern, wie eine Sammlung zur Entwurfszeit serialisiert wird. Durch Anwenden des Werts auf Ihre Sammlungseigenschaft wird sichergestellt, dass die Content Eigenschaft serialisiert wird.

Achtung

Dieser Inhalt wurde für .NET Framework geschrieben. Wenn Sie .NET 6 oder eine höhere Version verwenden, verwenden Sie diesen Inhalt mit Vorsicht. Das Designer-System für Windows Forms hat sich geändert, und es ist wichtig, dass Sie den Artikel Änderungen am Designer seit .NET Framework lesen.

Informationen zum Kopieren des Codes in diesem Thema als einzelner Eintrag finden Sie unter How to: Serialize Collections of Standard Types with the DesignerSerializationVisibilityAttribute.

Voraussetzungen

Für diese exemplarische Vorgehensweise benötigen Sie Visual Studio.

Erstellen eines Steuerelements mit einer serialisierbaren Sammlung

Der erste Schritt besteht darin, ein Steuerelement zu erstellen, das eine serialisierbare Sammlung als Eigenschaft aufweist. Sie können den Inhalt dieser Sammlung mithilfe des Sammlungs-Editors bearbeiten, auf den Sie im Eigenschaftenfenster zugreifen können.

  1. Erstellen Sie in Visual Studio ein Windows Steuerelementbibliotheksprojekt, und benennen Sie es SerializationDemoControlLib.

  2. Benennen Sie UserControl1 in SerializationDemoControl um. Weitere Informationen finden Sie auf Refactoring des Umbenennens eines Codesymbols.

  3. Legen Sie im Eigenschaftenfenster den Wert der Padding.All-Eigenschaft auf 10 fest.

  4. Platzieren Sie ein TextBox Steuerelement im SerializationDemoControl.

  5. Wählen Sie das TextBox-Steuerelement. Legen Sie im Eigenschaftenfenster die folgenden Eigenschaften fest.

    Eigenschaft Ändern in
    Mehrzeilig true
    Andocken Fill
    ScrollBars Vertical
    ReadOnly true

  6. Deklarieren Sie im Code-Editor ein Zeichenfolgenarrayfeld namens stringsValue in SerializationDemoControl.

        // This field backs the Strings property.
private:
    array<String^>^ stringsValue;



    // This field backs the Strings property.
private String[] stringsValue = new String[1];

    ' This field backs the Strings property.
 Private stringsValue(1) As String

  7. Definieren Sie die Strings Eigenschaft auf dem SerializationDemoControl.

    Hinweis

    Der Content Wert wird verwendet, um die Serialisierung der Sammlung zu aktivieren.

        // When the DesignerSerializationVisibility attribute has
    // a value of "Content" or "Visible" the designer will 
    // serialize the property. This property can also be edited 
    // at design time with a CollectionEditor.
public:
    [DesignerSerializationVisibility(
        DesignerSerializationVisibility::Content)]
    property array<String^>^ Strings
    {
        array<String^>^ get()
        {
            return this->stringsValue;
        }
        void set(array<String^>^ value)
        {
            this->stringsValue = value;

            // Populate the contained TextBox with the values
            // in the stringsValue array.
            StringBuilder^ sb =
                gcnew StringBuilder(this->stringsValue->Length);

            for (int i = 0; i < this->stringsValue->Length; i++)
            {
                sb->Append(this->stringsValue[i]);
                sb->Append(Environment::NewLine);
            }

            this->demoControlTextBox->Text = sb->ToString();
        }
    }

    // When the DesignerSerializationVisibility attribute has
// a value of "Content" or "Visible" the designer will
// serialize the property. This property can also be edited
// at design time with a CollectionEditor.
[DesignerSerializationVisibility(
    DesignerSerializationVisibility.Content )]
public String[] Strings
{
    get
    {
        return this.stringsValue;
    }
    set
    {
        this.stringsValue = value;

        // Populate the contained TextBox with the values
        // in the stringsValue array.
        StringBuilder sb =
            new StringBuilder(this.stringsValue.Length);

        for (int i = 0; i < this.stringsValue.Length; i++)
        {
            sb.Append(this.stringsValue[i]);
            sb.Append("\r\n");
        }

        this.textBox1.Text = sb.ToString();
    }
}

    ' When the DesignerSerializationVisibility attribute has
' a value of "Content" or "Visible" the designer will 
' serialize the property. This property can also be edited 
' at design time with a CollectionEditor.
 <DesignerSerializationVisibility( _
     DesignerSerializationVisibility.Content)> _
 Public Property Strings() As String()
     Get
         Return Me.stringsValue
     End Get
     Set(ByVal value As String())
         Me.stringsValue = Value

         ' Populate the contained TextBox with the values
         ' in the stringsValue array.
         Dim sb As New StringBuilder(Me.stringsValue.Length)

         Dim i As Integer
         For i = 0 To (Me.stringsValue.Length) - 1
             sb.Append(Me.stringsValue(i))
             sb.Append(ControlChars.Cr + ControlChars.Lf)
         Next i

         Me.textBox1.Text = sb.ToString()
     End Set
 End Property

  8. Drücken Sie F5, um das Projekt zu erstellen, und führen Sie das Steuerelement im UserControl-Testcontainer aus.

  9. Suchen Sie die Strings-Eigenschaft im PropertyGridUserControl Test-Container. Markieren Sie die Eigenschaft Strings und wählen Sie dann die Schaltfläche Ellipsis (The Ellipsis button (...) in the Properties window of Visual Studio), um den String Collection Editor zu öffnen.

  10. Geben Sie mehrere Zeichenfolgen im String-Sammlungs-Editor ein. Trennen Sie sie, indem Sie die EINGABETASTE am Ende jeder Zeichenfolge drücken. Klicken Sie auf OK, wenn Sie mit der Eingabe der Zeichenfolgen fertig sind.

Hinweis

Die eingegebenen Zeichenfolgen werden im TextBox Bereich der SerializationDemoControl.

Serialisieren einer Sammlungseigenschaft

Um das Serialisierungsverhalten Ihres Steuerelements zu testen, platzieren Sie es in einem Formular und ändern den Inhalt der Sammlung mit dem Sammlungs-Editor. Sie können den serialisierten Sammlungsstatus sehen, indem Sie sich eine spezielle Designerdatei ansehen, in der der Windows Forms Designer Code ausgibt.

  1. Fügen Sie der Projektmappe ein Projekt vom Typ Windows-Anwendung hinzu. Benennen Sie das Projekt mit SerializationDemoControlTest.

  2. Suchen Sie in der Toolbox nach der Registerkarte "SerializationDemoControlLib-Komponenten". Auf dieser Registerkarte finden Sie die SerializationDemoControl. Weitere Informationen finden Sie unter Exemplarische Vorgehensweise: Automatisches Füllen der Toolbox mit benutzerdefinierten Komponenten.

  3. Platzieren Sie ein SerializationDemoControl Formular auf Ihrem Formular.

  4. Suchen Sie die Strings-Eigenschaft im Eigenschaftenfenster. Klicken Sie die Eigenschaft Strings an und wählen Sie dann die Schaltfläche Ellipsis (The Ellipsis button (...) in the Properties window of Visual Studio.), um den String Collection Editor zu öffnen.

  5. Geben Sie mehrere Zeichenfolgen im String-Sammlungs-Editor ein. Trennen Sie sie, indem Sie die EINGABETASTE am Ende jeder Zeichenfolge drücken. Klicken Sie auf OK, wenn Sie mit der Eingabe der Zeichenfolgen fertig sind.

    Hinweis

    Die eingegebenen Zeichenfolgen werden im TextBox Bereich der SerializationDemoControl.

  6. Klicken Sie im Projektmappen-Explorer auf die Schaltfläche Alle Dateien anzeigen.

  7. Öffnen Sie den Formular1-Knoten. Darunter befindet sich eine Datei namens Form1.Designer.cs oder Form1.Designer.vb. Dies ist die Datei, in der der Windows Forms Designer Code ausgibt, der den Entwurfszeitzustand Ihres Formulars und der untergeordneten Steuerelemente darstellt. Öffnen Sie diese Datei im Code-Editor.

  8. Öffnen Sie den Bereich namens Windows Generierten Formular-Designer, und suchen Sie die Abschnittsbezeichnung SerialisierungDemoControl1. Unter dieser Bezeichnung handelt es sich um den Code, der den serialisierten Zustand Ihres Steuerelements darstellt. Die in Schritt 5 eingegebenen Zeichenfolgen werden in einer Zuordnung zur Strings Eigenschaft angezeigt. Die folgenden Codebeispiele in C# und Visual Basic zeigen Code an, ähnlich wie sie sehen, wenn Sie die Zeichenfolgen "rot", "orange" und "gelb" eingegeben haben.

    this.serializationDemoControl1.Strings = new string[] {
        "red",
        "orange",
        "yellow"};

    Me.serializationDemoControl1.Strings = New String() {"red", "orange", "yellow"}

  9. Ändern Sie im Code-Editor den Wert der DesignerSerializationVisibilityAttributeStrings Eigenschaft in Hidden.

    [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]

    <DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)> _

  10. Erstellen Sie die Lösung neu, und wiederholen Sie die Schritte 3 und 4.

Hinweis

In diesem Fall gibt der Windows Forms Designer keine Zuordnung zur Strings Eigenschaft aus.

Nächste Schritte

Sobald Sie wissen, wie Sie eine Sammlung von Standardtypen serialisieren, sollten Sie Ihre benutzerdefinierten Steuerelemente tiefer in die Entwurfszeitumgebung integrieren. In den folgenden Themen wird beschrieben, wie Sie die Entwurfszeitintegration Ihrer benutzerdefinierten Steuerelemente verbessern:

Siehe auch