Condividi tramite

Procedura dettagliata: Serializzare raccolte di tipi comuni

  • Articolo

I controlli personalizzati a volte espongono una raccolta come proprietà. Questa procedura dettagliata illustra come usare la classe DesignerSerializationVisibilityAttribute per controllare la modalità di serializzazione di una raccolta in fase di progettazione. Applicare il valore Content alla proprietà di raccolta assicura che la proprietà venga serializzata.

Attenzione

Questo contenuto è stato scritto per .NET Framework. Se si usa .NET 6 o una versione successiva, usare questo contenuto con cautela. Il sistema di progettazione è stato modificato per Windows Form ed è importante esaminare le modifiche apportate alla finestra di progettazione dall'articolo .NET Framework.

Per copiare il codice presente in questa sezione come un elenco singolo, vedere Procedura: Serializzare raccolte di tipi standard con DesignerSerializationVisibilityAttribute.

Prerequisiti

Per completare questa procedura dettagliata, è necessario Visual Studio.

Creare un controllo con una raccolta serializzabile

Il primo passaggio consiste nel creare un controllo che abbia come proprietà la raccolta serializzabile. È possibile modificare il contenuto di questa raccolta usando l'Editor raccolta , accessibile dalla finestra Proprietà .

  1. In Visual Studio, creare un progetto di libreria di controlli Windows e denominarlo SerializationDemoControlLib.

  2. Rinominare UserControl1 in SerializationDemoControl. Per altre informazioni, vedere Rinominare un simbolo nel refactoring del codice.

  3. Nella finestra Proprietà impostare il valore della proprietà Padding.All su 10.

  4. Posizionare un controllo TextBox nel SerializationDemoControl.

  5. Selezionare il controllo TextBox. Nella finestra Proprietà impostare le proprietà seguenti.

    Proprietà Cambia in
    multilinea true
    Dock Fill
    Barre di scorrimento Vertical
    Sola lettura true

  6. Nell'editor di codice , dichiarare un campo di una matrice di stringhe denominato 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. Definire la proprietà Strings nel SerializationDemoControl.

    Nota

    Il valore Content viene utilizzato per abilitare la serializzazione della raccolta.

        // 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. Premere F5 per compilare il progetto ed eseguire il controllo nel Contenitore di test UserControl.

  9. Trova la proprietà di Stringhe nel del contenitore di test del UserControl. Selezionare la proprietà stringhe di , quindi selezionare il pulsante puntini di sospensione (pulsante Con i puntini di sospensione (...) nella finestra Proprietà di Visual Studio) per aprire l'Editor dell'insieme di stringhe .

  10. Immettere diverse stringhe nell'editor raccolta di stringhe . Separarli premendo il tasto INVIO alla fine di ogni stringa. Fare clic su OK dopo aver inserito le stringhe.

Nota

Le stringhe digitate vengono visualizzate nella TextBox del SerializationDemoControl.

Serializzare una proprietà di raccolta

Per testare il comportamento di serializzazione del controllo, posizionerai il controllo su un modulo e modificherai il contenuto della raccolta con il Collection Editor. È possibile visualizzare lo stato della raccolta serializzata esaminando un file di progettazione speciale in cui il Progettazione Windows Forms emette codice.

  1. Aggiungere un progetto applicazione Windows alla soluzione. Assegnare al progetto il nome SerializationDemoControlTest.

  2. Nella casella degli strumenti , individuare la scheda denominata SerializationDemoControlLib Components. In questa scheda troverai il SerializationDemoControl. Per ulteriori informazioni, vedere Guida passo passo: Popolamento automatico della casella degli strumenti con componenti personalizzati.

  3. Posizionare un SerializationDemoControl nel modulo.

  4. Trova la proprietà Strings nella finestra delle proprietà . Fare clic sulla proprietà Strings, quindi fare clic sui puntini di sospensione (pulsante Puntini di sospensione (...) nella finestra Proprietà di Visual Studio.) per aprire l'editor dell'insieme di stringhe .

  5. Digitare più stringhe nell'editor della raccolta di stringhe . Separarli premendo Invio alla fine di ogni stringa. Fare clic su OK al termine dell'inserimento delle stringhe.

    Nota

    Le stringhe che hai digitato appaiono nel TextBox del SerializationDemoControl.

  6. In Esplora Soluzioni, fare clic sul pulsante Mostra tutti i file.

  7. Apri il nodo Form1. Sotto di esso è un file denominato Form1.Designer.cs o Form1.Designer.vb. Si tratta del file in cui Progettazione Windows Form genera codice che rappresenta lo stato della fase di progettazione del form e dei relativi controlli figlio. Aprire questo file nell'editor di codice .

  8. Aprire l'area denominata di codice generato da Progettazione Windows Form e individuare la sezione con etichetta serializationDemoControl1. Sotto questa etichetta è presente il codice che rappresenta lo stato serializzato del controllo. Le stringhe digitate nel passaggio 5 vengono visualizzate in un'assegnazione alla proprietà Strings. Gli esempi di codice seguenti in C# e Visual Basic mostrano codice simile a quello che verrà visualizzato se sono state digitate le stringhe "rosso", "arancione" e "giallo".

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

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

  9. Nel Code Editor, modifica il valore di DesignerSerializationVisibilityAttribute nella proprietà Strings a Hidden.

    [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]

    <DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)> _

  10. Ricompilare la soluzione e ripetere i passaggi 3 e 4.

Nota

In questo caso, il Designer di Windows Forms non emette alcuna assegnazione alla proprietà Strings.

Passaggi successivi

Dopo aver appreso come serializzare una raccolta di tipi standard, è consigliabile integrare i controlli personalizzati in modo più approfondito nell'ambiente in fase di progettazione. Negli argomenti seguenti viene descritto come migliorare l'integrazione in fase di progettazione dei controlli personalizzati:

Vedere anche