Lição 05 - The DataSet e SqlDataAdapter

[ÐλяkFeλя]

Lição 05 - Trabalhando com Disconnected Data - The DataSet  e  SqlDataAdapter

Esta lição explica como trabalhar com dados desconectados, usando
SqlDataAdapter o DataSet e objetos. Aqui estão os objectivos:

Compreender a necessidade de dados desconectado.
Obter uma compreensão básica do que é um DataSet.
Aprender a usar um SqlDataAdapter para recuperar e atualizar dados.

Introdução

Na Lição 3, discutimos um modo de funcionamento totalmente ligado para
interagirmos com uma fonte de dados usando o objeto SqlCommand.
Na Lição 4, nós aprendemos sobre como ler dados com o SqlDataReader. Esta lição mostra como
realizar alguma coisa nas entrelinhas SqlConnection e
SqlDataReader e DataSet usando o SqlDataAdapter
objetos.

Um DataSet é um armazenamento de dados na memória que podem conter numerosas
tabelas. Datasets apenas dispor de dados e não interagem com uma base de dados
fonte. É o SqlDataAdapter que gerencia conexões com
a fonte de dados e dá-nos desembraiado comportamento. O
SqlDataAdapter abre uma conexão somente quando necessário e fecha
que logo após ter realizado a sua missão. Por exemplo, o
SqlDataAdapter realiza as seguintes tarefas:

Abrir ligação
Recuperar dados em DataSet
Fechar a ligação
e executa as seguintes ações ao atualizar os dados com a fonte
DataSet mudanças:

Abrir ligação
Escreve mudanças a partir de DataSet para fonte de dados
Fechar a ligação
Fonte de dados são fechadas e você está livre para ler e escrever dados
com o DataSet como você necessita. Estes são os mecanismos de trabalho
com dados.

EX: "Um casal cenários ilustram" por que você gostaria de trabalhar com
desembraiado dados: pessoas que trabalham sem conectividade de rede e tornar sites mais escalável. Considere as pessoas que as vendas necessidade dos clientes, uma vez que os dados de viagem. No início do dia, que ele precisa para sincronizar-se com o principal banco de dados para ter as últimas informações disponíveis. Durante o dia, eles vão fazer
modificações de dados dos clientes existentes, adiciona novos clientes, e
entrada novas encomendas. Isso é certo, porque eles têm uma determinada região
ou carteira de clientes em que outras pessoas não será a mesma mutação
registros. No final do dia, as vendas pessoa que irá ligar a
a rede e atualizar as alterações de processamento overnight.

Outro cenário está a fazer um site mais escalável. Com um SqlDataReader, você tem que voltar para o banco de dados de registros
toda vez que você mostrar uma página. Isto exige uma nova ligação para cada página de carga, que vai doer escalabilidade à medida que o número de
utilizadores aumentar. Uma maneira de aliviar esta é usar um DataSet que é atualizada uma vez e armazenados em cache. Qualquer pedido para a
página verifica o cache e carrega os dados se não estiver lá ou
simplesmente puxa os dados de cache e apresenta-lo. Isso evita um
viagem para o banco de dados, tornando a sua aplicação mais eficiente.

Exceções para o cenário acima incluem situações em que você
necessidade de atualizar os dados. Você então tem que fazer uma decisão, baseada no
a natureza do modo como os dados serão utilizados como a sua estratégia. Usar
desembraiado dados quando a informação é, em primeiro lugar somente leitura,
mas considerar outras alternativas (como a utilização objeto SqlCommand
imediato para atualização), quando os seus requisitos para uma coisa chamada
mais dinâmico. Além disso, se a quantidade de dados é tão grande que
segurá-lo na memória é impraticável, você precisará usar SqlDataReader para só de leitura de dados. Realmente, poderia chegar a um
todos os tipos de exceções, mas a verdadeira força orientador deverá ser o
requisitos de sua aplicação que irá influenciar aquilo que o seu design deve ser.

Criando um objeto DataSet

Não há nada de especial sobre instantiating um DataSet. Você apenas criar uma nova instância, como qualquer outro objeto:

DsCustomers DataSet = new DataSet ();


O construtor DataSet não requer parâmetros. Contudo
há uma sobrecarga que aceita uma string para o nome da
DataSet, que é usado se você serializar os dados para XML.
Desde que não seja uma exigência para esse exemplo, eu deixei-o para fora.
Agora, o DataSet está vazio e você precisa de um SqlDataAdapter
carregá-lo.

Criando Um SqlDataAdapter

O SqlDataAdapter detém os comandos SQL e conexão objeto
para ler e gravar dados. Você inicializá-lo com um SQL
selecione declaração ea ligação objeto:

