View
699
Download
3
Category
Preview:
Citation preview
Neste artigo eu vou mostrar (novamente) como gerenciar um banco de dados MySQL efetuando as operações de acesso, seleção, inclusão , alteração e exclusão usando a linguagem C# e ADO .NET.
Vamos trabalhar usando a arquitetura em 3 camadas definindo assim:
A camada de interface : UI - namespace UI A camada de negócios : BLL - namespace BLL e classe
produtoBLL A camada de acesso a dados : DAL - namespace DAL e
classe produtoDAL
Vamos também criar a entidade Produto que será o objeto do nosso negócio e que possuirá 3 propriedades: ID, Nome e Preco representando assim cada coluna da tabela Estoque. A entidade terá o namespace DTO e a classe Produto.
Eu poderia criar 3 projetos distintos mas para simplificar vou criar as seguintes classes :
produtoBLL - contém os métodos das regras de negócio; (namespace BLL)
produtoDAL - Contém os métodos para acesso a dados no MySQL; (namespace DAL)
produto - contém a classe Produto; (namespace DTO) UI - representa a nossa aplicação Windows Forms;
Lembrando que em uma aplicação em 3 camadas temos uma hierarquia de chamadas onde :
A UI chama a BLL que chama a DLL que por sua vez acesso os dados e retorna os objetos;
Nunca deverá haver uma chamada direta da UI para a DAL e vice-versa.(Quando usamos os controles de acesso a dados vinculados no formulário estamos fazendo o acesso direto da camada de interface para a DAL ou banco de dados o que não é uma boa prática.)
As ferramentas usadas são:
Banco de dados MySQL 5.01; http://dev.mysql.com/downloads/mysql/5.1.html
MySQL Administrator e MySQL Query Browse - http://dev.mysql.com/downloads/gui-tools/5.0.html;
MySQL Connector .NET 6.04; http://dev.mysql.com/downloads/connector/
SharpDevelop 3.0 ou Visual Studio C# 2008; http://www.icsharpcode.net/OpenSource/SD/Download/ ou http://www.microsoft.com/express/vcsharp/
Se você não possuir o MySQL e o Connector .NET para o MySQL deverá efetuar o download e instalar. A instalação é simples basta clicar no pacote e seguir as orientações aceitando as configurações padrão. Veja a seguir a sequência de telas principais da instalação:
1-tela inicial de instalação do MySQL
2-Selecione a opção Typical para
instalação
3-Verifique o local onde os arquivos serão instalados
4-Marque a opção para configurar o MySQL
5-Marque a opção Standard Configuration
6-Marque a opção para instalar como um serviço e forneça um nome para o serviço. O nome padrão
é MySQL
7-Informe uma senha ao usuário root
8-Clique no botão Execute para processar as opções
definidas
Com os componentes instalados vamos efetuar as seguintes tarefas:
Criar um banco de dados no MySQL Chamado Cadastro e uma tabela chamada Estoque com os campos ID, Nome e Preco;
Criar um novo projeto Windows Forms no Visual C# 2008 Express ou SharpDevelop;
Embora eu já tenha descrito como criar um banco de dados no MySQL usando MySQL Administrator vou resumidamente repetir os passos:
Abra o MySQL Admininistrator, e, na área inferior esquerda, onde são exibidos os esquemas. clique com o botão direito e selecione a opção : Create New Schema;
Na janela Create new Schema e informe o nome do banco de dados , no nosso caso, Cadastro, e tecle OK;
Clique sobre o esquema criado e selecione a opção Create New Table ou clique no botão Create Table;
A seguir defina o nome da tabela como Estoque e defina os campos da mesma conforme a figura abaixo:
A seguir a partir do menu Tools selecione a opção MySQL Query Browse;
Na janela do MySQL Query Browse digite a instrução INSERT INTO Estoque VALUES (',"Caderno", 1.23) e clique no botão Execute para incluir um registro na tabela. Repita a operação e inclua uma borracha com um valor de forma que ao efetuar uma instrução SELECT * FROM Estoque iremos obter o resultado abaixo;
Neste momento já temos o banco de dados Cadastro e a tabela Estoque com dois registros.
Abra o SharpDevelop ou o Visual C# 2008 Express e crie um novo projeto do tipo Windows Application com o nome MySQL_C#;
Devemos incluir a referência ao Connector .NET para ter acesso as classes de acesso a dados do MySQL. Para isso clique sobre o nome do projeto e selecione a opção Add Reference;
A seguir inclua uma referência a dll do MySQL Connector .NET selecionando na pasta onde foi instalado e clicando no botão Abrir/Open;
No formulário padrão inclua um controle TabControl e defina dois TabPages:
TabPage1 - Text = Cadastro TabPage2 - Text = Lista tabControl1 - Appearence = FlatButtons (para obter
a aparência conforme a figura abaixo)
Na primeira TabPage inclua os seguintes controles:
3 controles Label 3 Controles TextBox :txtID, txtNome e txtPreco
5 controles Button : btnNovo, btnAltear, btnExcluir, btnExibir e btnProcurar
Na segunda TabPage inclua um controle DataGridView - gdvProdutos.
Acima vemos o leiaute do formulário para cada TabPage.
Vamos iniciar criando o arquivo de classe Produto.cs que irá representar a classe Produto, clicando no nome do projeto e selecionando a opção Add New Item;
Na janela de templates selecione o template Class e informe o nome Produto.cs;
A seguir defina o seguinte código nesta classe onde estamos definindo 3 membros e 3 propriedades da nossa entidade Produto:
using System;
namespace DTO{ public class Produto { int _id;
String _nome;Decimal _preco;
public int ID { get {return _id;} set {_id = value;} } public String Nome { get {return _nome;} set {_nome = value;} } public Decimal Preco { get {return _preco;} set {_preco = value;} } }
}
Neste arquivo criamos a classe Produto e definimos os membros _id, _nome e _preco e as propriedades ID, Nome e Preco. Ela será usada para transferência de objetos entre as camadas de interface de negócio e de acesso a dados.
Agora vamos criar o arquivo de classe DAL.cs clicando no nome do projeto e selecionando a opção Add New Item;
Na janela de templates selecione o template Class e informe o nome DAL.cs;
Os pacotes usados nesta classe são:
using System;using System.Collections.Generic;using System.Data;using MySql.Data.MySqlClient;using DTO;
A seguir vamos definir na classe produtoDAL 6 métodos conforme exibidos abaixo:
selectListProdutos - retorna uma lista de produtos : List<Produto> com os produtos selecionados;
selectProdutos - retorna um DataTable com os produtos selecionados;
selectProdutosByID - retorna uma entidade Produto para um produto selecionado pelo seu código (id);
insertProduto - inclui um novo produto; updateProduto - atualiza um produto existente; deleteProduto - exclui um produto existente;
Vejamos o código da classe produtoDAL:
Declaramos duas variáveis que serão visíveis na classe:
String _conexaoMySQL = "";MySqlConnection con = null;
O construtor da classe ProdutoDAL define a string de conexão com o banco de dados MySQL:
public produtoDAL(){ _conexaoMySQL = "server=localhost;user id=root;password=password;database=cadastro";}
onde temos:
server - localhost , pois estou acessando o MySQL instalado na minha máquina local;id = root , pois estou usando o usuário root;password = password , pois essa foi a senha definida para o usuário root;database=cadastro, pois esse é o banco de dados que criamos no MySQL;
Agora vejamos os métodos:
1- SelectProdutos - Usada para exibir todos os produtos do estoque;
public DataTable selectProdutos(){try{ String sql = "SELECT * FROM Estoque"; con = new MySqlConnection(_conexaoMySQL); MySqlCommand cmd = new MySqlCommand(sql,con); MySqlDataAdapter da = new MySqlDataAdapter(); da.SelectCommand = cmd; DataTable dt = new DataTable(); da.Fill(dt); return dt;} catch (Exception ex){ throw ex;}}
2- selecteProdutoByID() - Usada para retornar uma entidade Produto representando um único produto pelo seu código (id);
public Produto selectProdutoByID(int id){try{ String sql = "SELECT * FROM Estoque WHERE id = @id"; con = new MySqlConnection(_conexaoMySQL); MySqlCommand cmd = new MySqlCommand(sql,con); cmd.Parameters.AddWithValue("@id",id); con.Open(); MySqlDataReader dr;
Produto produto = new Produto(); dr = cmd.ExecuteReader(CommandBehavior.CloseConnection);
while (dr.Read()) { produto.ID = Convert.ToInt32(dr["id"]); produto.Nome = dr["Nome"].ToString(); produto.Preco = Convert.ToDecimal(dr["Preco"]); }return produto;}catch (Exception ex){throw ex;}}
3- selectListProdutos() - Usada para retornar uma lista de objetos Produto representando uma coleção de produtos.
public List<Produto> selectListProdutos(){ try { using (MySqlConnection conn = new MySqlConnection(_conexaoMySQL)) { using (MySqlCommand command = new MySqlCommand("Select * from Estoque", conn)) { conn.Open(); List<Produto> listaProdutos = new List<Produto>(); using (MySqlDataReader dr = command.ExecuteReader()) { while (dr.Read()) { Produto produto = new Produto(); produto.ID = (int)dr["id"]; produto.Nome = (String) dr["Nome"]; produto.Preco = Convert.ToDecimal(dr["Preco"]); listaProdutos.Add(produto); } } return listaProdutos; } } }
catch (Exception ex) { throw new Exception("Erro ao acessar estoque " + ex.Message); }}
4- insertProduto() - Usada para incluir um novo produto no estoque;
public void insertProduto(Produto produto){try{
String sql = "INSERT INTO Estoque (nome,preco) VALUES (@nome,@preco)";
con = new MySqlConnection(_conexaoMySQL);
MySqlCommand cmd = new MySqlCommand(sql,con);
cmd.Parameters.AddWithValue("@nome",produto.Nome);
cmd.Parameters.AddWithValue("@preco",produto.Preco);
con.Open();cmd.ExecuteNonQuery();}catch (Exception ex){
throw ex;}finally{
con.Close();}
}
5- updateProduto() - Usada para atualizar os dados de um produto no estoque;
public void updateProduto(Produto produto){try{ String sql = "UPDATE Estoque SET nome= @nome ,preco=@preco WHERE id = @id "; con = new MySqlConnection(_conexaoMySQL);
MySqlCommand cmd = new MySqlCommand(sql,con);
cmd.Parameters.AddWithValue("@id",produto.ID); cmd.Parameters.AddWithValue("@nome",produto.Nome);
cmd.Parameters.AddWithValue("@preco",produto.Preco);
con.Open();cmd.ExecuteNonQuery();}catch (Exception ex){throw ex;
}finally{con.Close();}
}
6- deleteProduto() - Usada para excluir um produto no estoque;
public void deleteProduto(Produto produto){try{
String sql = "DELETE FROM Estoque WHERE id = @id ";
MySqlConnection con = new MySqlConnection(_conexaoMySQL);
MySqlCommand cmd = new MySqlCommand(sql,con);
cmd.Parameters.AddWithValue("@id",produto.ID);
con.Open();
cmd.ExecuteNonQuery();}catch (Exception ex){
throw ex;}finally{
con.Close();}
}
Eu mantive o código o mais simples possível usando ADO .NET clássica e instruções SQL. Poderia ter usado stored procedures o que seria mais indicado.
Esta é a nossa camada de acesso a dados e sua responsabilidade e acessar e persistir dados no MySQL, só isso. Veja abaixo uma figura onde temos uma visão da nossa solução:
I
Estamos usando a arquitetura em 3 camadas definida assim:
A camada de interface : UI - namespace UI A camada de negócios : BLL - namespace BLL e classe
produtoBLL A camada de acesso a dados : DAL - namespace DAL e
classe produtoDAL
Em uma aplicação em 3 camadas temos uma hierarquia de chamadas onde :
A UI chama a BLL que chama a DAL que por sua vez acesso os dados e retorna os objetos;
Nunca deverá haver uma chamada direta da UI para a DAL e vice-versa.(Quando usamos os controles de acesso a dados vinculados no formulário estamos fazendo o acesso direto da camada de interface para a DAL ou banco de dados o que não é uma boa prática.)
Nosso projeto possui a seguinte estrutura:
produtoBLL - contém os métodos das regras de negócio; (namespace BLL)
produtoDAL - Contém os métodos para acesso a dados no MySQL; (namespace DAL)
produto - contém a classe Produto; (namespace DTO) UI - representa a nossa aplicação Windows Forms;
Onde já implementamos a classe produtoDAL na camada DAL.
Vamos agora mostrar a definição da camada BLL onde temos a classe produtoBLL. A classe produtoBLL possui os seguintes métodos:
DataTable selecionaProdutos() - retorna todos os produtos ;
novoProduto(Produto produto) - inclui um novo produto;
alteraProduto(Produto produto) - altera os dados de um produto; a
excluiProduto(Produto produto) - exclui um produto; List<Produto> listaProdutos() - retorna uma lista
genérica de produtos; Produto listaProdutoPorID(int id) - retorna um único
produto;
Conforme é mostrado na figura a seguir:
Vejamos o código da classe produtoBLL:
Devemos declarar os seguintes namespaces nos imports:
using System.Collections.Generic;using System;using DAL;using DTO;using System.Data;
Precisamos da referência a camada DAL para acessar os métodos da classe produtoDAL e da referência a camada DTO para acessar as propriedades da entidade Produto. A referência aGeneric deve-se ao fato de estarmos retornando uma lista genérica de produtos no método listaProdutos();
O construtor da classe ProdutoBB esta vazio:
public produtoBLL(){}
Agora vejamos os métodos:
1- selecionaProdutos() - retorna um datatable com todos os produtos usando o método selectProdutos() da camada DAL;
public DataTable selecionaProdutos(){DataTable tb = new DataTable();try{ dal = new DAL.produtoDAL(); tb = dal.selectProdutos();}catch (Exception ex){throw ex;}return tb;}
2- listaProdutoPorID() - Usada para retornar uma entidade Produto representando um único produto pelo seu código (id) através do método selectProdutoByID() da camada DAL;
public Produto listaProdutoPorID(int id){ try{ dal = new produtoDAL(); return dal.selectProdutoByID(id); }catch (Exception ex) { throw ex; }}
3- listaProdutos() - Usada para retornar uma lista de objetos Produto representando uma coleção de produtos usando o método selectListProdutos() da camada DAL;
public List<Produto> listaProdutos(){ try{ dal = new produtoDAL(); return dal.selectListProdutos(); }catch (Exception ex) {
throw ex; }}
4- novoProduto(Produto produto) - Usada para incluir um novo produto no estoque usando o método insertProduto() da camada DAL;
public void novoProduto(Produto produto){try{ dal = new DAL.produtoDAL(); dal.insertProduto(produto); }catch (Exception ex) { throw ex; }}
5- updateProduto() - Usada para atualizar os dados de um produto no estoque através do método updateProduto() da camada DAL;
public void alteraProduto(Produto produto){try{ dal = new DAL.produtoDAL(); dal.updateProduto(produto); }catch (Exception ex) { throw ex; }}
6- deleteProduto() - Usada para excluir um produto no estoque via método deleteProduto() da camada DAL;
public void excluiProduto(Produto produto){try{ dal = new produtoDAL(); dal.deleteProduto(produto); }catch (Exception ex) {
throw ex; }}
Não estamos efetuando nenhuma validação de negócio nessas classes devido a simplicidade do exemplo mas em um sistema de produção aqui teríamos as validações referente ao negócio como restrições de valores, cálculo de impostos, descontos, etc.
Dessa forma concluímos a definição do código da nossa camada de negócios - BLL - através da implementação dos métodos da classe produtoBLL.
Estamos usando uma arquitetura em 3 camadas definida assim:
A camada de interface : UI - namespace UI A camada de negócios : BLL - namespace BLL e classe
produtoBLL A camada de acesso a dados : DAL - namespace DAL e
classe produtoDAL A classe Produto que representa um produto do nosso
domínio;
A nossa camada de interface será uma aplicação Windows Forms que possui um formulário onde através de um componente TabControl podemos obter uma visão com detalhes do produto e outra visão da relação dos produtos cadastrados conforme as figuras a seguir:
Para criar esta interface inclua o controle TabControl a partir da ToolBox e na sua propriedade TabPages clique no botão ao lado de Collection e defina duas TabPages definindo a propriedade nome da primeira- TabPage1- como sendo igual a Cadastro e da segunda - TabPage2- como Lista:
Inclua o controle TabControl e defina a sua propriedadeAppearence como igual a FlatButtons;
Na TabPage Cadastro inclua os seguintes controles apartir da ToolBox:
- 3 Label- 3 TextBox - txtID , txtNome e txtPreco- 4 Button - btnNovo, btnAlterar, btnExcluir, btnExibir e btnProcurar
Na TabPge Lista inclua o componente DataGridView -gdvProdutos
Com isso temos a nossa interface pronta para ser usada. Fazemos isso acessando os dados da base MySQL e fazendo
uma chamada a nossa camada de negócio (BLL) que por sua vez chama a camada de acesso a dados(DAL) que é responsável por recuperar e persistir informação na base de dados.
Vamos usar os eventos dos controles de formulário Button para fazer a chamada a nossa classe de negócio. Para isso no início do nosso formulário devemos ter as seguintes referências:
using System;
using System.Collections.Generic;
using System.Drawing;
using System.Windows.Forms;
using BLL;
using DTO;
Note que temos que ter uma referência a camada de negócios BLL a nossa camada DTO - Data Transfer Object, onde definimos a classe Produto.
Vamos começar com o evento Click do botão Exibir que irá exibir os dados na TabPage Lista em um DataGridView;
void BtnExibirClick(object sender, EventArgs e)
{try{ BLL.produtoBLL bll = new produtoBLL(); gdvProdutos.DataSource = bll.selecionaProdutos(); }catch (Exception ex){ MessageBox.Show(" Erro : " + ex.Message.ToString()); }}
Neste código criamos uma instância da classe ProdutoBLL() e em seguida usamos o método selecionaProdutos() que irá retornar um DataTable e exibir os produtos no DataGridView.
Vejamos agora o código do evento Click do botão Novo :
void BtnNovoClick(object sender, EventArgs e)
{
Produto p = new Produto();
p.Nome = (String) txtNome.Text;
p.Preco = Convert.ToDecimal(txtPreco.Text);
try{
BLL.produtoBLL bll = new produtoBLL();
bll.novoProduto(p);
}
catch (Exception ex) {
MessageBox.Show(" Erro : " + ex.Message.ToString());
}
}
Primeiro criamos uma instância da classe Produto e definimos as propriedades Nome e Preco atribuindo a elas os valores fornecidos pelo usuário através das caixas de texto txtNome e txtPreco. Não precisamos informar o código do produto(ID) pois o mesmo é controlado pelo SGBD visto que definimos este campo como do tipo identity.
A seguir criamos uma instância da classe ProdutoBLL() no namespace BLL e em seguida usamos o método novoProduto(p) para incluir um novo produto na
base de dados. Observe que passamos como parâmetro um objeto produto e não valores escalares.
A seguir temos o código associado ao evento Click do botão Alterar:
void BtnAlterarClick(object sender, EventArgs e)
{
Produto p = new Produto();
p.ID = Convert.ToInt32(txtID.Text);
p.Nome = (String) txtNome.Text;
p.Preco = Convert.ToDecimal(txtPreco.Text);
try{
BLL.produtoBLL bll = new produtoBLL();
bll.alteraProduto(p);
}
catch (Exception ex){
MessageBox.Show(" Erro : " + ex.Message.ToString());
}
}
Primeiro criamos uma instância da classe Produto e definimos as propriedades ID, Nome e Preco atribuindo a elas os valores fornecidos pelo usuário através das caixas de texto txtID, txtNome e txtPreco. Aqui precisamos informar o ID do produto para identificar o produto a ser alterado.
A seguir criamos uma instância da classe ProdutoBLL() no namespace BLL e em seguida usamos o método alteraProduto(p) para alterar um produto na base
de dados. Observe que passamos como parâmetro um objeto produto e não valores escalares.
Vejamos agora o código do evento Click do botão Excluir:
void BtnExcluirClick(object sender, EventArgs e)
{ Produto p = new Produto(); p.ID = Convert.ToInt32(txtID.Text);try{ BLL.produtoBLL bll = new produtoBLL(); bll.excluiProduto(p); } catch (Exception ex) { MessageBox.Show(" Erro : " + ex.Message.ToString());} }
Primeiro criamos uma instância da classe Produto e definimos a propriedade ID atribuindo a ela o valor fornecido pelo usuário através das caixas de texto txtID.
A seguir criamos uma instância da classe ProdutoBLL() no namespace BLL e em seguida usamos o método excluiProduto(p) para excluir um produto na base de dados identificado pelo parâmetro ID informado.
Finalmente temos o código do botão Procurar:
void BtnProcurarClick(object sender, EventArgs e)
{
int id = Convert.ToInt32(txtID.Text);
Produto p = new Produto();
try{
BLL.produtoBLL bll = new produtoBLL();
p = bll.listaProdutoPorID(id);
txtNome.Text = p.Nome;
txtPreco.Text = p.Preco.ToString();
}
catch (Exception ex){
MessageBox.Show(" Erro : " + ex.Message.ToString());
}
}
Neste código obtemos o código do produto (ID) a partir da caixa de texto txtID.Text. A seguir criamos uma instância da classe Produto() e invocamos o método listaProdutoPorIDusando o id obtido; por fim exibimos os dados do produto no formulário.
Com isso encerramos a nossa aplicação que acessa o MySQL usando uma arquitetura em camadas. Aplicamos os conceitos básicos da orientação a objetos mas podemos ir além, pois usamos na camada DTO uma classe anêmica sem nenhuma inteligência e não usamos o conceito de interface neste projeto. Deixo isso para você como um exercício.
Eu vou usar os seguintes recursos:
1- MySQL 5.0 (Comunity Server) - Baixe e instale usando as configurações padrão sugeridas pelo assistente de instalação;2- MySQL Administrator e MySQL Query Browser - Baixe e instale usando o assistente;3- SharpDevelop 2.2 ou Visual C# Express Edition
Para efetuar a conexão usando C# vamos usar provedor ADO .NET para MySQL :
4- Download Connector/Net 5.1 (Podemos usar também a versão 5.2)
Criando o banco de dados e a tabela
Após fazer o download e instalar as ferramentas indicadas vamos criar um novo banco de dados chamado Cadastro no MySQL.
Abra o MySQL Administrator e clique em Catalogs;
A seguir clique com o botão direito do mouse na área onde são exibidos os banco de dados e selecione Create New Schema;
Informe o nome do banco de dados e a seguir clique no botão Create Table;
A seguir informe o nome da tabela Clientes e defina as colunas: id , nome, endereço e email conforme abaixo;
Para incluir alguns dados na tabela abra o MySQL Query Browser e digite a instrução INSERT INTO conforme figura abaixo e clique em Execute;
INSERT INTO Clientes(nome,endereco, email) values ('Janice', 'Pça da Luz, 54', 'janice@bol.com.br')
O campo id foi definido como chave primária e incremental de forma que o seu valor é atribuído pelo MySQL;
Ao final teremos o banco de dados Cadastro e a tabela Clientes com alguns dados no MySQL. Estamos prontos para começar.
Vamos agora criar uma nova solução chamada MySQLExemplo usando o SharpDevelop.
Abra o SharpDevelop e no menu Arquivo selecione Novo e em seguida Solução;
Na janela Novo Projeto selecione C#->Aplicações Windows e na janela Modelos marque Aplicação Windows e informe o nome da solução , no meu caso: MySQLExemplo;
No formulário padrão MainForm.cs vamos incluir um controle DataGrid a partir da guia Data na janela de Ferramentas:
Na janela de código vamos primeiro declarar os namespaces:
using System.Data;using MySql.Data.MySqlClient;
A seguir vamos incluir o código para fazer a conexão com o banco de dados Cadastro no MySQL , acessar a tabela Clientes e exibir os seus dados
no DataGrid; public class MainForm : System.Windows.Forms.Form{private System.Windows.Forms.DataGrid mDataGrid;private MySqlConnection mConn;private MySqlDataAdapter mAdapter;private DataSet mDataSet;public MainForm(){ InitializeComponent(); //define o dataset mDataSet = new DataSet(); //define string de conexao e cria a conexao mConn = new MySqlConnection(" Persist Security Info=False;server=localhost;database=Cadastro;uid=root;server=localhost;database=Cadastro;uid=root;pwd=xxxx");
try{ //abre a conexao mConn.Open(); } catch(System.Exception e) { MessageBox.Show(e.Message.ToString()); } //verificva se a conexão esta aberta if (mConn.State == ConnectionState.Open) { //cria um adapter usando a instrução SQL para acessar a tabela Clientes mAdapter = new MySqlDataAdapter("SELECT * FROM Clientes", mConn); //preenche o dataset via adapter mAdapter.Fill(mDataSet, "Clientes"); //atribui a resultado a propriedade DataSource do DataGrid mDataGrid.DataSource = mDataSet;
mDataGrid.DataMember = "Clientes"; }}
No código acima eu vou falar um pouco sobre a string de conexão usada. Ele é definida dessa forma para o provedor MySQL Connector/Net (.NET).
mConn = new MySqlConnection( Persist Security Info=False; "Server=localhost;" + "DataBase=Cadastro;"+ "Uid=root;" + "Pwd=xxx;");
Um objeto MySqlConnection representa uma sessão para uma fonte de dados MySQL. Quando criamos uma instância MySqlConnection todas as propriedades são definidas para os seus valores iniciais. A seguir temos os valores padrão no construtor:
Propriedades Valor InicialConnectionString empty string ("")ConnectionTimeout 15Database empty string ("")DataSource empty string ("")ServerVersion empty string ("")
O atributo Persist Security Info para uma string de conexão especifica se a fonte de dados pode persistir uma informação segura como as credenciais de autenticação do usuário. O valo padrão é mantido como False. Se Persist Security Info for definido como False e a conexão foi aberta , o valor retornado pela string de conexão não irá exibir a chave nem a senha. Se o valor for definido como True a informação da conexão - incluindo a senha - pode ser obtida pela consulta a conexão , permitindo assim uma forma de acesso não confiável as informações do usuário quando a conexão for persistida. A propriedade Server(DataSource) indica o nome ou endereço de rede da instância do MySQL com o qual será feita
a conexão. Múltiplas instâncias podem ser definidas separadas por &. A propriedade DataBase define o nome do banco de dados atual a ser usado após a conexão ser aberta. Ela não é atualizada dinamicamente, desta forma, se você alterar o banco de dados usando uma instrução SQL poderá ocorrer um erro. Para alterar o banco de dados use o método ChangeDataBase para refletir o novo banco de dados. A propriedade Uid representa a conta que será usada para acessar o MySQL. A propriedade Pwd representa a senha da conta que esta sendo usada para o login no MySQL. Após encerrar o trabalho com a conexão o objeto MySqlConnection não é fechado, e , por isso você deve fechar a conexão explicitamente chamando MySqlConnection.Close ou MySqlConnection.Dispose. Para fechar a conexão sobrescrevemos o método Dispose conforme abaixo: protected override void Dispose(bool disposing){if (disposing){ if (mConn.State == ConnectionState.Open) { mConn.Close(); }}base.Dispose(disposing);}
Ao usar o comando Open o MySqlConnection tenta obter uma conexão a partir do pool de conexão , se não existir uma
conexão disponível, será estabelecida uma nova conexão com uma instância do MySQL. mConn.Open(); Ao executar o projeto iremos obter o seguinte resultado no controle DataGrid;
Este foi apenas uma pequena introdução ao acesso a dados com MySQL e C#. Aguarde em breve artigos mais avançados...
Um bom estudo para você... Pegue o projeto completo aqui: MySQLExemplo.zip
Recommended