VB.NET - Usando controles Vinculados

Usando controles vinculados no VB.NET

Os controles vinculados sempre estiveram presentes no Visual Basic e permitem a exibição de informações de uma maneira simples e rápida. Trabalhar com os controles vinculados na plataforma .NET além de ser fácil e usar pouco código , chega a ser divertido . Vou mostrar como usar alguns controles vinculados usando a plataforma .NET em aplicações Winforms através do VB.NET.

Os controles Vinculados

Os controles vinculados são controles Winforms que podem ser facilmente vinculados a componentes de dados. A plataforma Visual Studio .NET é rica em componentes para dados ADO.NET , e , neste artigo vou tratar do controle vinculado DataGrid.

Vou mostrar como usar as propriedades dos controles vinculados para exibirem informações através da vinculação destas propriedades com os componentes para dados. Existem duas propriedades básicas para fazer este serviço : DataSource e DisplayMember.

- DataSource- define a fonte de dados para a vinculação. Ex: Public ReadOnly Property DataSource As Object

Ex: Podemos definir um DataSource assim :

Dim ds as DataSet = New DataSet()

DataGrid1.DataSource = ds.DefaulViewManager

Onde DefaulViewManager obtêm uma visão dos dados contidos no DataSet quer permite a busca , filtragem e navegação através de um DataViewManager. personalizado.

- DisplayMember- obtêm ou define uma string que especifica a propriedade da fonte de dados cujo conteúdo desejamos exibir. Ex: Public Property DisplayMember As String

-onde String define o nome da propriedade do objeto especificado pela propriedade DataSource. O valor padrão é uma string vazia ("").

Ex: Podemos atribuir a propriedade a um campo de uma tabela do banco de dados

Dim dv as DataView = ds.Tables("Authors").DefaultView

ListBox1.DataSource = dv

ListBox1.DisplayMember = "Authors"

Os componentes para dados no VS.NET

Temos os componentes para dados no VS.NET :

Data Connection
DataSet
DataView
Data Adapters
Data Commands

- Estes componentes podem ser criados em tempo de desenvolvimento ou de execução. Para criar um componente basta arrastá-lo para o formulário e configurar suas propriedades.

Os componentes : Data Connection , Data Adapter e Command são específicos para um provedor de dados , já os componentes Datset e DataView são componentes comuns.

Os Provedores de Dados ADO.NET

ADO.NET possui três tipos de provedores de dados que foram desenhados para trabalhar com tipos diferentes de fontes de dados. Todos os estes provedores fornecem as mesmas classes para connection, command e Data Adapters. São eles:

- SQL Data Providers - trabalham com banco de dados SQL Server ( versão 7.0 ou superior). As classes Connection , Command e Data Adapters são: Sqlconnection , Sqlcommand e SqlDataAdapter

- OLE DB Data Providers - Trabalham com fonte de dados OLE DB. As classes Connection , command e Data Adapter são : OleDbConnection, OleDbCommand , OleDbDataAdapter.

- ODBC Data Providers - Esta presente somente na versão oficial ( a versão beta não traz este provedor). Trabalham com fonte de dados ODBC. As classes Connection , Command e Data Adapters são : ODBCConnection , ODBCCommand e ODBCDataAdapter.

Usando os componentes de dados(Data Components)

Para trabalhar com os componentes de dados podemos dividir as ações em etapas. Realizar a conexão a uma fonte de dados (data source) é uma das principais.

Para criar uma conexão com a fonte de dados usamos o objeto Connection. Vamos criar uma string de conexão e um objeto connection. Como exemplo usar como fonte de dados um banco de dados Access 2000 e usar classes Data adapters para realizar a conexão .

Vamos usar o controle DataGrid para exibir os dados da tabela - Clientes - que esta presente no banco de dados -Northwind.mdb. Poderiamos usar um assistente para fazer o serviço , mas já vimos este filme antes. Vou mais além , neste exemplo iremos criar um projeto vazio e criar via código formulário, controles e exibir os dados, ou seja, vamos criar tudo em tempo de execução. Vamos lá...

Exibindo os dados em um DataGrid a partir de um projeto vazio : Começando do nada e criando tudo...

- Inicie um novo projeto no Visual Studio.NET com as seguintes características (sinta-se a vontade para alterar a seu gosto.)

Project Types : Visual Basic Projects
Templates : Empty Project
Name : PreencheDataGrid
Location : c:\vbnet

- No - Solution Explorer - clique duas vezes(botão direito) sobre o nome do projeto e selecione - Add Reference no menu suspenso. Em seguida selecione as seguintes referências: System.Data.dll , System.dll, System.Windows.Forms.dll e System.XMl.dll

- No - Solution Explorer - clique novamente sobre o nome do projeto com o botão direito do mouse e selecione a opção - Add -> Add Module para incluir um novo módulo no projeto. De um nome ao módulo - usaremos - PreencherDataGrid - e clique em Open.

- Agora digite o código abaixo no módulo incluído:

