Procedura dettagliata: Serializzare raccolte di tipi standard

I controlli personalizzati a volte espongono una raccolta come proprietà. Questa procedura dettagliata illustra come usare la DesignerSerializationVisibilityAttribute classe per controllare la modalità di serializzazione di una raccolta in fase di progettazione. L'applicazione del Content valore alla proprietà della raccolta garantisce che la proprietà venga serializzata.

Per copiare il codice in questo argomento come singolo elenco, vedere Procedura: Serializzare raccolte di tipi standard con DesignerSerializationVisibilityAttribute.

Prerequisiti

Per completare la procedura dettagliata, è necessario Visual Studio.

Creare un controllo con una raccolta serializzabile

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

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

2. Rinomina UserControl1 in SerializationDemoControl. Per altre informazioni, vedere Rinominare un refactoring dei simboli di codice.

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

4. Posizionare un TextBox controllo in SerializationDemoControl.

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

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

6. Nell'editor di codice dichiarare un campo 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 Strings proprietà in SerializationDemoControl.

   Nota

   Il Content valore 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. Trovare la proprietà Strings in PropertyGrid del contenitore di test UserControl. Selezionare la proprietà Strings e quindi selezionare il pulsante con i puntini di sospensione () per aprire l'Editor raccolta stringhe.

10. Immettere diverse stringhe nell'Editor raccolta stringhe. Separarli premendo INVIO alla fine di ogni stringa. Al termine dell'immissione di stringhe, fare clic su OK .

Serializzare una proprietà della raccolta

Per testare il comportamento di serializzazione del controllo, verrà inserito in una maschera e modificato il contenuto della raccolta con l'Editor raccolta. È possibile visualizzare lo stato della raccolta serializzata esaminando un file di progettazione speciale in cui la finestra di progettazione Windows Form genera codice.

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

2. Nella casella degli strumenti trovare la scheda denominata SerializationDemoControlLib Components. In questa scheda si troverà .SerializationDemoControl Per altre informazioni, vedere Procedura dettagliata: Compilare automaticamente la casella degli strumenti con componenti personalizzati.

3. Posizionare un oggetto SerializationDemoControl nel modulo.

4. Trovare la Strings proprietà nella finestra Proprietà . Fare clic sulla Strings proprietà e quindi sul pulsante con i puntini di sospensione () per aprire l'Editor raccolta stringhe.

5. Digitare diverse stringhe nell'Editor raccolta stringhe. Separarli premendo INVIO alla fine di ogni stringa. Al termine dell'immissione di stringhe, fare clic su OK .

   Nota

   Le stringhe digitate vengono visualizzate nell'oggetto TextBoxSerializationDemoControldi .

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

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

8. Aprire l'area denominata Codice generato di Progettazione Windows Form e trovare 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 Strings proprietà . 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. Nell'editor di codice modificare il valore di DesignerSerializationVisibilityAttribute nella Strings proprietà in Hidden.

   [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
   

   <DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)> _
   

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

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:

• Architettura in fase di progettazione

• Attributi nei controlli Windows Form

• Panoramica della serializzazione della finestra di progettazione

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

Vedi anche

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