Vamos recordar os passos que utilizamos nos Capítulos 10 e 11, para conectar e retornar dados a partir de uma fonte de dados:

1.         Criamos um objeto OleDbConnection ou SqlConnection.

2.         Criamos um objeto OleDbDataAdapter ou SqlDataAdapter. Passamos como parâmetros para este objeto, uma string SQL e uma referência para o objeto Connection, criado no item 1.

3.         Criamos um objeto do tipo DataSet.

4.         Utilizamos o método Fill, do objeto DataAdapter, para executar o comando SQL passado como parâmetro, na criação do objeto DataAdapter e retornar os dados para o objeto DataSet.

5.         Neste momento temos um objeto DataSet com dados. Podemos criar um objeto DataView para ligar estes dados (Data Bound) a um controle, como por exemplo DataGrid ou DropDownList.

É importante salientar que o objeto DataSet não mantém nenhuma conexão com o banco de dados, ou seja, o mesmo está desconectado do banco de dados. Para fazermos alterações nos dados, e enviar estas alterações de volta para o banco de dados, utilizaremos a seguinte abordagem:

• Criaremos um objeto do tipo DataTable, ligado a uma das tabelas do DataSet.
• Faremos as alterações, inclusões e exclusões necessárias, utilizando os métodos respectivos do objeto DataTable.
• Utilizaremos métodos do objeto DataAdapter para enviar as alterações de volta para o banco de dados. Se não utilizarmos estes métodos, as alterações não serão enviadas para o banco de dados e serão perdidas quando a página for encerrada.

O objeto DataTable – alterações nos dados desconectados.

O objeto DataTable faz parte do namespace System.Data. Este objeto é utilizado para representar uma tabela de dados na memória.

Podemos criar um objeto DataTable completamente independente, isto é, podemos definir através de código as colunas do objeto e adicionar registros. Outra maneira é criar o objeto associado a uma tabela de um objeto DataSet.

Uma das maneiras de criar um objeto DataSet é utilizando o próprio construtor da classe DataTable, conforme o exemplo a seguir:

DataTable MinhaTabela = new DataTable("Pedidos");

No exemplo a seguir, criamos um objeto DataTable, utilizando o método Add, da coleção Tables, de um objeto DataSet:

DataSet MeuDataSet = new DataSet();
DataTable MinhaTabela = MeuDataSet.Tables.Add("Pedidos");

O número máximo de linhas que um objeto DataTable pode conter é: 16.777.216. O objeto DataTable também possui uma coleção de objetos do tipo Constraint. Podemos utilizar esta coleção para implementar a “Integridade dos dados”. Por exemplo, podemos utilizar uma Constraint para definir que a coluna Salário não pode conter valores maiores do que R$ 10.000,00 e que a coluna DiasDeFérias deve conter um valor entre 1 e 30.

Importante! No momento da criação do objeto DataTable, o construtor da classe DataTable faz distinção entre maiúsculas e minúsculas, para o nome da tabela. Por exemplo, os dois comandos a seguir, criam dois objetos DataTable distintos:

      DataTable MinhaTabela = new DataTable("Pedidos");

      DataTable MinhaOutraTabela = new DataTable("pedidos");

Na Tabela 12.1 temos a descrição das principais propriedades da classe DataTable.

Tabela 12.1 Principais propriedades da classe DataTable.

Na Tabela 12.2 temos a descrição dos principais métodos da classe DataTable.

Tabela 12.2 Principais métodos da classe DataTable.

Inserindo, excluindo e adicionando dados com o objeto DataTable.

Vamos apresentar alguns exemplos onde faremos as seguintes operações:

• Adição de uma nova linha.
• Exclusão de uma linha.
• Alteração de uma linha.

Neste tópico aprenderemos a fazer as alterações no conjunto de dados da tabela representada pelo objeto DataTable. Porém ainda não faremos a sincronização de dados com o banco de dados. Iremos comprovar este fato exibindo os dados do DataTable, após as alterações e conferindo que as mesmas não foram enviadas para o banco de dados. Isso comprova o modelo desconectado do ASP.NET. Nos próximos tópicos aprenderemos a fazer a sincronização com o banco de dados.

