Tutorial: Serialización de colecciones de tipos estándar

Los controles personalizados a veces exponen una colección como una propiedad. Este tutorial muestra cómo utilizar la clase DesignerSerializationVisibilityAttribute para controlar cómo se serializa una colección en tiempo de diseño. Aplicar el valor Content a su propiedad de colección asegura que la propiedad se serializará.

Para copiar el código de este tema como una sola lista, vea Cómo: Serializar colecciones de tipos estándar con DesignerSerializationVisibilityAttribute.

Prerrequisitos

Necesita Visual Studio para completar este tutorial.

Creación de un control con una colección serializable

El primer paso es crear un control que tenga una colección serializable como una propiedad. Puede editar el contenido de esta colección utilizando el Editor de colecciones, al que puede acceder desde la ventana Propiedades.

1. En Visual Studio, cree un proyecto de biblioteca de control de Windows y nómbrelo SerializationDemoControlLib.

2. Cambie el nombre de UserControl1 a SerializationDemoControl. Para obtener más información, vea Cambiar el nombre de un símbolo de código de refactorización.

3. En la ventana Propiedades, establezca el valor de la propiedad Padding.All10.

4. Coloque un control TextBox en SerializationDemoControl.

5. Seleccione el control TextBox. En la ventana Propiedades, establezca las propiedades siguientes.

   Propiedad	Cambiar a
   Multiline	true
   Acoplar	Fill
   ScrollBars	Vertical
   ReadOnly	true

6. En el Editor de código, declare un campo de matriz de cadenas llamado stringsValue en 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. Definir la propiedad Strings sobre SerializationDemoControl.

   Nota

   El valor Content se utiliza para permitir la serialización de la colección.

       // 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. Presione F5 para compilar el proyecto y ejecutar el control en UserControl Test Container.

9. Encuentre la propiedad Strings en PropertyGrid del UserControl Test Container. Seleccione la propiedad Strings y, a continuación, seleccione el botón de puntos suspensivos () para abrir el Editor de colección de cadenas.

10. Introduzca varias cadenas en el Editor de colección de cadenas. Sepárelos pulsando la tecla Entrar al final de cada cadena. Haga clic en Aceptar cuando haya terminado de introducir las cadenas.

Serialización de una propiedad de colección

Para probar el comportamiento de la serialización de su control, lo colocará en un formulario y cambiará el contenido de la colección con el Editor de colección. Puede ver el estado de la colección serializada examinando un archivo de diseño especial en el que el Diseñador de Windows Forms emite código.

1. Agregue un proyecto de Aplicación Windows a la solución. Dé un nombre al proyecto SerializationDemoControlTest.

2. En el Cuadro de herramientas, busque la pestaña denominada Componentes de SerializaciónDemoControlLib. En esta pestaña, encontrará SerializationDemoControl. Para obtener más información, vea Tutorial: Rellenar automáticamente el cuadro de herramientas con componentes personalizados.

3. Coloque un SerializationDemoControl en su formulario.

4. Busque la propiedad Strings en la ventana Propiedades. Haga clic en la propiedad Strings y, a continuación, haga clic en el botón de puntos suspensivos () para abrir el Editor de colección de cadenas.

5. Escriba varias cadenas en el Editor de colección de cadenas. Sepárelos pulsando la tecla Entrar al final de cada cadena. Haga clic en Aceptar cuando haya terminado de introducir las cadenas.

   Nota

   Las cadenas que ha escrito aparecen en TextBox de SerializationDemoControl.

6. En el Explorador de soluciones, haga clic en el botón Mostrar todos los archivos.

7. Abre el nodo Form1. Debajo hay un archivo llamado Form1.Designer.cs o Form1.Designer.vb. Este es el archivo en el que el Diseñador de Windows Forms emite el código que representa el estado en tiempo de diseño de su formulario y sus controles secundarios. Abra este archivo en el Editor de código.

8. Abra la región denominada Código generado por el Diseñador de Windows Forms y busque la sección etiquetada como serializationDemoControl1. Debajo de esta etiqueta se encuentra el código que representa el estado serializado del control. Las cadenas que escribiste en el paso 5 aparecen en una asignación a la propiedad Strings. Los siguientes ejemplos de código en C# y Visual Basic, muestran código similar a lo que verá si ha escrito las cadenas "rojo", "naranja" y "amarillo".

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

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

9. En el Editor de código, cambie el valor de DesignerSerializationVisibilityAttribute en la propiedad Strings a Hidden.

   [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
   

   <DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)> _
   

10. Recompile la solución y repita los pasos 3 y 4.

Pasos siguientes

Una vez que sepa cómo serializar una colección de tipos estándar, considere la posibilidad de integrar los controles personalizados más profundamente en el entorno de tiempo de diseño. En los temas siguientes se describe cómo mejorar la integración en tiempo de diseño de los controles personalizados:

• Arquitectura en tiempo de diseño

• Atributos en controles de formularios Windows Forms

• Información general sobre serialización de diseñadores

• Tutorial: Crear un control de Windows Forms que aproveche las características en tiempo de diseño de Visual Studio

Vea también

• DesignerSerializationVisibilityAttribute
• Tutorial: Rellenar automáticamente el cuadro de herramientas con componentes personalizados