Referência rápida ADO.net

Paulo Sousa
Maio 2005
[ voltar à página de ADAV ]

Os exemplos apresentados utilizam o provider OleDb.
Para utilizar outro provider, em princípio, apenas necessitam mudar as classes utilizadas (ex. OleDbConnection --> SqlConnection)

[ SQL | notas e boas práticas | abrir conexão | iniciar transacção | consultar registos | obter esquema | comandos com parâmetros | parâmetros do tipo data | parâmetros do tipo Currency | passar NULL |  id autogerado | verificar se é NULL | terminar transacção | fechar conexão | tratamento excepções | data binding ]

Sintaxe SQL [topo]

SELECT <campo>, <campo>, ... FROM <tabela>, <tabela> WHERE <campo> = <valor> { AND | OR } <campo> = <valor> ORDER BY <campo>, ...

INSERT INTO <tabela> (<campo>, <campo>, ...) VALUES (<valor>, <valor>, ...)

UPDATE <tabela> SET <campo> = <valor>, <campo> = <valor>, ... WHERE <campo> = <valor> { AND | OR } <campo> = <valor>

DELETE FROM <tabela> WHERE <campo> = <valor> { AND | OR } <campo> = <valor>

Nota:
para uma descrição mais detalhada da sintaxe da linguagem SQL consultar http://www.w3schools.com/sql/
 

Notas e boas práticas [topo]

Abrir Conexão [topo]

OleDbConnection conn = new OleDbConnection(<string conexão>);
conn.Open();

Nota:
para exemplos de strings de conexão para diversos providers consultar http://www.able-consulting.com/ADO_Conn.htm ou http://www.connectionstrings.com

Um exemplo:
abrir uma conexão a uma base de dados em MS Access permitindo acesso simultâneo de várias aplicações

const string CONN = @"Provider=Microsoft.Jet.OLEDB.4.0;Data Source=C:\myPath\myJet.mdb;Mode=Share Deny None; User ID=;Password=";
...
OleDbConnection conn = new OleDbConnection(CONN);
conn.Open();
 

Iniciar transacção [topo]

// sendo conn uma referência para um objecto OleDbConnection
 OleDbTransaction tx = conn.BeginTransaction();

Nota:
se iniciar uma transacção todos os comandos emitidos nesta conexão devem ser associados à transacção antes de qualquer utilização.

Exemplo:

OleDbCommand cmd = new OleDbCommand(<comando sql>, conn);
cmd.Transaction = tx;
 

Consultar registos [topo]

usando DataReader

OleDbCommand cmd = new OleDbCommand(<select sql>, <objecto conexão>);
OleDbDataReader rd = cmd.ExecuteReader();

if (rd.HasRows)
{
    while (rd.Read())
    {
        ...
        string colname = rd.GetName(<ordem campo>); 
        int idx = rd.GetOrdinal(<nome do campo>); 
        string colval = (string)rd[<nome ou ordem campo>];    // os parêntesis rectos são uma abreviatura para a propriedade Item
        int colval2 = rd.GetInt32(<ordem campo>);
        ...
    }
}
rd.Close();

usando DataSet

OleDbDataAdapter dapt = new OleDbDataAdapter(<select sql>, <string conexão ou objecto conexão>);
DataSet ds = new DataSet();
dapt.Fill(ds, <nome tabela>);   

// o mesmo DataSet pode conter várias tabelas utilizando para tal outro DataAdapter
outro_dapt.Fill(ds, <nome outra tabela>);   

// a partir daqui é possível fechar a conexão pois os dados já estão em memória; caso o DataAdapter tenha sido criado usando uma string de conexão, a gestão de abertura e fecho da conexão é feita internamente pelo método Fill() do DataAdapter

//utilização do DataSet
foreach (DataRow reg in ds.Tables[<nome ou ordem tabela>].Rows)
{
    ...
    int ival = (int)reg[<nome ou ordem campo>]; // parêntesis rectos utilizam propriedade Item
    string colname = ds.Tables[<nome ou ordem tabela>].Columns[<ordem campo>].ColumnName;
    ...
}

//acesso a um campo de um registo (ex., campo do tipo float)
float  valor = (float)ds.Tables[<nome ou ordem tabela>].Rows[<ordem do registo>][<nome ou ordem do campo>];

//pesquisa em memória no DataSet
DataRow[] linhas = ds.Tables[<nome ou ordem tabela>].Select(<filtro de pesquisa>);

um exemplo:

OleDbDataAdapter da = new OleDbDataAdapter("SELECT * FROM contas", @"Provider=Microsoft.Jet.OLEDB.4.0;Data Source=C:\myPath\myJet.mdb;");
DataSet ds = new DataSet();
da.Fill(ds, "contas");
...
DataRow[] reg = dsContas.Tables[0].Select("id=" + codigo);
decimal s = (decimal)reg[0]["saldo"];
 

Obter esquema da BD [topo]

usando DataReader

