Demonstra Passo a passo: Serializar coleções de tipos padrão com o DesignerSerializationVisibilityAttribute

Os controles personalizados, às vezes, expõe uma coleção como uma propriedade. Esta explicação passo a passo demonstra como usar o DesignerSerializationVisibilityAttribute a classe de controle como uma coleção é serializada em tempo de design. Aplicando o Content o valor para a propriedade de coleção garante que a propriedade será serializada.

Para copiar o código deste tópico como uma única lista, consulte Como: Serializar coleções de tipos padrão com o DesignerSerializationVisibilityAttribute.

Observação
As caixas de diálogo e comandos de menu demonstradas podem ser diferentes daqueles descritos na Ajuda, dependendo das configurações ativas ou configurações de edição. Para alterar as configurações, escolha Import and Export Settings sobre o Ferramentas menu. Para obter mais informações, consulte Trabalhando com configurações.

Pré-requisitos

A fim de concluir este explicação passo a passo, será necessário:

• Dê permissões suficientes para poder criar e executar projetos de aplicativos de Formulários do Windows no computador onde o Visual Studio está instalado.

Criar um controle que tem uma coleção de serializável

A primeira etapa é criar um controle que tem uma coleção serializável como uma propriedade. Você pode editar o conteúdo dessa coleção, use o Collection Editor, que pode ser acessada a partir de Propriedades janela.

Para criar um controle com uma coleção serializável

1. Crie um projeto de biblioteca de controle do Windows chamado SerializationDemoControlLib. Para obter mais informações, consulte Windows Control Library Template.

2. Rename UserControl1 to SerializationDemoControl. Para obter mais informações, consulte How to: Rename Identifiers.

3. No Propriedades janela, defina o valor da Padding.All propriedade para 10.

4. Lugar uma TextBox de controle no SerializationDemoControl.

5. Selecione o controle TextBox. No Propriedades janela, defina as propriedades a seguintes.

   Propriedade	Alterar para
   Multiline (de múltiplas linhas)	true
   Dock	Fill
   ScrollBars	Vertical
   Readonly	true

6. No O Editor de código, declarar um campo de matriz de cadeia de caracteres denominado stringsValue na 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. Definir o Strings propriedade no SerializationDemoControl.

Observação
O Content valor é usado para habilitar a serialização da coleção.

' 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. Pressione F5 para compilar o projeto e executar o controle da Contêiner de teste de UserControl.

2. Encontrar o Strings propriedade no PropertyGrid da Contêiner de teste de UserControl. Clique na Strings propriedade, em seguida, clique nas reticências () botão para abrir o String Collection Editor.

3. Inserir várias cadeias de caracteres na String Collection Editor. Separe-as pressionando a tecla ENTER no final de cada seqüência de caracteres. Clique em OK quando você terminar de inserir seqüências de caracteres.

Observação
As seqüências de caracteres que você digitou são exibidos na TextBox da SerializationDemoControl.

Uma propriedade de coleção de serialização

Para testar o comportamento de serialização do seu controle, você irá colocá-lo em um formulário e alterar o conteúdo da coleção com o O Editor de coleção. Você pode ver o estado de coleção serializados examinando um arquivo de designer especial no qual o Windows Forms Designer emite código.

Para serializar uma coleção

1. Adicione um projeto Windows Application à solução. Nomeie o projeto SerializationDemoControlTest.

2. No caixa de ferramentas, encontrar a guia denominada SerializationDemoControlLib componentes. Nessa guia, você encontrará o SerializationDemoControl. Para obter mais informações, consulte Demonstra Passo a passo: Preenchendo automaticamente a caixa de ferramentas com componentes personalizados.

3. Local de um SerializationDemoControl em seu formulário.

4. Encontrar o Strings propriedade de Propriedades janela. Clique na Strings propriedade, em seguida, clique nas reticências () botão para abrir o String Collection Editor.

5. Digite várias cadeias de caracteres na String Collection Editor. Separe-as pressionando a tecla ENTER no final de cada seqüência de caracteres. Clique em OK quando você terminar de inserir seqüências de caracteres.

Observação
As seqüências de caracteres que você digitou são exibidos na TextBox da SerializationDemoControl.

1. Em Solution Explorer, clique na Mostrar todos os arquivos botão.

2. Abrir o Form1 nó. Posterior é um arquivo chamado Form1 ou Form1.Designer.vb. Este é o arquivo no qual o Windows Forms Designer emite um código que representa o estado de tempo de design do formulário e seus controles filho. Abrir este arquivo de O Editor de código.

3. Abrir a região denominada código gerado pelo Designer de formulário do Windows e localize a secção serializationDemoControl1. Sob esse rótulo é o código que representa o estado serializado do seu controle. As seqüências de caracteres que você digitou na etapa 5 aparecem em uma atribuição para o Strings propriedade. O exemplo de código a seguir mostra o código semelhante ao que você verá se você digitou as seqüências de caracteres "vermelho", "laranjas" e "amarelo".

4. [Visual Basic]

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

5. [C#]

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

6. No O Editor de código, alterar o valor da DesignerSerializationVisibilityAttribute na Strings propriedade para Hidden.

7. [Visual Basic]

   <DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)> _
   

8. [C#]

   [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
   

9. Recrie a solução e repita as etapas 4 a 8.

Observação
Nesse caso, o Windows Forms Designer não emite nenhuma atribuição para o Strings propriedade.

Próximas etapas

Você sabe como serializar uma coleção de tipos padrão, considere a possibilidade de integrar seus controles personalizados mais profundamente o ambiente de tempo de design. Os tópicos a seguir descrevem como melhorar a integração de tempo de design de seus controles personalizados:

• Arquitetura de tempo de design

• Atributos de controles do Windows Forms

• Designer Serialization Overview

• Demonstra Passo a passo: Criando um controle Windows Forms que tira proveito dos recursos de tempo de Design de Visual Studio

Consulte também

Tarefas

Como: Serializar coleções de tipos padrão com o DesignerSerializationVisibilityAttribute

Demonstra Passo a passo: Preenchendo automaticamente a caixa de ferramentas com componentes personalizados

Referência

DesignerSerializationVisibilityAttribute

Conceitos

Designer Serialization Overview