Olá pessoal, tudo bem?
Neste artigo estarei mostrando a vocês como desenvolver usando ADO .NET para acesso a dados no modelo conectado.

O MODELO CONECTADO

Essa é a maneira mais comum de acessar banco de dados e segue o que normalmente fazemos no nosso dia a dia. A idéia é, todas as vezes que precisamos de alguma informação, nos conectamos a base de dados e carregamos essa informação. Esse modelo nos permite termos sempre a informação o mais atualizada possível e é ideal para sistemas em que os dados mudam o tempo todo e que precisam das informações atualizadas. Um bom exemplo disso é um controle de estoque que precisa saber "on-the-fly" informações que mudam o tempo todo. A quantidade de produtos pode ter mudado inúmeras vezes e você precisa saber a informação mais atualizada. Essa é a idéia! Um problema desse modelo é o fato de que todas as vezes em que é preciso recuperar uma informação é preciso se conectar a base de dados. Isso causa um tráfego maior na rede deixando-a sobrecarregada.

CODIFICANDO PARA MODELO CONECTADO

Mostrei no artigo passado como criar um objeto que representa a conexão ao banco. Além disso precisaremos também ter um objeto chamado XXXCommand. O XXXCommand servirá para executar algum comando SQL no banco de dados. Como vocês perceberam, coloquei XXX antes do nome Command. Esse padrão é usado para definir que o objeto depende do banco de dados e do Provider (se não se lembra o que é Provider, por favor, leia a primeira parte de acesso a dados com .NET). Se estivéssemos trabalhando com uma base de dados SQL Server, por exemplo, usaríamos o SqlCommand.

Se vocês ainda se lembram (faz um tempão...), usamos um banco de dados Access no artigo anterior, então usaremos o objeto OleDbCommand, pois estaremos usando o provedor OLEDB para acessar os nossos registros.

Vamos então criar um objeto OleDbCommand. Podemos fazer isso de duas formas:

//usando a palavra reservada "new"
OleDbCommand comando = new OleDbCommand(...);

Temos 4 diferentes construtores para o OleDbCommand, e você pode escolher dependendo da sua necessidade:

• OleDbCommand() - o construtor vazio

• OleDbCommand(string cmdSQL, System.Data.OleDbConnection connection, System.Data.OleDbTransaction transacao) - construtor que recebe uma string SQL que guardada na propriedade CommandText do objeto OleDbCommand criado para depois ser executada no banco de dados; um objeto OleDbConnection que será guardado na propriedade Connection do comando; um objeto OleDbTransaction que representa a transação ao qual esse comando está ligado e será guardado na propriedade Trasaction do comando.

• OleDbCommand(string cmdSQL) - recebe apenas a string SQL a ser executada

• OleDbCommand(string cmdSQL, System.Data.OleDbConnection connection) - recebe apenas a string SQL e a conexão ao qual o comando está ligado

A segunda maneira é usando o método CreateCommand de uma conexão:

//criando a conexão e passando uma string de conexão como parâmetro
OleDbConnection conexao = new OleDbConnection(strConexao);

// criando o comando através da conexão:
OleDbCommand comando = conexao.CreateCommand();

//setando a string SQL do comando
comando.CommandText = "INSERT INTO <table> AlgumaCoisa";

A PROPRIEDADE CommandText

É importante lembrar que nem sempre (na verdade, quase nunca) nós setamos a string SQL diretamente no código de desenvolvimento. Normalmente usamos Stored Procedures. Para setar o CommandText para ser usado com o seu stored procedure, faça como segue:

//setando o CommandText com o nome do Stored Procedure
comando.CommandText = "NomeDoSP";
			
//setando o tipo do comando para StoredProcedure
comando.CommandType = System.Data.CommandType.StoredProcedure;

Quando setamos o CommandText para uma string SQL não precisamos setar o CommandType para System.Data.CommandType.Text porque esse já é o valor padrão da propriedade.

EXECUTANDO O COMANDO

Após criado o comando é necessário que executemos a operação! Para fazermos isso, temos 3 métodos em qualquer XXXCommand:

• ExecuteNonQuery() - Método utilizado para executar comandos que não retornam resultados de busca. Como por exemplo inserção, deleção e atualização (INSERT, DELETE e UPDATE, respectivamente no SQL). O método em si retorna um inteiro que representa a quantidade de linhas modificadas no banco de dados após a sua execução;

• ExecuteScalar() - Utilizado para executar comandos que retornam um único valor. Um exemplo prático é quando procuramos o nome de uma pessoa que tem CPF igual a 142312312-32, por exemplo. Mesmo que nosso comando SQL retorne mais de um comando, o método ExecuteScalar() irá retornar um object com o valor apenas da primeira coluna da primeira linha entre todos os valores retornados.

• ExecuteReader() - Caso seja necessário retornar mais de um valor, poderemos usar esse método. O método executa o comando SQL no banco de dados e retorna os resultados em um objeto XXXDataReader. O XXXDataReader é um objeto forward-only e readonly que permite a visualização dos dados retornados. Discutirei o objeto XXXDataReader em outro artigo!

O USO DE PARÂMETROS

Trabalhando com strings SQL nós perceberemos que algumas vezes precisamos passar valores para os comandos que ainda não conhecemos. Para fazer coisas desse tipo nós usamos parâmetros. Queremos, por exemplo, inserir na tabela Cliente um novo registro. Se a tabela possuir como campos CPF e Nome, teríamos o seguinte código:

public void Inserir(string cpf, string nome) 
{
	//criando a conexao
	OleDbConnection conexao = null;
	try 
	{
	// inicializando
	OleDbConnection conexao = new OleDbConnection(strConecao);
	//criando o comando
	OleDbCommand comando = conexao.CreateCommand();
	//setando o CommandText e usando parâmetros na string de inserção
	comando.CommandText = "INSERT INTO Cliente VALUES(@cpf, @nome)";
	//criando os parâmetros e adicionando a coleção de parâmetros do comando
	comando.Parameters.Add("@cpf", cpf);
	comando.Parameters.Add("@nome", nome);

	//abrindo a conexão com o banco de dados
	conexao.Open();

	//executando o comando
	comando.ExecuteNonQuery();

	} 
	catch (Exception ex) 
	{
		//trata o erro
	}
	finally 
	{
		//fechando a conexao
		conexao.Close();
	}
}

Fiz questão de mostrar o código completo de um suposto método inserir para vocês verem coisas importantes que temos de lembrar:

1. Cada comando tem uma coleção de parâmetros. Se vamos usar algum parâmetro, temos de adiciona-lo a essa coleção passando o nome do parâmetro (por exemplo, @cpf) seguido do objeto que representa o valor do parâmetro passado (por exemplo, a string cpf).

2. É preciso abrir a conexão antes de executar qualquer comando!

3. Para evitar erros futuros, é importante sempre fechar a conexão após o seu uso!

CONCLUSÃO

Bom pessoal, espero ter ajudado vocês a entenderem um pouco do uso de comandos para execução de operações no banco de dados no modelo conectado de acesso. No próximo artigo tratarei de uma visão inicial do modelo desconectado de acesso a banco e de implementação com DataSets, DataAdapters, etc. Até lá!