Exemplo 1: Vamos criar um exemplo onde acessamos os dados da  tabela Clientes, do banco de dados NorthWind.mdb. Retornaremos apenas os clientes para o Brasil.Utilizando código, no evento Page_Load, adicionaremos dois novos registros ao objeto DataTable. Exibiremos a tabela original em um DataGrid e a tabela com os novos registros em um segundo DataGrid. Em seguida abriremos o banco de dados NorthWind.mdb e comprovaremos que as adições não foram enviadas para o banco de dados.

Na Listagem 12.1 temos o código para o exemplo proposto.

Listagem 12.1 – O objeto DataTable – Chjap12Ex1.aspx.

Clique aqui para visualizar o código da listagem 12.1

Digite o código da Listagem 12.1 e salve o mesmo em um arquivo chamado chap12ex1.aspx, na pasta chap12, dentro da pasta wwwroot, conforme descrito no item: “Check List para acompanhar os exemplos deste livro”, no Capítulo 6.

Para acessar esta página utilize o seguinte endereço:

http://localhost/chap12/chap12ex1.aspx

Ao carregar a página você obtém o resultado indicado na Figura 12.1.

Figura 12.1 Utilizando o objeto DataTable – Chap12ex1.aspx.

Comentários sobre o código do exemplo – Chap12ex1.aspx.

• Na seção de apresentação da página, utilizamos dois controles DataGrid – MinhaGrade1 e MinhaGrade 2. No controle MinhaGrade1 exibimos os registros retornados da tabela Clientes; no controle MinhaGrade2 exibimos os dados, após termos adicionados duas linhas ao objeto DataTable.
• Utilizamos o evento Page_Load da página, para fazer a conexão com o banco de dados. Neste evento temos a seguinte seqüência de passos:

1.         Conectamos com o banco de dados NortWhind.mdb e retornamos somente os Clientes do Brasil. Em seguida utilizamos um objeto DataView para ligar os dados retornados com o controle DataGrid1. Esta parte do código já foi utilizada em outros exemplos, dos capítulos anteriores.

2.         Em seguida criamos um objeto DataTable, chamado Clientes2, objeto este ligado a primeira tabela do objeto DataSet, que no nosso caso é a tabela Clientes. Na prática estamos criando uma cópia da tabela Clientes, na tabela Clietnes2.

DataTable  Clientes2 = ds.Tables[0];

3.         Na seqüência declaro um objeto do tipo DataRow – Linha, defino o valor de cada coluna e utilizo o método Add, da coleção Rows da tabela Clientes2, para adicionar a linha a coleção de linhas da tabela.

//  Declaro um objeto do tipo DataRow.

DataRow Linha = Clientes2.NewRow();

//  Defino os valores para as colunas da linha a ser inserida.

Linha["CódigoDoCliente"]="XXYYK";

Linha["NomeDaEmpresa"]="ABC  Ltda.";

Linha["Endereço"]="Rua das letras,  123";

Linha["Telefone"]="222-2222";

Linha["País"]="Brasil";

//  Adiciona a linha à coleção de linhas da tabela Clientes2.

Clientes2.Rows.Add(Linha);

4.         Repetimos as operações do item anterior, para adicionar mais uma linha:

//  Declaro um objeto do tipo DataRow.

DataRow Linha2 = Clientes2.NewRow();

//  Defino os valores para a linha a ser inserida.

Linha2["CódigoDoCliente"]="WWMMK";

Linha2["NomeDaEmpresa"]="LMN  Ltda.";

Linha2["Endereço"]="Rua dos números,  123";

Linha2["Telefone"]="555-5555";

Linha2["País"]="Brasil";

//  Adiciona a linha à coleção de linhas da tabela Clientes2.

Clientes2.Rows.Add(Linha2);