OleDbCommand cmd = new OleDbCommand(<select sql>, <objecto conexão>);
OleDbDataReader rd = cmd.ExecuteReader();

for(int i = 0; i < rd.FieldCount; i++)
{
    string tipo = rd.GetDataTypeName(i);
    Type t = rd.GetFieldType(i);
    string colname = rd.GetName(i);
    ...
}
rd.Close();

usando DataSet

OleDbDataAdapter dapt = new OleDbDataAdapter(<select sql>, <string conexão ou objecto conexão>);
DataSet ds = new DataSet();
dapt.FillSchema(ds, SchemaType.Source, <nome tabela>);   

// o mesmo DataSet pode conter várias tabelas utilizando para tal outro DataAdapter
outro_dapt.FillSchema(ds, SchemaType.Source, <nome outra tabela>);   

// a partir daqui é possível fechar a conexão pois os dados já estão em memória

foreach(DataColumn dc in ds.Tables[<nome ou ordem tabela>].Columns)
{
    string colname = dc.ColumnName;
    Type t = dc.DataType;
    ...
}

Executar comandos com parâmetros [topo]

Sintaxe dos parâmetros no SQL

Em qualquer comando SQL é possível inserir parâmetros utilizando o símbolo ? (MS Access) ou @ (MS SQL Server) ou : (Oracle).

Alguns exemplos:

SELECT * FROM utilizadores WHERE user_name = ? and pass_word = ?

INSERT INTO utilizadores (user_name, pass_word, email) VALUES (@un, @pwd, @e)

DELETE FROM utilizadores WHERE id = :id

Utilização

OleDbCommand cmd = new OleDbCommand(<sql com parâmetros>, <objecto conexão>);
cmd.Parameters.Add(<nome do parâmetro>, <valor>);
...
cmd.ExecuteNonQuery();    // se for um comando SELECT usar ExecuteReader ou OleDbDataAdapter.Fill()

um exemplo:

OleDbCommand cmd = new OleDbCommand();
cmd.CommandText = "INSERT INTO utilizadores (user_name, pass_word, email) VALUES (?, ?, ?)";
cmd.Connection = conn;

cmd.Parameters.Add("uname", "i111999");
cmd.Parameters.Add("pwd", "7GFe2a");
cmd.Parameters.Add("email", "i111999@dei.isep.ipp.pt");

cmd.ExecuteNonQuery();
 

Passar um valor do tipo data para um parâmetro [topo]

// sendo cmd uma referência para um objecto OleDbCommand
 OleDbParameter parm = cmd.Parameters.Add(<nome do parâmetro>, OleDbType.Date);
parm.Value= <valor data>;

um exemplo:

OleDbCommand cmd = conn.CreateCommand();
cmd.CommandText = "INSERT INTO facturas (clienteID, dataCriacao) VALUES (?, ?)";

cmd.Parameters.Add("cid", 347);
OleDbParameter parm = cmd.Parameters.Add("dt", OleDbType.Date);
parm.Value= DateTime.Now;

cmd.ExecuteNonQuery();
 

Passar um valor do tipo Currency para um parâmetro [topo]

// sendo cmd uma referência para um objecto OleDbCommand
 OleDbParameter parm = cmd.Parameters.Add(<nome do parâmetro>, OleDbType.Currency);
parm.Value= <valor data>;
um exemplo:

OleDbCommand cmd = conn.CreateCommand();
cmd.CommandText = "INSERT INTO facturas (clienteID, saldo) VALUES (?, ?)";

cmd.Parameters.Add("cid", 347);
OleDbParameter parm = cmd.Parameters.Add("s", OleDbType.Currency);
decimal saldo = 1000.00m;
parm.Value= saldo;

cmd.ExecuteNonQuery();
 

Passar o valor NULL para um parâmetro [topo]

// sendo cmd uma referência para um objecto OleDbCommand
cmd.Parameters.Add(<nome do parâmetro>, DBNull.Value);

Obter id autogerado após inserção de registo [topo]

OleDbCommand cmdID = new OleDbCommand("SELECT @@IDENTITY", <objecto conexão>);
int id = (int)cmd.ExecuteScalar();

Notas:
funciona em MS Access 2000 ou superior apenas quando se usa o provider OleDB Jet 4.0
também funciona em MS SQL Server embora se deva utilizar SCOPE_IDENTITY() para evitar problemas com triggers
no caso do Oracle, usam-se sequências, que permitem gerar a chave antes de inserir o registo

No caso do SQL Server o valor retornado é do tipo decimal, assim sendo, devem usar o seguinte código:

SqlCommand cmdID = new SqlCommand("SELECT @@IDENTITY", <objecto conexão>);
decimal id = (decimal)cmd.ExecuteScalar();
 

Verificar se um campo é NULL [topo]

usando DataReader

//sendo rd uma referência para um DataReader
if (rd.IsDBNull(<ordem do campo>))
{
    ...
}

usando DataSet

//sendo ds uma referência para um DataSet
if (ds.Tables[<nome ou ordem tabela>].Rows[<ordem do registo>].IsNull(<nome ou ordem da coluna>))
{
    ...
}

