Procedura dettagliata: serializzazione di insiemi di tipi standard tramite DesignerSerializationVisibilityAttribute

I controlli personalizzati talvolta espongono un insieme come una proprietà. In questa procedura dettagliata viene indicato come utilizzare la classe DesignerSerializationVisibilityAttribute per controllare come un insieme viene serializzato in fase di progettazione. Tramite l'applicazione del valore Content alla proprietà dell'insieme si assicura che la proprietà venga serializzata.

Per copiare il codice relativo a questo argomento come un listato unico, vedere Procedura: serializzare insiemi di tipi standard mediante DesignerSerializationVisibilityAttribute.

Prerequisiti

Per completare questa procedura dettagliata è necessario:

• Disporre di autorizzazioni sufficienti per creare ed eseguire progetti di applicazioni Windows Form nel computer dove è installato Visual Studio.

Creazione di un controllo contenente un insieme serializzabile

Il primo passaggio consiste nella creazione di un controllo che contiene un insieme serializzabile come una proprietà. È possibile modificare il contenuto dell'insieme utilizzando l'editor dell'insieme dalla finestra Proprietà.

Per creare un controllo con un insieme serializzabile

1. Creare un progetto Libreria di controlli Windows denominato SerializationDemoControlLib. Per ulteriori informazioni, vedere Windows Control Library Template.

2. Rinominare UserControl1 in SerializationDemoControl. Per ulteriori informazioni, vedere How to: Rename Identifiers.

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

4. Inserire un controllo TextBox in SerializationDemoControl.

5. Fare clic sul controllo TextBox. Nella finestra Proprietà impostare le seguenti proprietà:

   Proprietà	Modificare in
   Multiline	true
   Dock	Fill
   ScrollBars	Vertical
   ReadOnly	true

6. Nell'editor di codice, dichiarare un campo di matrice di stringhe denominato stringsValue in SerializationDemoControl.

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

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

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

7. Definire la proprietà Strings in SerializationDemoControl.

' 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

// 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.
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();
        }
    }

1. Per compilare il progetto ed eseguire il controllo in UserControl Test Container, premere F5.

2. Trovare la proprietà Strings nell'oggetto PropertyGrid di UserControl Test Container. Fare clic sulla proprietà Strings, quindi fare clic sul pulsante con i puntini di sospensione () per aprire l'editor dell'insieme String.

3. Immettere diverse stringhe nell'editor dell'insieme String. Separarle premendo INVIO alla fine di ogni stringa. Una volta aggiunte tutte le stringhe, premere OK.

Serializzazione di una proprietà dell'insieme

Per verificare il comportamento di serializzazione di un controllo, si inserisce il controllo in un form e si modifica il contenuto dell'insieme con l'editor dell'insieme. È possibile osservare lo stato dell'insieme serializzato in un file speciale della finestra di progettazione in cui Progettazione Windows Form emette il codice.

Per serializzare un insieme

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

2. Nella Casella degli strumenti, individuare la scheda Componenti SerializationDemoControlLib dove si troverà il controllo SerializationDemoControl. Per ulteriori informazioni, vedere Procedura dettagliata: compilare automaticamente la casella degli strumenti con componenti personalizzati.

3. Inserire un SerializationDemoControl nel form.

4. Trovare la proprietà Strings nella finestra Proprietà. Fare clic sulla proprietà Strings, quindi fare clic sul pulsante con i puntini di sospensione () per aprire l'editor dell'insieme String.

5. Digitare diverse stringhe nell'editor dell'insieme String. Separarle premendo INVIO alla fine di ogni stringa. Una volta aggiunte tutte le stringhe, premere OK.

1. In Esplora soluzioni fare clic sul pulsante Mostra tutti i file.

2. Aprire il nodo Form1 in cui è presente un file chiamato Form1.Designer.cs o Form1.Designer.vb. Si tratta del file in cui Progettazione Windows Form emette il codice che rappresenta lo stato in fase di progettazione del form e dei controlli figlio. Aprire il file nell'editor di codice.

3. Aprire la regione Codice generato da Progettazione Windows Form e individuare la sezione serializationDemoControl1. In questa etichetta è contenuto il codice che rappresenta lo stato serializzato del controllo. Le stringhe digitate al passaggio 5 sono presenti in un'assegnazione alla proprietà Strings. Il seguente codice di esempio mostra ciò che si otterrebbe se si digitassero stringhe "red", "orange" e "yellow".

4. [Visual Basic]

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

5. [C#]

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

6. Nell'editor di codice modificare il valore di DesignerSerializationVisibilityAttribute sulla proprietà Strings in Hidden.

7. [Visual Basic]

   <DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)> _
   

8. [C#]

   [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
   

9. Ricompilare la soluzione e ripetere i passaggi da 4 a 8.

Passaggi successivi

Una volta appreso come serializzare un insieme di tipi standard, provare a integrare i controlli personalizzati in modo più specifico nell'ambiente della fase di progettazione. Negli argomenti riportati di seguito viene descritto come aumentare l'integrazione della fase di progettazione dei controlli personalizzati.

• Architettura della fase di progettazione

• Attributi nei controlli Windows Form

• Cenni preliminari sulla serializzazione della finestra di progettazione

• Procedura dettagliata: creazione di un controllo di Windows Form che usufruisca delle funzionalità offerte da Visual Studio in fase di progettazione

Vedere anche

Attività

Procedura: serializzare insiemi di tipi standard mediante DesignerSerializationVisibilityAttribute

Procedura dettagliata: compilare automaticamente la casella degli strumenti con componenti personalizzati

Riferimenti

DesignerSerializationVisibilityAttribute

Concetti

Cenni preliminari sulla serializzazione della finestra di progettazione