5.         Por último faço a ligação entre o objeto DataTable – Clientes2 e o controle DataGrid – MinhaGrade2:

MnhaGrade2.DataSource = Clientes2.DefaultView;

MinhaGrade2.DataBind();

6.         Neste momento, conforme pode ser confirmado pela Figura 12.1, temos duas novas linhas adicionadas ao objeto Clientes2. Este objeto segue o modelo “desconectado”, do ADO.NET. Isto significa que as alterações feitas no objeto DataTable (no caso adição de duas novas linhas), ainda não foi enviada para o banco de dados NorthWind.mdb. Isto pode ser facilmente comprovado.

Abra o Microsoft Access e abra o  banco de dados NorthWind.mdb. Crie uma consulta baseada na tabela Clientes e defina como critério “Brasil”, para o campo País. Serão exibidos apenas os Clientes do Brasil. Observe que os dois novos clientes (códigos XXYYK e WWMMK) não foram adicionados a tabela Clientes, conforme indicado na Figura 12.2.

Figura 12.2 O banco de dados NorthWind.mdb ainda não foi atualizado.

7.         Para atualizar o banco de dados, isto é, enviar de volta as alterações feitas no objeto DataTable, temos que utilizar alguns métodos do objeto DataAdapter. Aprenderemos a utilizar estes métodos mais adiante, neste capítulo.

Vamos aprender a utilizar mais alguns métodos do objeto DataTable, antes de aprenderemos a sincronizar as alterações deste com o banco de dados.

Exemplo 2: Vamos modificar um pouco o exemplo anterior. Ao invés de adicionarmos duas novas linhas, vamos excluir as duas primeiras linhas do objeto DataTable.

Vamos exibir os dados originais, retornados do banco de dados NorthWind.mdb e a tabela Clientes2, após as exclusões dos registros.

Na Listagem 12.2 temos o código para o exemplo proposto. Vou excluir o comentário da parte básica da listagem, parte esta que já explicamos em exemplos anteriores. Somente incluirei comentários nos pontos da listagem onde temos novidades.

Listagem 12.2 – O objeto DataTable – Excluindo linhas.

Clique aqui para visualizar o código da listagem 12.2

Digite o código da Listagem 12.2 e salve o mesmo em um arquivo chamado chap12ex2.aspx, na pasta chap12, dentro da pasta wwwroot, conforme descrito no item: “Check List para acompanhar os exemplos deste livro”, no Capítulo 6.

Para acessar esta página utilize o seguinte endereço:

http://localhost/chap12/chap12ex2.aspx

Ao carregar a página você obtém o resultado indicado na Figura 12.3.

Figura 12.3 Utilizando o objeto DataTable – Chap12ex2.aspx.

Comentários sobre o código do exemplo – Chap12ex1.aspx.

• Para excluir uma linha de um objeto DataTable, utilizamos o método Delete, da coleção de linhas Rows. A sintaxe para este método é a seguinte:

MeuDataTable.Rows[número_da_linha].Delete();

O número da primeira linha é zero, o da segunda linha é 1 e assim por diante.

Após a chamada deste método a linha é marcada para exclusão. Podemos retornar a linha ao seu estado normal, chamando o método RejectChanges. A chamada deste método faz com que sejam descartadas todas as alterações efetuadas, desde a última chamada do método AcceptChanges. No nosso exemplo, excluímos as duas primeiras linhas, depois chamamos o método RejectChanges, para cancelar as exclusões. Em seguida exibimos os dados do objeto Clientes2, no controle MinhaGrade2:

      Clientes2.Rows[0].Delete();

      Clientes2.Rows[1].Delete();

      // Neste momento as linhas foram apenas  marcadas para exclusão,

      // porém continuam no objeto DataTable,  conforme pode ser confirmado

      // pelos dados exibidos no controle  MinhaGrade2.

      // Vamos descartar as alterações. Para  isto chamaremos o método

      //  RejectChanges(), do objeto DataTable. 

      // A chamada deste método, fará com que  as linhas marcadas para 

      // exclusão, sejam restauradas ao seu  estatus padrão e, portanto,

      // exibidas no DataGrid MinhaGrade2.

      Clientes2.RejectChanges();

      MinhaGrade2.DataSource =  Clientes2.DefaultView;

      MinhaGrade2.DataBind();

       Conforme podemos comprovar na Figura 12.3, as linhas não foram excluídas.