SqlDataAdapter daCustomers = new SqlDataAdapter (
     "select CustomerID, CompanyName FROM Customers", conn);

O código acima cria um novo SqlDataAdapter, daCustomers. O
Declaração SQL SELECT especifica os dados que serão lidos em uma
DataSet. O objeto de conexão conn, já deveria ter sido
instanciados, mas não abriu. É o SqlDataAdapter's
responsabilidade de abrir e fechar a conexão durante o preenchimento e
Atualizar método chamadas.

Como indicado anteriormente, o SqlDataAdapter contém todos os comandos necessários para interagir com a fonte de dados. O código mostrou como especificar a escolha declaração, mas não revelou a inserir, atualizar e excluir declarações. Estes são adicionados à SqlDataAdapter depois é instanciado.

Existem duas maneiras de adicionar inserir, atualizar e excluir comandos:

SqlDataAdapter ou através de propriedades com um SqlCommandBuilder. Em
esta lição, eu vou lhe mostrar a maneira mais fácil de fazê-lo com o SqlCommandBuilder. Em uma aula mais tarde, eu vou mostrar-lhe como usar o SqlDataAdapter propriedades, que tem mais trabalho, mas
dar-lhe mais capacidades do que aquilo que o SqlCommandBuilder faz.

Veja como adicionar comandos para o SqlDataAdapter com a
SqlCommandBuilder:

SqlCommandBuilder cmdBldr = new SqlCommandBuilder (daCustomers);

Observe que no código acima é que o SqlCommandBuilder instanciado com um único parâmetro do construtor
SqlDataAdapter, daCustomers, instância. Isto indica a SqlCommandBuilder que SqlDataAdapter para adicionar comandos para. O
SqlCommandBuilder lerá a declaração SQL SELECT (especificado quando o SqlDataAdapter foi instanciado), inferir a inserir, atualizar e excluir comandos e atribuir os novos comandos para a
Inserir, atualizar e excluir propriedades do SqlDataAdapter,
respectivamente.

Como mencionei anteriormente, o SqlCommandBuilder tem limitações.
Ele funciona quando você faz uma escolha simples declaração sobre uma única tabela.
No entanto, quando você precisa de um join de duas tabelas ou mor ou devem fazer uma
procedimento armazenado, não vai funcionar. Eu vou descrever um trabalho, em torno de
estes cenários de futuro lições.

Preenchendo o DataSet

Uma vez que você tenha um DataSet e SqlDataAdapter casos, você precisará
preencher o DataSet. Veja como fazer isso, usando o método Fill
do SqlDataAdapter:

daCustomers.Fill (dsCustomers, "Customers");


Preencha o método, no código acima, tem dois parâmetros: um
DataSet e uma tabela nome. O DataSet deve ser instanciado
antes de tentar preenchê-lo com os dados. O segundo parâmetro é o
nome da tabela que será criado no DataSet. Você pode
nome da tabela o que quiser. Sua finalidade é para que você possa
identificar a tabela com um nome significativo no futuro. Normalmente,
Vou dar-lhe o mesmo nome que o banco de dados tabela. No entanto, se
SqlDataAdapter a escolha do comando contém uma aderir, você precisará
para encontrar outro nome significativo.

Preencha o método tem uma sobrecarga que aceita um parâmetro para
o DataSet só. Nesse caso, a tabela foi criado um padrão nome de "tabela1" para a primeira tabela. O número será incrementada (tabela2, table3, ..., tableN) para cada mesa adicionado ao
DataSet onde o nome da tabela não foi especificado na Fill
método.

Usando o DataSet

Um DataSet irá vincular tanto com ASP.NET e Windows Forms
DataGrids. Aqui está um exemplo que atribui a DataSet para um
Windows Forms DataGrid:

dgCustomers.DataSource = dsCustomers;
dgCustomers.DataMember = "Clientes";

A primeira coisa que fazemos, no código acima, é atribuir o DataSet
à propriedade DataSource do DataGrid. Isso permite que o
DataGrid sei que tem algo de vincular a, mas você vai ter
um sinal '+' na GUI, porque o DataSet pode conter várias
quadros e isso permite-lhe expandir cada mesa disponível.
Para especificar exactamente qual tabela de usar, defina o DataGrid's
DataMember propriedade para o nome da tabela. No exemplo, nós
definir o nome de clientes, que é o mesmo nome usado como o
segundo parâmetro para o SqlDataAdapter Preencha método. Esta é a razão pela qual
Gosto de dar um nome em cima da mesa Preencha o método, na medida em que torna
subsequentes código mais legível.

