Compartilhar via


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

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çãoObservaçã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 de segurançaObservaçã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.

Observação de segurançaObservaçã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çãoObservaçã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

  1. Crie um novo projeto de biblioteca de classe e o nome "loanclass". Para obter mais informações, consulte Como: Criar soluções e projetos.

  2. 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.

  3. 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.

  1. Para adicionar um projeto de aplicativo do Windows Forms para sua solução, o arquivo , aponte para Adde, em seguida, clique em Novo projeto.

  2. 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.

  3. Em Solution Explorer, selecione o projeto LoanApp.

  4. Sobre o projeto menu, clique em Set as StartUp Project.

  5. No menu Project, escolha Add Reference.

  6. No Add Reference caixa de diálogo, clique no projetos e selecione o projeto LoanClass.

  7. Clique OK para fechar a caixa de diálogo.

  8. No designer, adicione quatro TextBox controles no formulário.

  9. 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;
    }
    
  10. 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

  1. 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";
    
  2. 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

  1. Em Solution Explorer, selecione o projeto LoanApp.

  2. No menu Project, escolha Add Reference.

  3. No Add Reference caixa de diálogo, clique no .NET e selecione o System.Runtime.Serialization.Formatters.Soap componente.

  4. Clique OK para fechar a caixa de diálogo.

  5. 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;
    
  6. Alterar o nome do arquivo de SavedLoan.bin para SavedLoan.xml.

  7. 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();
    
  8. 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çãoObservaçã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