• Em seguida marcamos as duas primeiras linhas para exclusão, porém agora chamamos o método AcceptChanges, para confirmar as exclusões. Exibimos os resultados no controle DataGrid3:

      // Agora excluo novamente as duas  primeiras linhas 

      // índice 0 e índice1.

      // Para excluir uma linha, utilizo o  método

      // Delete, da coleção Rows, do objeto  DataTable.

      //  **************************************************     

      Clientes2.Rows[0].Delete();

      Clientes2.Rows[1].Delete();

      // Para fazer a exclusão definitiva das  linhas, vamos

      // chamar o método AcceptChanges(), do  objeto DataTable.

      // Após a chamada deste método, as linhas  são excluídas

      // do objeto DataTable, conforme pode ser  confirmado

      // pelos dados exibidos no controle  MinhaGrade3

      Clientes2.AcceptChanges();

      MinhaGrade3.DataSource =  Clientes2.DefaultView;

      MinhaGrade3.DataBind();

       Conforme podemos comprovar na Figura 12.3, as linhas foram realmente excluídas.

• Mais uma vez cabe ressaltar que estas exclusões não foram enviadas para o banco de dados. Foram feitas no objeto DataTable que é um objeto que segue o modelo “desconectado” do ADO.NET. Aprenderemos a sincronizar as alterações com o banco de dados, ainda neste capítulo.

Exemplo 3: Vamos aprender a alterar os dados de uma linha do objeto DataSet. Vamos apresentar um exemplo, onde temos uma Caixa de Combinação com o nome de todos os Clientes do Brasil. O usuário seleciona um nome na lista e clica no botão Editar. O respectivo registro será retornado e os valores exibidos em controles do tipo TextBox, para que o usuário possa alterá-los, com exceção do campo CódigoDoCliente. Uma vez feitas as alterações necessárias, o usuário clica no botão Salvar. Os novos valores são salvos e a listagem de Clientes é novamente exibida para que possamos confirmar se as alterações foram feitas.

Na Listagem 12.3 temos o código para o exemplo proposto. Vou excluir o comentário da parte básica da listagem, parte esta que já explicamos em exemplos anteriores. Somente incluirei comentários nos pontos da listagem onde temos novidades. O exemplo é um pouco longo pois, além das técnicas para edição de registros, vamos aprender a tratar eventos, localizar dados automaticamente, ocultar e exibir controles utilizando código e outras técnicas úteis.

Listagem 12.3 – O objeto DataTable – Editando linhas.

Clique aqui para visualizar o código da listagem 12.3

Digite o código da Listagem 12.3 e salve o mesmo em um arquivo chamado chap12ex3.aspx, na pasta chap12, dentro da pasta wwwroot, conforme descrito no item: “Check List para acompanhar os exemplos deste livro”, no Capítulo 6.

Para acessar esta página utilize o seguinte endereço:

http://localhost/chap12/chap12ex3.aspx

Ao carregar a página você obtém o resultado indicado na Figura 12.4, onde é apresentada uma lista com o nome dos clientes do Brasil e cinco controles do tipo TextBox, em branco.

Figura 12.4 Uma lista com os clientes do Brasil – Chap12ex3.aspx.

Na lista de Clientes selecione “Tradição Hipermercados”. Observe que, automaticamente, as informações do registro referente ao cliente selecionado, são exibidas nos controles do formulário, conforme indicado na Figura 12.5.

Figura 12.5 O registro do cliente é automaticamente localizado.

Clique no campo Nome da Empresa e altere o valor para: Tradição Hipermercados XYZ.

Clique no campo Telefone e altere o número do telefone para: (011-11) 555-2167.