Actualizar uma tabela da BD usando DataSet [topo]

sem transacções

//sendo ds uma referência para um DataSet
 DataSet dsChanged = ds.GetChanges();
if (dsChanged != null)
{
    OleDbDataAdapter da = new OleDbDataAdapter(<select sql>, <string conexão ou objecto conexão>);
    OleDbCommandBuilder cb = new OleDbCommandBuilder(da);
    da.Update(dsChanged);
}

um exemplo:

const string CONN = @"Provider=Microsoft.Jet.OLEDB.4.0;Data Source=C:\myPath\myJet.mdb;User ID=;Password=";
const string SQL_CONTAS = "SELECT * FROM contas";

public DataSet ObterDados()
{
    OleDbDataAdapter da = new OleDbDataAdapter(SQL_CONTAS, CONN);
    DataSet ds = new DataSet();
    da.Fill(ds, "contas");
    return ds;
}

public void ActualizarBD(DataSet ds)
{
    DataSet dsChanged = ds.GetChanges();
    if (dsChanged != null)
    {
        OleDbDataAdapter da = new OleDbDataAdapter(SQL_CONTAS, CONN);
        OleDbCommandBuilder cb = new OleDbCommandBuilder(da);
        da.Update(dsChanged);
    }
}

public void Processamento()
{
    DataSet ds = ObterDados();

    ...

    ds.Tables[0].Rows[0]["saldo"] += 1000;

    ...

    ActualizarBD(ds);
}
 

com transacções

//sendo ds uma referência para um DataSet
//sendo tx uma referência para um objecto OleDbTransaction
 DataSet dsChanged = ds.GetChanges();
if (dsChanged != null)
{
    OleDbDataAdapter da = new OleDbDataAdapter(<select sql>, <objecto conexão>);
    da.SelectCommand.Transaction = tx;
    OleDbCommandBuilder cb = new OleDbCommandBuilder(da);
    da.Update(ds);
}

Terminar transacção [topo]

com sucesso

// sendo tx uma referência para um objecto OleDbTransaction
 tx.Commit();

sem sucesso

// sendo tx uma referência para um objecto OleDbTransaction
 tx.Rollback();

Fechar conexão [topo]

// sendo conn uma referência para um objecto OleDbConnection
 conn.Close();

Tratamento de excepções [topo]

sem transacções

OleDbConnection conn = null;
try
{
    conn = new OleDbConnection(<string conexão>);

    //efectuar processamento
    ...
}
catch (OleDbException ex)
{
    //registar excepção e sair graciosamente ou relançar a excepção
    ...
}
finally
{
    if (conn != null && conn.State != ConnectionState.Closed)
        conn.Close();
}

com transacções

OleDbConnection conn = null;
OleDbTransaction tx = null;
try
{
    conn = new OleDbConnection(<string conexão>);
    conn.Open()
    tx = conn.BeginTransaction();

    //efectuar processamento
    ...

    tx.Commit();
}
catch (OleDbException ex)
{
    if (tx != null)
        tx.Rollback();

    //registar excepção e sair graciosamente ou relançar a excepção
    ...
}
finally
{
    if (conn != null && conn.State != ConnectionState.Closed)
        conn.Close();
}

Data binding Winforms [topo]

Nota:
podem consultar em http://www.syncfusion.com/FAQ/WinForms/default.asp uma lista de perguntas mais frequentes (FAQ) sobre WinForms.
 

ComboBox

//sendo cb uma referência para um objecto do tipo ComboBox
//sendo ds uma referência a um objecto do tipo DataSet
cb.ValueMember = <nome do campo>;
cb.DisplayMember = <nome do campo>;
cb.DataSource = ds.Tables[<ordem ou nome da tabela>].DefaultView;

Nota:
para saber o item actualmente seleccionado, ou para seleccionar um item, usar SelectedItem, SelectedIndex, SelectedValue ou SelectedText
 

DataGrid

//sendo dg uma referência para um objecto do tipo DataGrid
//sendo ds uma referência a um objecto do tipo DataSet
dg.DataMember = <nome da tabela>;
dg.DataSource = ds;
 

Nota:
para saber o item actualmente seleccionado no DataGrid colocar o seguinte código no event handler desejado (ex., DoubleClick)

//Get the Currency Manager by using the BindingContext of the DataGrid
 CurrencyManager cm = (CurrencyManager)<objecto form>.BindingContext[<objecto datagrid>.DataSource, <objecto datagrid>.DataMember];

//Retrieve the default DataView of the DataGrid
 DataView dv = (DataView)cm.List;

// Use Currency Manager and DataView to retrieve the Current Row
DataRow drItemSeleccionado = dv[cm.Position].Row;    //parentesis rectos usam propriedade Item
 

[ Home Page | Fabricare | Publicações | Bookmarks | Disciplinas | Download ]

comentários e sugestões

Última Alteração: 30 de Maio de 2005