Acessando banco de dados em .NET – Parte 3 (final)

O artigo de hoje finaliza a série de 3 artigos sobre as informações básicas de ADO .NET para você já começar a desenvolver aplicações acessando banco de dados. Neste artigo irei abordar o acesso desconectado a banco de dados.

por Marden Menezes

Olá pessoal! O artigo de hoje finaliza a série de 3 artigos sobre as informações básicas de ADO .NET para você já começar a desenvolver aplicações acessando banco de dados. Nessa semana irei falar de acesso desconectado a banco de dados.

Há aplicações em que as informações não mudam constantemente e pode-se utilizar uma maneira diferente de obtê-las, economizando recursos de rede. Essa idéia é descrita no modelo desconectado de acesso a dados.

O MODELO DESCONECTADO AO BANCO DE DADOS

No modelo desconectado, a idéia é ter uma cópia do banco de dados (ou um subconjunto dele) na memória, evitando ter que utilizar a conexão ao banco de dados em excesso apenas para recuperar uma informação. A idéia então é se conectar uma vez ao banco, recuperar o banco para a memória ou para um arquivo XML e depois ficar usando esse banco de dados na sua aplicação. Caso seja necessária uma modificação, como por exemplo atualizar algum dado, a modificação é feita nesse banco na memória e depois pode-se atualizar o do servidor com essas novas informações.

O DATASET

O objeto mais importante desse modelo de dados é o DataSet, que representa a cópia total ou de parte da base de dados. O DataSet consegue espelhar detalhadamente o BD, tendo em sua formação objetos DataTables (representando as tabelas do banco), Constraints, relacionamentos, etc...

O interessante é ver que os objetos DataTable também representam perfeitamente tabelas, possuindo uma coleção de DataRows (representando as linhas) e de DataColumns, representando as colunas.

É importante lembrar que o DataSet não tem conhecimento algum do local original dos dados que ele contém. Isso permite ao DataSet ser totalmente independente de banco de dados. Podendo então ser usado como objeto de negócios em uma aplicação dividida em camadas, podendo ser passado entre as camadas sem nenhum ônus. Por ser independente de base de dados, o DataSet está presente no namespace System.Data e não possui prefixo Sql ou OleDb como os outros objetos.

Para criar um DataSet, temos dois diferentes construtores:

• new DataSet() - construtor vazio
• new DataSet(string nome) - recebe o nome do DataSet que será guardado na propriedade DataSetName do dataSet.

Após criado o DataSet, é preciso preenche-lo com dados! Podemos fazer isso na mão, inserindo dados um a uma (inserindo uma nova DataRow, por exemplo), ou podemos inserir os dados vindos do banco de dados. Como o DataSet não sabe de onde vêm os dados que ele contém, algum outro objeto deve fazer a ligação entre ele e o banco. O XXXDataAdapter é o objeto que se liga ao Banco de dados para comunicar com o DataSet.

O XXXDataAdapter pode ser criado das seguintes formas, lembrando que ele é dependendete do banco de dados, então o prefixo que será colocado no lugar do XXX depende do banco de dados, como foi explicado no artigo de número 2!

• new XXXDataAdapter() - construtor vazio;
• new XXXDataAdapter (string selectCommand, XXXConnection conexao) - recebe uma string com um SELECT SQL para ser colocado na propriedade SelectCommand do XXXDataAdapter. Esse será o select utilizado para recuperar os dados e preencher o dataSet. Recebe também a conexão usada para conectar ao banco;
• new XXXDataAdapter (string selectCommand, string strConneciont) - ao invés de receber a conexão, recebe a string de conexão;
• new XXXDataAdapter(string selecCommand) - só recebe a string SQL para fazer o SELECT;

PREENCHENDO O DATASET

O XXXDataAdapter possui um método chamado Fill( ) que recebe um dataSet e o preenche com os dados recuperados pela string SQL guardada na propriedade SelectCommand. Veja abaixo dois exemplos de utilização do método Fill():

//utilizando o método Fill para preencher o DataSet. 
//O segundo parâmetro é o nome da tabela que 
//o XXXDataAdapter cria no DataSet para guardar as informações:

dataAdapter.Fill(dataSet,"NomeDaTabela");

//Outra maneira de preencher o DataSet, sem passar um nome de tabela. 
//Nesse caso será criada uma tabela com nome Table no DataSet

dataAdapter.Fill(dataSet);

ATUALIZANDO O BANCO DE DADOS

Após preenchido o DataSet, poderemos fazer modificações como quisermos, inserindo novas linhas, atualizando ou excluindo. Após isso é preciso atualizar os dados do banco de dados com os mais atualizados vindos do dataSet. Para isso, usamos também o XXXDataAdapter com seu método Update().

//atualizando o banco de dados
dataAdapter.Update(dataSet);

No momento em que o método Update é chamado, o que o XXXDataAdapter faz é ver as alterações que aconteceram no DataSet (uma linha alterada é marcada no momento da sua alteração). Se houve uma inserção de linha nova, o XXXDataAdapter utilizará o comando SQL que está na sua propriedade InsertCommand para inserir a linha no Banco de Dados. O mesmo será feito caso haja Exclusão (Delete) e atualização (Update), com as propriedades DeleteCommand e UpdateCommand.

Percebe-se então que é preciso configurar esses 3 comandos para que eles sejam usados pelo Adapter para atualizar o banco, senão ocorrerá um erro.

Caso esteja-se trabalhando com apenas uma tabela no DataSet, o .NET Framework nos provém um objeto que cria as SQL"s automaticamente: o XXXCommandBuilder. Esse objeto se liga ao adapter e configura as propriedades de comando dependendo do banco a ser atualizado.

Para criar um XXXCommandBuilder e liga-lo a ao XXXDataAdapter, usamos o próprio construtor do XXXCommand Builder, por exemplo, para OleDb:

OleDbDataAdapter dataAdapter = new OleDbDataAdapter();
OleDbCommandBuilder comBuilder = new OleDbCommandBuilder(dataAdapter);

CÓDIGO PARA PREENCHER DATASET E RETORNÁ-LO EM UM MÉTODO

Veja um exemplo de código mostrando um exemplo de como seria um método que retorna um dataSet com as informações requeridas:

public DataSet RetornaCliente(string cpf) 	{

    OleDbConnection conexao = null;
    try 
    {
	OleDbConnection conexao = new OleDbConnection("String de conexao do seu banco");
		
	//criando o DataAdapter
	OleDbDataAdapter dap = 
          new OleDbDataAdapter("SELECT * FROM Cliente WHERE CPF=@cpf",conexao);
	//criando o DataSet
	DataSet ds = new DataSet();

//preenchendo o DataSet com os dados do Adapter (nesse momento o 
//próprio adapter abre a conexao chamando o método Open() do 
// objeto conexao

dap.Fill(ds,"Cliente");

	//testando se o DataSet não está vazio
	if (ds.Tables["Cliente"].Rows.Count == 0 ) 
	{
		throw new ApplicationException("DataSet está vazio!");
	}
	return ds;
    }
    catch(OleDbException ex) 
    {
	//faça algo
    } 

    catch (Exception ex) 
    {
	//faça algo
    }
    finally 
    {
	conexao.Close();
    }
}

Por hoje é só pessoal! Obrigado por acompanhar essa "saga" de inicio em ADO .NET! Até a próxima!