Dê um clique no botão Atualizar dados. Na coluna do meio são exibidos os valores originais do registro para o cliente Tradição Hipermarcados e, na coluna da direita, são exibidos os valores já alterados, conforme indicado na Figura 12.6.

Figura 12.6 Exibindo os valores antes a depois da edição.

Cabe, mais uma vez, resaltar que os valores foram alterados no objeto DataTable, desconectado do banco de dados. As alterações ainda não foram enviadas para o banco de dados NorthWind.mdb. Para comprovar isto, basta abrir o banco de dados NorthWind.mdb e verificar que o registro para o cliente Tradição Hipermercados não foi alterado. No próximo tópico aprenderemos a sincronizar o objeto DataTable com o banco de dados.

Comentários sobre o código do exemplo – Chap12ex1.aspx.

• O exemplo é um pouco extenso, porém veremos que a sua funcionalidade é bastante simples.
• Declaramos algumas variáveis com escopo de página, ou seja, fora de qualquer procedimento. Estas variáveis serão utilizadas em diversos procedimentos da página, por isso foram declaradas com escopo de página:

  // Declaro variáveis que serão globais para a  página. 

  OleDbDataAdapter  MeuComando;

  String auxSQL1;

  String auxSQL2;

  String comandoSQL;

  DataSet ds = new DataSet();

   OleDbConnection MinhaConexão;

  String DefineConexão = "PROVIDER=MICROSOFT.JET.OLEDB.4.0;" +

                         "DATA SOURCE=c:\\meus  documentos\\NorthWind.mdb";

• No evento Page_Load da página, fazemos a conexão com o banco de dados NorthWind.mdb, retornamos dados da tabela Clientes e fazemos a ligação com o controle MinhaLista. O controle MinhaLista exibe uma listagem com o nome dos clientes do Brasil. O código do evento Page_Load somente é executado quando a página é carregada pela primeira vez, ou seja, quando não for um PostBack. Observe que, no início do procedimento, testamos se é ou não um PostBack:

if  (!Page.IsPostBack)

O operador “!” é o operador not. O teste é equivalente a dizer: “Se não for um PostBack, execute o código dentro do if”. O código para conexão com o banco de dados e ligação com o controle MinhaLista é semelhante ao código utilizada em exemplos anteriores.

No evento Page_Load, também fazemos uma chamada ao procedimento OcultaControles. Este procedimento oculta todos os controles da terceira coluna, os quais somente voltarão a ser exibidos quando o usuário editar um registro:

OcultaControles();

Na definição do controle MinhaLista, definimos diferentes valores para as propriedades DataTextField. A propriedade DataTextField, define qual o campo que fornece os valores que serão exibidos para cada item da lista. No nosso exemplo, como queríamos que fossem exibidos os nomes dos clientes, definimos a propriedade DataTextField=”NomeDaEmpresa”. A propriedade DataValueField define qual o valor associada com cada item da lista. Em outras palavras, quando o usuário seleciona um cliente na lista, qual o valor que ficará associado com a propriedade Value da lista. Poderia ser o mesmo campo que define o texto de cada item. Porém, para o nosso exemplo, queremos que, ao selecionar um cliente, seja definido como valor do elemento selecionado da lista, o respectivo CódigoDoCLiente. Por isso definimos a propriedade DataValueField=”CódigoDoCliente”. Na prática, quando o usuário selecionar, por exemplo, o cliente “Tradição Hipermercados “, o valor associado será “TRADH”, que é o código do cliente “Tradição Hipermercados”. Mais adiante veremos que o código do cliente é utilizado para localizar o registro do cliente. A seguir temos a definição do controle MinhaLista:

<asp:DropDownList 

                        id="MinhaLista"

                        runat="server"

                        BackColor="#c0c0c0"

                        Font-Bold="True"

                        DataTextField  = "NomeDaEmpresa"

                        DataValueField  = "CódigoDoCliente"

                        AutoPostBack  = "True"

                        onSelectedIndexChanged  = "ClienteSelecionado"

