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 2-Selecione a

MySQL opção Typical para instalação
 3-Verifique o local onde os 4-Marque a opção para
arquivos serão instalados configurar o MySQL

6-Marque a opção para

instalar como um serviço e
5-Marque a opção Standard
forneça um nome para o
Configuration
serviço. O nome padrão
é MySQL

8-Clique no
7-Informe uma senha ao
botão Execute para processar
usuário root
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=cadastr
o";
}

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(_conexao
MySQL);
     MySqlCommand cmd
= new MySqlCommand(sql,con);
   
cmd.Parameters.AddWithValue("@
id",id);
    con.Open();
    MySqlDataReader dr;

    Produto produto
= new Produto();
   dr =
cmd.ExecuteReader(CommandBeh
avior.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",pro
duto.Nome);

cmd.Parameters.AddWithValue("@preco",pro
duto.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",produt
o.ID);

cmd.Parameters.AddWithValue("@nome",pro
duto.Nome);

cmd.Parameters.AddWithValue("@preco",pro
duto.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 pro
dutoBLL()
{}

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 listaProdut
oPorID(int id)
{
   try{
        dal
= new produtoDAL();
            return dal.selectPro
dutoByID(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.selectListProdu
tos();
       }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(P
roduto 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(produt
o);
     }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 propr

Appearence como igual a FlatButtons;

Na TabPage Cadastro inclua os seguintes controle

partir da ToolBox:

- 3 Label
- 3 TextBox - txtID , txtNome e txtPreco
- 4 Button - btnNovo, btnAlterar, btnExcluir, bt

Na TabPge Lista inclua o componente DataGridVi

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 Inicial

ConnectionString empty string ("")
ConnectionTimeout 15
Database 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 Disp
ose(bool disposing)
{
if (disposing)
{
   
if (mConn.State == Connecti
onState.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