Demonstra Passo a passo: Persisting an Object (C# e Visual Basic)

Artigo
08/01/2011

Embora você possa definir as propriedades do objeto aos valores padrão em tempo de design, quaisquer valores inseridos em tempo de execução são perdidas quando o objeto é destruído. Você pode usar serialização para persistir os dados de um objeto entre instâncias, o que permite que você armazene valores e recuperá-los na próxima vez que o objeto é instanciado.

Observação
No Visual Basic, para armazenar dados simples, como, por exemplo, um nome ou número, você pode usar o My.Settings objeto. Para obter mais informações, consulte Objeto My.Settings (Visual Basic).

Esta explicação passo a passo, você criará uma simples Loan object e manter seus dados para um arquivo. Em seguida, recuperará os dados do arquivo quando você recriar o objeto. Finalmente, você irá modificar o código para manter o objeto em um formato SOAP.

Observação sobre segurança
Este exemplo cria um novo arquivo, se o arquivo ainda não existir. Se um aplicativo deve criar um arquivo, o aplicativo deve Create permissão para a pasta. As permissões são definidas usando listas de controle de acesso. Se o arquivo já existir, o aplicativo precisa de apenas Write permissão, permissão menor. Sempre que possível, é mais seguro para criar o arquivo durante a implantação e conceder apenas Read permissões para um único arquivo (em vez de criar permissões para uma pasta). Além disso, é mais seguro gravar dados em pastas de usuário que em pasta raiz ou em pasta Program Files.

Este exemplo cria um novo arquivo, se o arquivo ainda não existir. Se um aplicativo deve criar um arquivo, o aplicativo deve Create permissão para a pasta. As permissões são definidas usando listas de controle de acesso. Se o arquivo já existir, o aplicativo precisa de apenas Write permissão, permissão menor. Sempre que possível, é mais seguro para criar o arquivo durante a implantação e conceder apenas Read permissões para um único arquivo (em vez de criar permissões para uma pasta). Além disso, é mais seguro gravar dados em pastas de usuário que em pasta raiz ou em pasta Program Files.

Observação sobre segurança
Este exemplo armazena dados em um arquivo de formato SOAP ou binário. Esses formatos não devem ser usados para dados confidenciais, como senhas ou informações de cartão de crédito.

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 suas configurações, escolha Importar e Exportar Configurações no menu Ferramentas. Para obter mais informações, consulte Configurações do Visual Studio.

Criando o objeto de empréstimo

A primeira etapa é criar um Loan classe e um aplicativo de teste que usa a classe.

Para criar a classe de empréstimo

Crie um novo projeto de biblioteca de classe e o nome "loanclass". Para obter mais informações, consulte Como: Criar soluções e projetos.
Em Solution Explorer, o botão direito do mouse no arquivo Class1 e clique em Renomear. Renomeie o arquivo para empréstimo e pressione ENTER. Renomear o arquivo também renomear a classe Loan.

Adicione os seguintes membros públicos na classe:

Public Class Loan
    Implements System.ComponentModel.INotifyPropertyChanged

    Public Property LoanAmount As Double
    Public Property InterestRate As Double
    Public Property Term As Integer

    Private p_Customer As String
    Public Property Customer As String
        Get
            Return p_Customer
        End Get
        Set(ByVal value As String)
            p_Customer = value
            RaiseEvent PropertyChanged(Me,
              New System.ComponentModel.PropertyChangedEventArgs("Customer"))
        End Set
    End Property

    Event PropertyChanged As System.ComponentModel.PropertyChangedEventHandler _
      Implements System.ComponentModel.INotifyPropertyChanged.PropertyChanged

    Public Sub New(ByVal loanAmount As Double,
                   ByVal interestRate As Double,
                   ByVal term As Integer,
                   ByVal customer As String)

        Me.LoanAmount = loanAmount
        Me.InterestRate = interestRate
        Me.Term = term
        p_Customer = customer
    End Sub
End Class

public class Loan : System.ComponentModel.INotifyPropertyChanged
{
    public double LoanAmount {get; set;}
    public double InterestRate {get; set;}
    public int Term {get; set;}

    private string p_Customer;
    public string Customer
    {
        get { return p_Customer; }
        set 
        {
            p_Customer = value;
            PropertyChanged(this,
              new System.ComponentModel.PropertyChangedEventArgs("Customer"));
        }
    }

    public event System.ComponentModel.PropertyChangedEventHandler PropertyChanged;

    public Loan(double loanAmount,
                double interestRate,
                int term,
                string customer)
    {
        this.LoanAmount = loanAmount;
        this.InterestRate = interestRate;
        this.Term = term;
        p_Customer = customer;
    }
}

Você também terá que criar um aplicativo simples que usa o Loan classe.

Crie um aplicativo de teste.

Para adicionar um projeto de aplicativo do Windows Forms para sua solução, o arquivo , aponte para Adde, em seguida, clique em Novo projeto.
No Add New Project caixa de diálogo, digite LoanApp como o nome do projeto e clique em OK para fechar a caixa de diálogo.
Em Solution Explorer, selecione o projeto LoanApp.
Sobre o projeto menu, clique em Set as StartUp Project.
No menu Project, escolha Add Reference.
No Add Reference caixa de diálogo, clique no projetos e selecione o projeto LoanClass.
Clique OK para fechar a caixa de diálogo.
No designer, adicione quatro TextBox controles no formulário.

No Editor de código, adicione o seguinte código:

Private WithEvents TestLoan As New LoanClass.Loan(10000.0, 0.075, 36, "Neil Black")

Private Sub Form1_Load() Handles MyBase.Load
    TextBox1.Text = TestLoan.LoanAmount.ToString
    TextBox2.Text = TestLoan.InterestRate.ToString
    TextBox3.Text = TestLoan.Term.ToString
    TextBox4.Text = TestLoan.Customer
End Sub

private LoanClass.Loan TestLoan = new LoanClass.Loan(10000.0, 0.075, 36, "Neil Black");

private void Form1_Load(object sender, EventArgs e)
{
    textBox1.Text = TestLoan.LoanAmount.ToString();
    textBox2.Text = TestLoan.InterestRate.ToString();
    textBox3.Text = TestLoan.Term.ToString();
    textBox4.Text = TestLoan.Customer;
}

Adiciona um manipulador de eventos para o PropertyChanged evento para o formulário usando o seguinte código:

Public Sub CustomerPropertyChanged(
      ByVal sender As Object,
      ByVal e As System.ComponentModel.PropertyChangedEventArgs
    ) Handles TestLoan.PropertyChanged

    MsgBox(e.PropertyName & " has been changed.")
End Sub

private void CustomerPropertyChanged(object sender, 
    System.ComponentModel.PropertyChangedEventArgs e)
{
    MessageBox.Show(e.PropertyName + " has been changed.");
}

Neste ponto, você pode criar e executar o aplicativo. Observe que os valores padrão da Loan classe aparecem em caixas de texto. Tente alterar o valor da taxa de juros de 7.5 para 7.1, feche o aplicativo e executá-lo novamente — o valor reverte para o padrão de 7.5.

No mundo real, taxas de juros alterar periodicamente, mas não necessariamente sempre que o aplicativo é executado. Em vez de fazer com que o usuário atualizar a taxa de juros sempre que o aplicativo é executado, é melhor preservar a taxa de juros mais recente entre instâncias do aplicativo. Na próxima etapa, você fará apenas isso adicionando serialização à classe de empréstimo.

O uso de serialização para manter o objeto.

Para persistir os valores para a classe de empréstimo, você deverá primeiro marcar a classe com o Serializable atributo.

Para marcar uma classe como serializável

Altere a declaração de classe para a classe de empréstimo da seguinte maneira:

<Serializable()>
Public Class Loan

[Serializable()]
public class Loan : System.ComponentModel.INotifyPropertyChanged
{

O Serializable atributo informa ao compilador que tudo o que a classe pode ser transmitido para um arquivo. Porque o PropertyChanged evento é tratado por um objeto de formulário do Windows, não pode ser serializado. O NonSerialized atributo pode ser usado para marcar os membros da classe que não devem ser persistentes.

Para impedir que um membro que está sendo serializado.

Altere a declaração para o PropertyChanged o evento da seguinte maneira:

<NonSerialized()>
Event PropertyChanged As System.ComponentModel.PropertyChangedEventHandler _
  Implements System.ComponentModel.INotifyPropertyChanged.PropertyChanged

[field: NonSerialized()]
public event System.ComponentModel.PropertyChangedEventHandler PropertyChanged;

A próxima etapa é adicionar o código de serialização para o aplicativo LoanApp. Para serializar a classe e gravá-lo em um arquivo, você usará o System.IO e System.Xml.Serialization namespaces. Para evitar digitar os nomes totalmente qualificados, você pode adicionar referências a bibliotecas de classe necessária.

Para adicionar referências aos namespaces

Adicione as seguintes instruções sobre o Form1 classe:
```
Imports System.IO
Imports System.Runtime.Serialization.Formatters.Binary
```
```
using System.IO;
using System.Runtime.Serialization.Formatters.Binary;
```
Nesse caso, você está usando um formatador binário para salvar o objeto em um formato binário. Posteriormente nesta explicação passo a passo, você irá modificar o código para salvar o objeto em um formato SOAP.

A próxima etapa é adicionar código para desserializar o objeto do arquivo quando o objeto é criado.

Para desserializar um objeto

Adicione uma constante para a classe para o nome do arquivo de dados serializados.

Const FileName As String = "..\..\SavedLoan.bin"

const string FileName = @"..\..\SavedLoan.bin";

Modificar o código do Form1_Load o procedimento de evento da seguinte maneira:

Private WithEvents TestLoan As New LoanClass.Loan(10000.0, 0.075, 36, "Neil Black")

Private Sub Form1_Load() Handles MyBase.Load
    If File.Exists(FileName) Then
        Dim TestFileStream As Stream = File.OpenRead(FileName)
        Dim deserializer As New BinaryFormatter
        TestLoan = CType(deserializer.Deserialize(TestFileStream), LoanClass.Loan)
        TestFileStream.Close()
    End If

    AddHandler TestLoan.PropertyChanged, AddressOf Me.CustomerPropertyChanged

    TextBox1.Text = TestLoan.LoanAmount.ToString
    TextBox2.Text = TestLoan.InterestRate.ToString
    TextBox3.Text = TestLoan.Term.ToString
    TextBox4.Text = TestLoan.Customer
End Sub

private LoanClass.Loan TestLoan = new LoanClass.Loan(10000.0, 0.075, 36, "Neil Black");

private void Form1_Load(object sender, EventArgs e)
{
    if (File.Exists(FileName))
    {
        Stream TestFileStream = File.OpenRead(FileName);
        BinaryFormatter deserializer = new BinaryFormatter();
        TestLoan = (LoanClass.Loan)deserializer.Deserialize(TestFileStream);
        TestFileStream.Close();
    }

    TestLoan.PropertyChanged += this.CustomerPropertyChanged;

    textBox1.Text = TestLoan.LoanAmount.ToString();
    textBox2.Text = TestLoan.InterestRate.ToString();
    textBox3.Text = TestLoan.Term.ToString();
    textBox4.Text = TestLoan.Customer;
}

Observe que você primeiro deve verificar se o arquivo existe. Se ele existir, crie um Stream classe para ler o arquivo binário e um BinaryFormatter classe para converter o arquivo. Você também precisa converter o tipo de fluxo para o tipo de objeto do empréstimo.

Em seguida, você deve adicionar código para salvar os dados inseridos nas caixas de texto para o Loan classe e em seguida, você precisa serializar a classe para um arquivo.

Para salvar os dados e serializar a classe

Adicione o seguinte código para o Form1_FormClosing procedimento de evento:

Private Sub Form1_FormClosing() Handles MyBase.FormClosing
    TestLoan.LoanAmount = CDbl(TextBox1.Text)
    TestLoan.InterestRate = CDbl(TextBox2.Text)
    TestLoan.Term = CInt(TextBox3.Text)
    TestLoan.Customer = TextBox4.Text

    Dim TestFileStream As Stream = File.Create(FileName)
    Dim serializer As New BinaryFormatter
    serializer.Serialize(TestFileStream, TestLoan)
    TestFileStream.Close()
End Sub

private void Form1_FormClosing(object sender, FormClosingEventArgs e)
{
    TestLoan.LoanAmount = Convert.ToDouble(textBox1.Text);
    TestLoan.InterestRate = Convert.ToDouble(textBox2.Text);
    TestLoan.Term = Convert.ToInt32(textBox3.Text);
    TestLoan.Customer = textBox4.Text;

    Stream TestFileStream = File.Create(FileName);
    BinaryFormatter serializer = new BinaryFormatter();
    serializer.Serialize(TestFileStream, TestLoan);
    TestFileStream.Close();
}

Neste ponto, novamente construir e executar o aplicativo. Inicialmente, os valores padrão aparecem nas caixas de texto. Tente alterar os valores e digite um nome na quarta caixa de texto. Feche o aplicativo e execute-o novamente. Observe que agora aparecem novos valores nas caixas de texto.

O objeto usando um formato SOAP de persistência

Até agora, este exemplo tenha demonstrado como persistir um objeto em um arquivo de texto usando um formato binário. Um formato binário é bom para a maioria dos aplicativos do Windows. Para aplicativos da Web ou serviços da Web, você talvez queira persistir o objeto para um arquivo XML usando um formato SOAP, que faz com que o objeto fácil compartilhar.

Para persistir o objeto para um formato SOAP, você deve primeiro fazer referência a SoapFormatter classe. O SoapFormatter classe reside em seu próprio namespace: System.Runtime.Serialization.Formatters.Soap.

Para manter o objeto usando o formato SOAP

Em Solution Explorer, selecione o projeto LoanApp.
No menu Project, escolha Add Reference.
No Add Reference caixa de diálogo, clique no .NET e selecione o System.Runtime.Serialization.Formatters.Soap componente.
Clique OK para fechar a caixa de diálogo.

No O Editor de código, adicione a seguinte instrução na parte superior da Form1 módulo:

Imports System.Runtime.Serialization.Formatters.Soap

using System.Runtime.Serialization.Formatters.Soap;

Alterar o nome do arquivo de SavedLoan.bin para SavedLoan.xml.
No Form1_Load o procedimento de evento, alterar a declaração da deserializer variável para o seguinte:
```
Dim deserializer As New SoapFormatter
```
```
SoapFormatter deserializer = new SoapFormatter();
```
No Form1_FormClosing o procedimento de evento, alterar a declaração da serializer variável para o seguinte:
```
Dim serializer As New SoapFormatter
```
```
SoapFormatter serializer = new SoapFormatter();
```

Neste ponto, você pode criar e testar o aplicativo. Quando o aplicativo foi executado pela primeira vez, o arquivo SavedLoan.xml é criado. Para exibir o arquivo, selecione o Mostrar todos os arquivos opção em Solution Explorer; ele está localizado no nó Bin do projeto de aplicativo do Windows.

Observação
Se você já estiver em Mostrar todos os arquivos modo, você deve atualizar a exibição clicando em Atualizar da Exibir menu para ver o arquivo.

Observe que três membros da LoanClass são exibidos em formato XML. Alterar o valor InterestRate no arquivo XML, salvá-lo e, em seguida, executar o aplicativo novamente. A nova taxa de juros é exibido na segunda caixa de texto.

Consulte também

Conceitos

Guia de Programação C#

Outros recursos

Serialização (C# e Visual Basic)

Guia de programação Visual Basic

Partilhar via