> 

</asp:DropDownList>

• Para alinhar os diversos controles do formulário, utilizamos uma tabela de três colunas. Na primeira coluna são exibidos os rótulos para cada campo. Na segunda coluna são exibidos os valores originais do registro. Na terceira coluna são exibidos os valores após o usuário ter feito alterações.
• Quando é selecionado um cliente, na lista de clientes, é disparado o evento onSelectedIndexChanged. Para tratar este evento, definimos o procedimento ClienteSelecionado. Vamos analisar o funcionamento deste procedimento.

O procedimento ClienteSelecionado inicia ocultando os controles da terceira coluna:

OcultaControles();

Depois executamos uma série de comandos para conectar com o banco de dados. Estes comandos são idênticos aos utilizados no evento Page_Load.

Em seguida criamos um objeto DataTable, associado a primeira tabela do objeto DataSource – ds:

DataTable Clientes = ds.Tables[0];

Agora vamos definir a chave primária para a tabela Clientes:                            

Clientes.PrimaryKey = new DataColumn[] {Clientes.Columns["CódigoDoCliente"]};

Este comando precisa de mais alguns comentários. Para definir a chave primária, utilizamos a propriedade PrimaryKey, do objeto DataTable. Devemos passar um objeto do tipo DataColumn para a propriedade PrimaryKey. O objeto DataColumn é um array de objetos do tipo Column. O Array contém a referência a uma ou mais colunas, que formam a chave primária. No nosso exemplo, definimos apenas a coluna CódigoDoCliente, como sendo a chave primária.

Agora é hora de criar um objeto do tipo Linha, o qual contém os valores para o cliente selecionado. Para localizar o registro do cliente que foi selecionado na lista de clientes, utilizamos o método Find, da coleção Rows, da tabela Clientes:

DataRow Linha = Clientes.Rows.Find(MinhaLista.SelectedItem.Value);

Como  parâmetro para o método Find, nos passamos o valor selecionado na lista MinhaLista. O método Find recebe um valor e pesquisa na coluna Chave Primária da tabela.Caso encontre o valor passado como parâmetro, o registro correspondente será retornado. Observe que definimos o campo CódigoDoCliente como Chave Primária da tabela Clientes e a propriedade DataValueField, da lista de clientes como sendo CódigoDoCliente. Agora ficou mais claro o porque desta definição. Ao selecionarmos um cliente na lista, é associado o valor do CódigoDoCliente, com o item selecionado. Este valor é utilizado para localizar o registro do cliente.

Uma vez localizado o registro do cliente, vamos definir o conteúdo dos controles do tipo TextBox, da segunda coluna, como sendo igual aos valores dos campos do registro do cliente:

            // Defino os valores dos controles TextBox da seção de apresentação.

            txtCódigoDoCliente.Text = Linha["CódigoDoCliente"].ToString();

            txtNomeDaEmpresa.Text   = Linha["NomeDaEmpresa"].ToString();

            txtEndereço.Text        = Linha["Endereço"].ToString();

            txtTelefone.Text        = Linha["Telefone"].ToString();

            txtPaís.Text            = Linha["País"].ToString();

Em resumo, o procedimento ClienteSelecionado faz o seguinte:

1.         Oculta os controles da terceira coluna.

2.         Conecta com o banco de dados.

3.         Cria um objeto DataTable - Clientes.

4.         Localiza o registro correspondente ao cliente selecionado na lista de clientes.

5.         Exibe os dados do cliente, nos controles TextBox da segunda coluna.

• Uma vez exibidos os dados do cliente, o usuário poderá alterar o conteúdo dos campos, com exceção do campo CódigoDoCliente, que está desabilitado para alterações ( Enabled=”False”). O usuário faz as alterações necessárias e clica no botão “Atualizar dados”. Ao clicar neste botão é disparado o procedimento “AtualizaRegistro”.

