Procédure pas à pas : sérialisation des collections de types standard avec DesignerSerializationVisibilityAttribute

Vos contrôles personnalisés exposeront quelquefois une collection en tant que propriété. Cette procédure pas à pas montre comment utiliser la classe DesignerSerializationVisibilityAttribute pour contrôler la façon dont une collection est sérialisée au moment du design. L'application de la valeur Content à votre propriété de collection garantit la sérialisation de la propriété.

Pour copier le code dans cette rubrique sous forme de liste unique, consultez Comment : sérialiser des collections de types standard avec DesignerSerializationVisibilityAttribute.

Composants requis

Pour exécuter cette procédure pas à pas, vous devrez :

• Avoir des autorisations suffisantes pour être en mesure de créer et d'exécuter des projets d'application Windows Forms sur l'ordinateur où Visual Studio est installé.

Création d'un contrôle qui a une collection sérialisable

La première étape consiste à créer un contrôle qui a une collection sérialisable en tant que propriété. Vous pouvez modifier le contenu de cette collection à l'aide de l'éditeur de collections auquel vous pouvez accéder à partir de la fenêtre Propriétés.

Pour créer un contrôle avec une collection sérialisable

1. Créez un projet de bibliothèque de contrôles Windows appelé SerializationDemoControlLib. Pour plus d'informations, consultez Windows Control Library Template.

2. Renommez UserControl1 à SerializationDemoControl. Pour plus d'informations, consultez How to: Rename Identifiers.

3. Dans la fenêtre Propriétés, affectez à la propriété Padding.All la valeur 10.

4. Placez un contrôle TextBox dans le SerializationDemoControl.

5. Sélectionnez le contrôle TextBox. Dans la fenêtre Propriétés, définissez les propriétés suivantes.

   Propriété	Remplacez par
   Multiline	true
   Dock	Fill
   ScrollBars	Vertical
   ReadOnly	true

6. Dans l'éditeur de code, déclarez un champ de tableau de chaînes nommé stringsValue dans 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. Définissez la propriété Strings sur le 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. Appuyez sur F5 pour générer le projet et exécuter votre contrôle dans le conteneur de test UserControl.

2. Recherchez la propriété Strings dans PropertyGrid de l'élément conteneur de test UserControl. Cliquez sur la propriété Strings, puis sur le bouton de sélection () pour ouvrir l'éditeur de collections String.

3. Entrez plusieurs chaînes dans l'éditeur de collections String. Séparez-les en appuyant sur la touche ENTRÉE à la fin de chaque chaîne. Cliquez sur OK lorsque vous avez terminé d'ajouter des chaînes.

Sérialisation d'une propriété de collection

Pour tester le comportement de sérialisation de votre contrôle, vous le placerez sur un formulaire et modifierez le contenu de la collection à l'aide de l'éditeur de collections. Vous pouvez consulter l'état de collection sérialisée en examinant un fichier de concepteur spécial dans lequel le Concepteur Windows Forms Designer émet le code.

Pour sérialiser une collection

1. Ajoutez un nouveau projet Application Windows à la solution. Nommez le projet SerializationDemoControlTest.

2. Dans la Boîte à outils, recherchez l'onglet nommé Composants SerializationDemoControlLib. Sous cet onglet, vous trouverez le SerializationDemoControl. Pour plus d'informations, consultez Procédure pas à pas : remplissage automatique de la boîte à outils avec des composants personnalisés.

3. Ajoutez un SerializationDemoControl sur votre formulaire.

4. Recherchez la propriété Strings dans la fenêtre Propriétés. Cliquez sur la propriété Strings, puis sur le bouton de sélection () pour ouvrir l'éditeur de collections String.

5. Entrez plusieurs chaînes dans l'éditeur de collections String. Séparez-les en appuyant sur la touche ENTRÉE à la fin de chaque chaîne. Cliquez sur OK lorsque vous avez terminé d'ajouter des chaînes.

1. Dans l'Explorateur de solutions, cliquez sur le bouton Afficher tous les fichiers.

2. Ouvrez le nœud Form1. Vous trouverez en dessous un fichier appelé Form1.Designer.cs ou Form1.Designer.vb. C'est le fichier dans lequel le Concepteur Windows Forms émet le code qui représente l'état au moment du design de votre formulaire et ses contrôles enfants. Ouvrez ce fichier dans l'éditeur de code.

3. Ouvrez la région appelée Code généré par le Concepteur Windows Form et recherchez la section étiquetée serializationDemoControl1. Sous cette étiquette se trouve le code qui représente l'état sérialisé de votre contrôle. Les chaînes que vous avez entrées à l'étape 5 apparaissent dans une assignation à la propriété Strings. L'exemple de code suivant affiche un code similaire à celui que vous verrez si vous tapez les chaînes « rouge », « orange » et « jaune ».

4. [Visual Basic]

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

5. [C#]

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

6. Dans l'éditeur de code, remplacez la valeur de l'DesignerSerializationVisibilityAttribute de la propriété Strings par Hidden.

7. [Visual Basic]

   <DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)> _
   

8. [C#]

   [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
   

9. Régénérez la solution et répétez les étapes 4 à 8.

Étapes suivantes

Une fois que vous savez comment sérialiser une collection de types standard, pensez à intégrer plus profondément vos contrôles personnalisés dans l'environnement au moment du design. Les rubriques suivantes décrivent comment améliorer l'intégration au moment du design de vos contrôles personnalisés :

• Architecture de design

• Attributs dans les contrôles Windows Forms

• Vue d'ensemble de la sérialisation du concepteur

• Procédure pas à pas : création d'un contrôle Windows Forms qui tire parti des fonctionnalités au moment du design de Visual Studio

Voir aussi

Tâches

Comment : sérialiser des collections de types standard avec DesignerSerializationVisibilityAttribute

Procédure pas à pas : remplissage automatique de la boîte à outils avec des composants personnalisés

Référence

DesignerSerializationVisibilityAttribute

Concepts

Vue d'ensemble de la sérialisation du concepteur