Imports System.Data
Imports System.Data.OleDb
Imports System.Windows.Forms

Module PreencheDataGrid

Sub main()

'cria um novo objeto connection
Dim cn As New OleDbConnection("Provider =Microsoft.Jet.OLEDB.4.0;Data Source=c:\teste\northwind.mdb")
Dim da As New OleDbDataAdapter()
Dim ds As New DataSet("ds")
Dim dgrid As New DataGrid()
Dim frm As New Form()

Try
    da.SelectCommand = New OleDbCommand("Select * from Clientes", cn)
     da.FillSchema(ds, SchemaType.Mapped)
     da.Fill(ds)
     dgrid.Dock = DockStyle.Fill
     dgrid.DataSource = ds
     dgrid.DataMember = "Table"

     frm.Controls.Add(dgrid)
     frm.Text = "Preechendo um DataGrid"
     frm.WindowState = FormWindowState.Normal
     frm.ShowDialog()
Catch erro As Exception
    MsgBox(erro.ToString, MsgBoxStyle.Exclamation)
End Try

End Sub

End Module

código para preencher um datagrid

Execute e , se você fez tudo certo , vai obter o seguinte resultado:

Agora vou explicar o código. Vamos por partes :

- As referências aos namespaces

Imports System.Data
Imports System.Data.OleDb
Imports System.Windows.Forms

Estas linhas tornam acessíveis os componentes de acesso a dados no nosso projeto

- A declaração de variavéis objeto para acesso a dados

'cria um novo objeto connection
Dim cn As New OleDbConnection("Provider =Microsoft.Jet.OLEDB.4.0;Data Source=c:\teste\northwind.mdb")
Dim da As New OleDbDataAdapter()
Dim ds As New DataSet("ds")
Dim dgrid As New DataGrid()
Dim frm As New Form()

- Os objetos Connection têm como objetivo criar uma conexão com um banco de dados. São básicos e sempre necessários.
A propriedade ConnectionString é quem define a conexão com o banco de dados.
- Após cria a conexão outros objetos - Command/DataAdapter - usam os objetos Connection para enviar e receber dados do banco de dados

Acima usamos o objeto OleDbConnection para criar uma conexão com o banco de dados Northind.mdb localizado em c:\teste. A ConnectionString é : "Provider =Microsoft.Jet.OLEDB.4.0;Data Source=c:\teste\northwind.mdb"

A seguir criamos um objeto - OleDbDataAdapter - para fazer a ligação entre o objeto DataSet e o banco de dados. É através dele que iremos preencher o DataSet com dados do banco de dados e depois atualizar novamente o banco de dados do DataSet.

O DataSet é muito importante , pois mantém em cache de memória o conjunto de informações do banco de dados armazenados em uma ou mais tabelas na coleção - DataTable.

DataGrid é componente que iremos usar para exibir as informações provenientes do DataSet.

- Executamos o código usando a estrutura - Try-Cacth-EndTry . Para maiores informações leia o artigo : VB.NET : tratamento de erros usando Try-Catch-Finally

- Executando o código

da.SelectCommand = New OleDbCommand("Select * from Clientes", cn)
  da.FillSchema(ds, SchemaType.Mapped)
  da.Fill(ds)
  dgrid.Dock = DockStyle.Fill
  dgrid.DataSource = ds
  dgrid.DataMember = "Table"

- da.SelectCommand - é uma declaração SQL que irá selecionar os registros do banco de dados para a conexão criada.

- da.FillSchema - Carrega a estrutura dos dados do banco de dados para uma nova tabela chamda - Table - dentro da coleção de tabelas - Tables - do objeto DataSet.

- da.Fill - carrega dos dados do banco de dados para o objeto DataSet associado ao DataAdapter.

- dgrid.Dock = DockStyle.Fill - Ajusta a grade para preencher todo o formulário.

- dgrid.DataSource = ds - define a fonte de dados que será ligada ao controle DataGrid - dgrid.

- dgrid.DataMember = "Table" - define o membro "Table" do DataSet que será exibido na grade

- Código de tratamento do formulário - frm - e do controle DataGrid - dgrid.

frm.Controls.Add(dgrid)
frm.Text = "Preechendo um DataGrid"
frm.WindowState = FormWindowState.Normal
frm.ShowDialog()

- frm.Controls.Add(dgrid) - inclui o controle - dgrid - no formulário - frm .

- frm.Text = "Preechendo um DataGrid" - define o título do formulário

- frm.WindowState = FormWindowState.Normal - define que a janela do formulário será aberta no modo normal.

- frm.ShowDialog() - exibe o formulário na tela como modal.

- executa o código caso ocorra alguma exceção/erro durante o processamento. (Esta dentro do bloco - Catch )

MsgBox(erro.ToString, MsgBoxStyle.Exclamation)

É isso ai. Acabamos criando em tempo de execução um componente DataGrid e exibindo a grade com a informações de um banco de dados na tela. Aguarde que vem mais por ai...

Jose Carlos Macoratti