Atualizando Mudanças

Após modificações são feitas para os dados, você deseja escrever
as alterações de volta para o banco de dados. Consulte a discussão anterior
na introdução deste artigo sobre a atualização orientação. O
seguinte código mostra como usar o método de atualização do
SqlDataAdapter modificações para empurrar de volta para o banco de dados.

daCustomers.Update (dsCustomers, "Customers");

O método Update, acima, é chamado sobre o SqlDataAdapter
exemplo, que originalmente preenchida a dsCustomers DataSet. O
segundo parâmetro para a atualização especifica em qual tabela método, a partir de
o DataSet, para atualização. A tabela contém uma lista de registros
que foram modificados e os inserir, atualizar e excluir
propriedades do SqlDataAdapter conter as declarações SQL utilizadas
de dados para fazer modificações.

Colocá-lo Todos Juntos

Até agora, você viu as peças necessárias para a execução
desconectado de gerenciamento de dados. O que realmente precisamos é de ver todos
isto implementado em uma aplicação. Listagem 1 mostra como o código
de todas as seções anteriores é usado em um programa de trabalho que
foi simplificado para reforçar os pontos desta lição:

Listing 1: Aplicar uma Desconectadas Dados Estratégia de Gestão

Código Selecionar Expandir

using System;
using System.Data;
using System.Data.SqlClient;
using System.Drawing;
using System.Windows.Forms;

class DisconnectedDataform : Form
{
private SqlConnection  conn;
private SqlDataAdapter daCustomers;

private DataSet  dsCustomers;
private DataGrid dgCustomers;

private const string tableName = "Customers";

// initialize form with DataGrid and Button
public DisconnectedDataform()
{
// fill dataset
Initdata();

// set up datagrid
dgCustomers = new DataGrid();
dgCustomers.Location = new Point(5, 5);
dgCustomers.Size = new Size(
this.ClientRectangle.Size.Width - 10,
this.ClientRectangle.Height - 50);
dgCustomers.DataSource = dsCustomers;
dgCustomers.DataMember = tableName;

// create update button
Button btnUpdate = new Button();
btnUpdate.Text = "Update";
btnUpdate.Location = new Point(
this.ClientRectangle.Width/2 -
btnUpdate.Width/2,
this.ClientRectangle.Height -
(btnUpdate.Height + 10));
btnUpdate.Click += new
EventHandler(btnUpdateClicked);

// make sure controls appear on form
Controls.AddRange(new Control[] { dgCustomers,
btnUpdate });
}

// set up ADO.NET objects
public void Initdata()
{
// instantiate the connection
conn = new SqlConnection(

"Server=(local);DataBase=Northwind;Integrated Security=SSPI");

// 1. instantiate a new DataSet
dsCustomers = new DataSet();

// 2. init SqlDataAdapter with select command and
connection
daCustomers = new SqlDataAdapter(
"select CustomerID, CompanyName from
Customers", conn);

// 3. fill in insert, update, and delete commands
SqlCommandBuilder cmdBldr = new
SqlCommandBuilder(daCustomers);

// 4. fill the dataset
daCustomers.Fill(dsCustomers, tableName);
}

// Update button was clicked
public void btnUpdateClicked(object sender, EventArgs e)
{
// write changes back to DataBase
daCustomers.Update(dsCustomers, tableName);
}

// start the Windows form
static void Main()
{
Application.Run(new DisconnectedDataForm());
}
}


O método Initdata na Listagem 1 contém os métodos necessários
para configurar o SqlDataAdapter e DataSet. Repare que vários
objetos de dados são definidos na classe nível para que possam ser utilizados em
vários métodos. O DataGrid do DataSource propriedade é definida no
construtor. Sempre que um usuário clica no botão Atualizar, o
Atualização método na btnUpdateClicked evento manipulador é chamado,
empurrando modificações de volta para o banco de dados.

Resumo

Datasets deter várias tabelas e pode ser mantido na memória e
reutilizados. O SqlDataAdapter permite que você preencha um DataSet e
Actualizar as alterações de volta para o banco de dados. Você não tem que preocupar-se
sobre abertura e encerramento das SqlConnection porque o
SqlDataAdapter faz isso automaticamente. Um SqlCommandBuilder
preenche inserir, atualizar e excluir comandos baseado no
SqlDataAdapter da escolha declaração. Use o método de preenchimento do
SqlDataAdapter para preencher um DataSet com dados. Chame o
SqlDataAdapter da Atualização método para impulsionar as alterações de volta para uma
base de dados.


CoNtInUa Lição 6...



By: Dark FEar