O procedimento AtualizaRegistro faz a conexão com o banco de dados e localiza o registro do cliente que está sendo editado. Neste caso são retornados os valores originais do registro, sem as alterações feitas pelo usuário. Esta parte do procedimento é idêntica a utilizada no procedimento ClienteSelecionado.

Uma vez localizado o registro, com os valores originais, utilizamos uma série de variáveis auxiliares, para armazenar os valores originais para o registro do cliente:

String auxCódigoDoCliente = Linha["CódigoDoCliente"].ToString();

      String auxNomeDaEmpresa   = Linha["NomeDaEmpresa"].ToString();

      String auxEndereço        = Linha["Endereço"].ToString();

      String auxTelefone        = Linha["Telefone"].ToString();

      String auxPaís            = Linha["País"].ToString();

Estas variáveis serão utilizadas para exibir os valores originais, na segunda coluna.

Finalmente chegamos ao momento de fazer a edição no registro do cliente selecionado. Para editar um registro, chamamos o método BeginEdit da linha, atribuímos os novos valores a cada campo da linha e chamamos o método EndEdit();

            // Agora vamos editar o valor da  linha.

            Linha.BeginEdit();

                        Linha["CódigoDoCliente"] = txtCódigoDoCliente.Text;

                        Linha["NomeDaEmpresa"]   = txtNomeDaEmpresa.Text;

                        Linha["Endereço"]        = txtEndereço.Text;

                        Linha["Telefone"]        = txtTelefone.Text;

                        Linha["País"]            = txtPaís.Text;

            Linha.EndEdit();

Em seguida tornamos os controles da terceira coluna visíveis e exibimos, nestes controles, o registro já alterado:

                        // Defino o valor dos  controles da terceira coluna

                        // como sendo igual aos  novos valores da linha

                        txtMostraAtualizado.Visible=true;                        

                        txtNovoCódigoDoCliente.Text  = Linha["CódigoDoCliente"].ToString();

                        txtNovoCódigoDoCliente.Visible  =true;

                        txtNovoNomeDaEmpresa.Text  = Linha["NomeDaEmpresa"].ToString();

                        txtNovoNomeDaEmpresa.Visible  = true;

                        txtNovoEndereço.Text =  Linha["Endereço"].ToString();

                        txtNovoEndereço.Visible=true;

                        txtNovoTelefone.Text =  Linha["Telefone"].ToString();

                        txtNovoTelefone.Visible  = true;

                        txtNovoPaís.Text =  Linha["País"].ToString();

                        txtNovoPaís.Visible=true;

                        txtMensagem.Visible=true;

Para finalizar, exibimos, na Segunda coluna, os valores originais do registro. Para isso fazemos uso das variáveis auxiliares criadas anteriormente, variáveis estas que contém os valores originais do registro, isto é, antes da edição:

                        // Exibo na segunda  coluna, os valores originais,

                        // obtidos a partir das  variáveis auxiliares 

                        // criadas  anteriormente.

                        txtCódigoDoCliente.Text  = auxCódigoDoCliente;

                        txtNomeDaEmpresa.Text    = auxNomeDaEmpresa;

                        txtEndereço.Text         = auxEndereço;

                        txtTelefone.Text         = auxTelefone;

                        txtPaís.Text             = auxPaís;

Em resumo, o procedimento AtualizaRegistro faz o seguinte:

1.         Conecta com o banco de dados.

2.         Cria um objeto DataTable - Clientes.

3.         Localiza o registro correspondente ao cliente selecionado na lista de clientes.

4.         Atribui os valores antes da edição à variáveis auxiliares.

5.         Edita o registro.

6.         Exibe os novos valores na terceira coluna.

7.         Exibe os valores originais na segunda coluna.

O exemplo é longo mas salienta uma série de técnicas úteis que podem ser, facilmente, adaptadas para as aplicações que o leitor venha a desenvolver com ASP.NET.

Agora é hora de aprendermos a sincronizar as alterações feitas em um objeto DataTable, com o banco de dados, de tal forma que estas alterações sejam enviadas de volta ao banco de dados.