100% acharam este documento útil (1 voto)

555 visualizações

Manual C#

Este documento fornece uma visão geral dos recursos disponíveis no Visual Studio para trabalhar com dados, incluindo conectividade a vários sistemas de banco de dados, ferramentas para modelagem de objetos e vinculação de dados, e integração com serviços de armazenamento de dados da Microsoft Azure.

Enviado por

Newton Magalhães

Direitos autorais

Formatos disponíveis

Baixe no formato PDF, TXT ou leia on-line no Scribd

100% acharam este documento útil (1 voto)

555 visualizações

Manual C#

Enviado por

Newton Magalhães

Direitos autorais

Formatos disponíveis

Baixe no formato PDF, TXT ou leia on-line no Scribd

Você está na página 1/ 376

Visão geral
Tutoriais
Criar um aplicativo de dados simples usando o ADO.NET
Criar um aplicativo de dados simples usando o WPF e o Entity Framework
Conecte-se aos dados usando um aplicativo C++
Criar classes LINQ to SQL usando o Designer Relacional de Objetos
Criar um aplicativo de dados de n camadas
Conceitos
Sistemas de banco de dados compatíveis
Ferramentas de dados do Visual Studio para .NET
Ferramentas do Entity Framework
DataSets
Ferramentas de conjunto de dados
Conjuntos de dados tipados vs. não tipados
Visão geral de TableAdapters
Trabalhar com conjuntos de dados em aplicativos de n camadas
Projetos de banco de dados e aplicativos da camada de dados (DAC)
Visão geral de aplicativos de dados de N camadas
Guias de instruções
Criar um banco de dados
conexões
Adicionar conexões
Salvar e editar cadeias de conexão
Conectar-se a dados em um banco de dados
Adicionar fontes de dados do .NET
Ferramentas do LINQ to SQL
Visão geral
Alterar o tipo de retorno de um método DataContext
Criar métodos DataContext mapeados para os procedimentos armazenados
Configurar a herança usando o Designer Relacional de Objetos
Criar classes LINQ to SQL mapeadas para tabelas e exibições
Estender o código gerado pelo Designer Relacional de Objetos
Criar uma associação entre classes LINQ to SQL
Adicionar validação a classes de entidade
Personalizar o comportamento de inserção, atualização e exclusão de classes de
entidade
Atribuir procedimentos armazenados para executar atualizações, inserções e
exclusões
Habilitar e desabilitar a pluralização
Usar as ferramentas do conjunto de dados
Criar conjuntos de dados
Criar e configurar conjuntos de dados
Criar relações entre conjuntos de dados
Criar um conjunto de dados usando o Designer de conjunto de dados
Criar uma tabela de dados usando o Designer de conjunto de dados
Configurar TableAdapters
Criar e configurar TableAdapters
Criar consultas TableAdapter parametrizadas
Acessar o banco de dados diretamente com um TableAdapter
Desativar as restrições ao preencher um conjunto de dados
Estender a funcionalidade de um TableAdapter
Ler dados XML em um conjunto de dados
Editar dados no conjuntos de dados
Validar dados no conjuntos de dados
Salvar dados novamente no banco de dados
Visão geral
Inserir novos registros em um banco de dados
Atualizar dados usando um TableAdapter
Executar uma atualização hierárquica
Tratar uma exceção de simultaneidade
Transactions
Salvar dados usando uma transação
Passo a passo: salvar dados em uma transação
Salvar dados em um banco de dados (várias tabelas)
Salvar dados de um objeto em um banco de dados
Salvar os dados com os métodos TableAdapter DBDirect
Salvar um conjunto de dados como XML
Consultar um conjuntos de dados
Aplicativos de N camadas
Adicionar validação a um conjunto de dados de n camadas
Adicionar código aos conjuntos de dados em aplicativos de n camadas
Adicionar código a TableAdapters em aplicativos de n camadas
Separar conjuntos de dados e TableAdapters em diferentes projetos
Controles
Associar controles a fontes de dados
Definir o controle a ser criado quando arrastado da janela Fontes de Dados
Adicionar controles personalizados à janela Fontes de Dados
Controles do WPF
Associar controles do WPF a dados
Associar controles do WPF a um conjunto de dados
Associar controles do WPF a um WCF Data Service
Criar tabelas de pesquisa
Exibir dados relacionados
Associar controles a imagens de um banco de dados
Controles de formulários do Windows
Associar controles do Windows Forms a dados
Filtrar e classificar dados em um aplicativo do Windows Forms
Confirmar edições no processo em controles associados a dados antes de salvar os
dados
Criar tabelas de pesquisa
Criar um Windows Form para pesquisar dados
Criar um controle de usuário compatível com associação de dados simples
Criar um controle de usuário compatível com associação de dados complexos
Criar um controle de usuário compatível com associação de dados de pesquisa
Passar dados entre formulários
Associar objetos personalizados
Personalizar como o Visual Studio cria legendas para controles associados a dados
Serviços do Windows Communication Foundation e WCF Data Services
Visão geral do WCF no Visual Studio
Trabalhar com um modelo conceitual
Conectar a dados em um serviço
Criar um serviço WCF no Windows Forms
Criar um WCF Data Service com o WPF e o Entity Framework
Solucionar problemas de referências de serviço
Configurar a caixa de diálogo de referência de serviço
Adicionar, atualizar ou remover uma referência do WCF Data Service
Atualizar arquivos .mdf
Referência
O/R Designer (Linq to SQL)
Métodos DataContext
Herança de classe de dados
Mensagens do Designer Relacional de Objetos
A classe selecionada não pode ser excluída porque é usada como um tipo de
retorno para um ou mais métodos DataContext
A cadeia de conexão contém credenciais com uma senha de texto não
criptografado e não estiver usando segurança integrada
A propriedade <property name> não pode ser excluída porque participa da
associação <association name>
A propriedade <property name> não pode ser excluída
A propriedade de conexão no arquivo de configurações do aplicativo está ausente
ou incorreta
Não é possível criar uma associação <association name> – os tipos de
propriedade não correspondem
Aviso. As alterações foram feitas à caixa de diálogo configurar o comportamento
que não foram aplicadas
Você tiver selecionado um objeto de base de dados de um provedor de base de
dados sem suporte
Este método relacionado é o método de suporte para a seguir inserção,
atualização, ou métodos padrão de exclusão
Um ou mais itens selecionados contêm um tipo de dados que não é suportado
pelo designer
Altere o tipo de retorno de um método DataContext não pode ser desfeito
O designer não pode ser alterado para depuração
A conexão selecionada usa um provedor de base de dados sem suporte
Os objetos você estiver adicionando ao uso de designer uma conexão de dados
diferente do designer está usando atualmente
Não é possível criar uma associação <association name> – propriedade listada
duas vezes
Não foi possível recuperar informações de esquema para o objeto de banco de
dados
Um ou mais objetos de base de dados selecionado retornam um esquema que
não corresponde ao esquema de classe de destino
Trabalhar com dados no Visual Studio
20/11/2021 • 10 minutes to read

No Visual Studio, você pode criar aplicativos que se conectam a dados em praticamente qualquer produto ou
serviço de banco de dados, em qualquer formato, em qualquer lugar, em um computador local, em uma rede
local ou em uma nuvem pública, privada ou híbrida.
Para aplicativos em JavaScript, Python, PHP, Ruby ou C++, você se conecta a dados como faz com qualquer
outra coisa, obtendo bibliotecas e escrevendo código. Para aplicativos .NET, o Visual Studio fornece ferramentas
que você pode usar para explorar fontes de dados, criar modelos de objeto para armazenar e manipular dados
na memória e vincular dados à interface do usuário. Microsoft Azure fornece SDKs para .NET, Java, Node.js, PHP,
Python, Ruby e aplicativos móveis e ferramentas no Visual Studio para se conectar ao Azure Armazenamento.
As listas a seguir mostram apenas alguns dos muitos sistemas de banco de dados e armazenamento que
podem ser usados Visual Studio. As Microsoft Azure são serviços de dados que incluem todo o provisionamento
e administração do armazenamento de dados subjacente. A carga de trabalho de desenvolvimento do Azure no
Visual Studio 2017 permite que você trabalhe com armazenamentos de dados do Azure diretamente do Visual
Studio.
As listas a seguir mostram apenas alguns dos muitos sistemas de banco de dados e armazenamento que
podem ser usados Visual Studio. As Microsoft Azure são serviços de dados que incluem todo o provisionamento
e administração do armazenamento de dados subjacente. A carga de trabalho de desenvolvimento do Azure
Visual Studio 2019 permite que você trabalhe com armazenamentos de dados do Azure diretamente do Visual
Studio.

A maioria dos outros SQL e produtos de banco de dados NoSQL listados aqui pode ser hospedada em um
computador local, em uma rede local ou Microsoft Azure em uma máquina virtual. Se você hospedar o banco
de dados em uma Microsoft Azure virtual, você será responsável por gerenciar o próprio banco de dados.
Microsoft Azure
Banco de Dados SQL
Azure Cosmos DB
Armazenamento (blobs, tabelas, filas, arquivos)
SQL Data Warehouse
SQL Server Stretch Database
StorSimple
E muito mais…
SQL
SQL Server 2005-2016 (inclui Express e LocalDB)
Firebird
MariaDB
MySQL
Oracle
PostgreSQL
SQLite
E muito mais…
NoSQL
Apache Cassandra
CouchDB
MongoDB
NDatabase
OrientDB|
RavenDB
VelocityDB
E muito mais…
Muitos fornecedores de banco de dados e terceiros são Visual Studio integração por NuGet pacotes. Você pode
explorar as ofertas no nuget.org ou por meio do NuGet Gerenciador de Pacotes no Visual Studio ( Ferramentas
> NuGet Gerenciador de Pacotes Gerenciar pacotes NuGet > para a solução). Outros produtos de banco
de dados se integram Visual Studio como uma extensão. Você pode procurar essas ofertas no Visual Studio
Marketplace ou navegando até Extensões e Atualizações de Ferramentas e selecionando Online no painel
esquerdo da caixa > de diálogo. Para obter mais informações, consulte Sistemas de banco de dados compatíveis
para Visual Studio.
Muitos fornecedores de banco de dados e terceiros são Visual Studio integração por NuGet pacotes. Você pode
explorar as ofertas no nuget.org ou por meio do NuGet Gerenciador de Pacotes no Visual Studio ( Ferramentas
> NuGet Gerenciador de Pacotes Gerenciar pacotes NuGet > para a solução). Outros produtos de banco
de dados se integram Visual Studio como uma extensão. Você pode procurar essas ofertas no Visual Studio
Marketplace ou navegando até Extensões Gerenciar Extensões e, em seguida, selecionando Online no painel
esquerdo da caixa > de diálogo. Para obter mais informações, consulte Sistemas de banco de dados compatíveis
para Visual Studio.

NOTE
O suporte estendido para o SQL Server 2005 terminou em 12 de abril de 2016. Não há nenhuma garantia de que as
ferramentas de dados Visual Studio 2015 e posterior continuarão a funcionar com o SQL Server 2005. Para obter mais
informações, consulte o comunicado de fim de suporte do SQL Server 2005.

Linguagens .NET
Todo o acesso a dados do .NET, incluindo no .NET Core, é baseado no ADO.NET, um conjunto de classes que
define uma interface para acessar qualquer tipo de fonte de dados, relacional e não relacional. Visual Studio tem
várias ferramentas e designers que funcionam com o ADO.NET para ajudá-lo a se conectar a bancos de dados,
manipular os dados e apresentar os dados ao usuário. A documentação nesta seção descreve como usar essas
ferramentas. Você também pode programar diretamente nos objetos de ADO.NET comando. Para obter mais
informações sobre como chamar as APIs ADO.NET diretamente, consulte ADO.NET.
Para a documentação de acesso a dados ASP.NET, consulte Trabalhando com dados no site ASP.NET dados. Para
ver um tutorial sobre como usar Entity Framework com ASP.NET MVC, consulte Ponto de Partida com Entity
Framework 6 Code First usando o MVC 5.
Aplicativos UWP (Plataforma Universal Windows) em C# ou Visual Basic podem usar o SDK do Microsoft Azure
para .NET para acessar o Azure Armazenamento e outros serviços do Azure. O Windows. A classe
Web.HttpClient permite a comunicação com qualquer serviço RESTful. Para obter mais informações, consulte
Como se conectar a um servidor HTTP usando Windows. Web.Http.
Para o armazenamento de dados no computador local, a abordagem recomendada é usar o SQLite, que é
executado no mesmo processo que o aplicativo. Se uma camada ORM (mapeamento relacional de objeto) for
necessária, você poderá usar Entity Framework. Para obter mais informações, consulte Acesso a dados no
Windows Developer Center.
Se você estiver se conectando aos serviços do Azure, baixe as ferramentas mais recentes do SDK do Azure.
Provedores de dados
Para que um banco de dados seja consumível ADO.NET, ele deve ter um provedor de dados ADO.NET
personalizado ou então deve expor uma interface ODBC ou OLE DB. A Microsoft fornece uma lista de ADO.NET
de dados para SQL Server, bem como provedores ODBC e OLE DB dados.

NOTE
Se estiver usando o Visual Studio para se conectar a bancos de dados usando provedores de dados OLEDB ou ODBC,
você precisará estar ciente de que as versões do Visual Studio anteriores ao Visual Studio 2022 são todos processos de 32
bits. Isso significa que algumas das ferramentas de dados no Visual Studio só poderão se conectar a bancos de dados
OLEDB ou ODBC usando provedores de dados de 32 bits. Isso inclui o provedor de dados OLEDB de 32 bits do Microsoft
Access, bem como outros provedores de 32 bits de terceiros.
Se estiver usando o Visual Studio 2022 para se conectar a bancos de dados, você precisará estar ciente de que Visual
Studio 2022 é um processo de 64 bits. Isso significa que algumas das ferramentas de dados no Visual Studio não poderão
se conectar a bancos de dados OLEDB ou ODBC usando provedores de dados de 32 bits.
Se você precisar manter aplicativos de 32 bits que se conectam a bancos de dados OLEDB ou ODBC, você ainda poderá
criar e executar o aplicativo com o Visual Studio 2022. No entanto, se você precisar usar qualquer uma das Ferramentas
de Dados do Visual Studio, como o Gerenciador de Servidores, o Assistente de Fonte de Dados ou o Designer de
Conjuntos de Dados, precisará usar uma versão anterior do Visual Studio que ainda seja um processo de 32 bits. A última
versão do Visual Studio que era um processo de 32 bits foi Visual Studio 2019.
Se você planeja converter o projeto para ser um processo de 64 bits, é recomendável usar o Microsoft Access Mecanismo
de Banco de Dados de 64 bits, também chamado de ACE (Mecanismo de Conectividade de Acesso). Consulte OLE DB
provedor para Jet e driver ODBC são versões de 32 bits apenas para obter mais informações.

Modelagem de dados
No .NET, você tem três opções para modelar e manipular dados na memória depois de recuperá-los de uma
fonte de dados:
Entity Framework A tecnologia orm da Microsoft preferida. Você pode usá-lo para programar dados relacionais
como objetos .NET de primeira classe. Para novos aplicativos, ele deve ser a primeira opção padrão quando um
modelo é necessário. Ele requer suporte personalizado do provedor de ADO.NET subjacente.
LINQ to SQL Um mapeado relacional de objeto de geração anterior. Ele funciona bem para cenários menos
complexos, mas não está mais em desenvolvimento ativo.
Conjuntos de dados A mais antiga das três tecnologias de modelagem. Ele foi projetado principalmente para o
desenvolvimento rápido de aplicativos "formulários sobre dados", nos quais você não está processando grandes
quantidades de dados ou executando consultas ou transformações complexas. Um objeto DataSet consiste em
objetos DataTable e DataRow que se assemelham logicamente SQL objetos de banco de dados muito mais do
que objetos .NET. Para aplicativos relativamente simples baseados SQL fontes de dados, os conjuntos de dados
ainda podem ser uma boa opção.
Não há nenhum requisito para usar nenhuma dessas tecnologias. Em alguns cenários, especialmente quando o
desempenho é crítico, você pode simplesmente usar um objeto DataReader para ler do banco de dados e copiar
os valores necessários para um objeto de coleção, como <T> Listar .
C++ nativo
Os aplicativos C++ que se conectam ao SQL Server devem usar o Microsoft® ODBC Driver 13.1 para SQL
Server na maioria dos casos. se os servidores estiverem vinculados, OLE DB será necessário e para que você use
o SQL Server Native Client. Você pode acessar outros bancos de dados usando os drivers ODBC ou OLE DB
diretamente. O ODBC é a interface de banco de dados padrão atual, mas a maioria dos sistemas de banco de
dados fornece uma funcionalidade personalizada que não pode ser acessada pela interface ODBC. OLE DB é
uma tecnologia de acesso a dados COM herdada que ainda é suportada, mas não é recomendada para novos
aplicativos. Para obter mais informações, consulte acesso a dados em Visual C++.
Os programas C++ que consomem serviços REST podem usar o C++ REST SDK.
programas C++ que funcionam com Armazenamento do Microsoft Azure podem usar o cliente
Armazenamento do Microsoft Azure.
—a Visual Studio de modelagem de dados não fornece uma camada de ORM para C++. O ODB é um popular
ORM de código-fonte aberto para C++.
para saber mais sobre como se conectar a bancos de dados de aplicativos c++, consulte Visual Studio data tools
para C++. Para obter mais informações sobre as tecnologias de acesso a dados herdadas Visual C++, consulte
acesso a dados.

JavaScript
o JavaScript no Visual Studio é uma linguagem de primeira classe para a criação de aplicativos de plataforma
cruzada, aplicativos UWP, serviços de nuvem, sites e aplicativos web. você pode usar Bower, Grunt, Gulp, npm e
NuGet de dentro Visual Studio para instalar suas bibliotecas JavaScript favoritas e seus produtos de banco de
dados. Conexão o armazenamento e os serviços do azure baixando SDKs do site do azure. Edge.js é uma
biblioteca que conecta o JavaScript do lado do servidor (Node.js) a ADO.NET fontes de dados.

Python
instale o suporte do python no Visual Studio para criar aplicativos Python. A documentação do Azure tem vários
tutoriais sobre como se conectar a dados, incluindo o seguinte:
Django e Banco de Dados SQL no Azure
Django e MySQL no Azure
Trabalhe com BLOBs, arquivos, filase tabelas (Cosmo DB).

Tópicos relacionados
Plataforma de ia da Microsoft — fornece uma introdução à nuvem inteligente da Microsoft, incluindo o Cortana
Analytics Suite e suporte para Internet das Coisas.
Armazenamento do Microsoft Azure — descreve o Armazenamento do Azure e como criar aplicativos usando
blobs, tabelas, filas e arquivos do azure.
Banco de Dados SQL do Azure — descreve como se conectar ao Banco de Dados SQL do Azure, um banco de
dados relacional como um serviço.
SQL Server Data Tools — Descreve as ferramentas que simplificam o design, a exploração, o teste e a
implantação de aplicativos e bancos de dados conectados a data.
ADO.net — descreve a arquitetura de ADO.NET e como usar as classes de ADO.NET para gerenciar dados de
aplicativos e interagir com fontes de dados e XML.
ADO.NET Entity Framework — Descreve como criar aplicativos de dados que permitem aos desenvolvedores
programar em um modelo conceitual em vez de diretamente em relação a um banco de dados relacional.
WCF Data Services 4,5 — Descreve como usar WCF Data Services o para implantar serviços de dados na Web
ou em uma intranet que implementam o protocolo Open Data (OData).
dados em soluções — de Office contém links para tópicos que explicam como os dados funcionam em Office
soluções. Isso inclui informações sobre programação orientada a esquema, cache de dados e acesso a dados no
servidor.
LINQ (consulta integrada à linguagem) — descreve os recursos de consulta incorporados ao C# e Visual Basic, e
o modelo comum para consultar bancos de dados relacionais, documentos XML, datasets e coleções na
memória.
Ferramentas XML no Visual Studio — Discute o trabalho com dados XML, depuração XSLT, recursos XML do
.NET e a arquitetura da consulta XML.
Documentos e dados XML — Fornece uma visão geral de um conjunto abrangente e integrado de classes que
funcionam com documentos e dados XML no .NET.
Criar um aplicativo de dados simples usando o
ADO.NET
20/11/2021 • 20 minutes to read

Ao criar um aplicativo que manipula dados em um banco de dados, você executa tarefas básicas, como definir
cadeias de conexão, inserir dados e executar procedimentos armazenados. Seguindo este tópico, você pode
descobrir como interagir com um banco de dados de dentro de um aplicativo simples de "formulários sobre
dados" do Windows Forms usando o Visual C# ou Visual Basic e ADO.NET. Todas as tecnologias de dados do
.NET, incluindo conjuntos de dados, LINQ to SQL e Entity Framework, executam etapas muito semelhantes às
mostradas neste artigo.
Este artigo demonstra uma maneira simples de obter dados de um banco de dados de maneira rápida. Se seu
aplicativo precisar modificar dados de maneiras não triviais e atualizar o banco de dados, considere usar o Entity
Framework e usar a associação de dados para sincronizar automaticamente os controles de interface do usuário
com as alterações nos dados subjacentes.

IMPORTANT
Para manter o código simples, ele não inclui o tratamento de exceção pronto para produção.

Pré-requisitos
Para criar o aplicativo, você precisará de:
Visual Studio.
LocalDB do SQL Server Express. Se você não tiver um SQL Server Express LocalDB, poderá instalá-lo na
página SQL Server Express download do .
Este tópico presume que você esteja familiarizado com a funcionalidade básica do IDE do Visual Studio e pode
criar um aplicativo do Windows Forms, adicionar formulários ao projeto, colocar botões e outros controles nos
formulários, definir propriedades dos controles e codificar eventos simples. Se você não estiver confortável com
essas tarefas, sugerimos que você conclua o tópico Guia de Visual Basic Visual C# antes de iniciar este passo a
passo.

Configurar o banco de dados de exemplo

Crie o banco de dados de exemplo seguindo estas etapas:
1. No Visual Studio, abra a Gerenciador de Ser vidores janela.
2. Clique com o botão direito do mouse em Conexões de Dados e escolha Criar SQL Ser ver Banco de
Dados .
3. Na caixa de texto Nome do servidor, insira (localdb)\mssqllocaldb .
4. Na caixa de texto Novo nome do banco de dados, insira Vendas e, em seguida, escolha OK.
O banco de dados Sales vazio é criado e adicionado ao nó Conexões de Dados no Gerenciador de
Servidores.
5. Clique com o botão direito do mouse na conexão de dados vendas e selecione Nova Consulta .
Uma janela do editor de consultas é aberta.
6. Copie o script Sales Transact-SQL para a área de transferência.
7. Colar o script T-SQL no editor de consultas e, em seguida, escolha o botão Executar.
Após um curto período, a consulta termina a execução e os objetos de banco de dados são criados. O
banco de dados contém duas tabelas: Cliente e Pedidos. Essas tabelas não contêm dados inicialmente,
mas você pode adicionar dados ao executar o aplicativo que criará. O banco de dados também contém
quatro procedimentos armazenados simples.

Criar os formulários e adicionar controles

1. Crie um projeto para um aplicativo Windows Forms e, em seguida, nomee-o SimpleDataApp.
Visual Studio cria o projeto e vários arquivos, incluindo um formulário Windows vazio chamado Form1 .
2. Adicione dois Windows formulários ao projeto para que ele tenha três formulários e, em seguida, dê a
eles os seguintes nomes:
Navegação
NewCustomer
FillOrCancel
3. Para cada formulário, adicione as caixas de texto, botões e outros controles que aparecem nas ilustrações
a seguir. Para cada controle, de definir as propriedades que as tabelas descrevem.

NOTE
A caixa de grupo e os controles de rótulo adicionam clareza, mas não são usados no código.

Formulário de navegação

C O N T RO L ES PA RA O F O RM UL Á RIO DE N AVEGA Ç Ã O P RO P RIEDA DES

Botão Nome = btnGoToAdd

Botão Nome = btnGoToFillOrCancel

Botão Nome = btnExit

Formulário NewCustomer
C O N T RO L ES PA RA O F O RM UL Á RIO N EW C USTO M ER P RO P RIEDA DES

TextBox Name = txtCustomerName

TextBox Nome = txtCustomerID

Readonly = True

Botão Nome = btnCreateAccount

NumericUpdown DecimalPlaces = 0

Máximo = 5000

Nome = numOrderAmount

DateTimePicker Formato = Curto

Nome = dtpOrderDate

Botão Nome = btnPlaceOrder

Botão Nome = btnAddAnotherAccount

Botão Nome = btnAddFinish

Formulário FillOrCancel
C O N T RO L ES PA RA O F O RM UL Á RIO F IL LO RC A N C EL P RO P RIEDA DES

TextBox Nome = txtOrderID

Botão Nome = btnFindByOrderID

DateTimePicker Formato = Curto

Nome = dtpFillDate

DataGridView Nome = dgvCustomerOrders

Readonly = True

RowHeadersVisible = False

Botão Nome = btnCancelOrder

Botão Nome = btnFillOrder

Botão Nome = btnFinishUpdates

Armazenar a cadeia de conexão

Quando seu aplicativo tenta abrir uma conexão com o banco de dados, seu aplicativo deve ter acesso à cadeia
de conexão. Para evitar inserir a cadeia de caracteres manualmente em cada formulário, armazene a cadeia de
caracteres no arquivo App.config em seu projeto e crie um método que retorna a cadeia de caracteres quando o
método é chamado de qualquer formulário em seu aplicativo.
Você pode encontrar a cadeia de conexão clicando com o botão direito do mouse na conexão de dados sales no
Gerenciador de Ser vidores e escolhendo Propriedades . Localize a propriedade ConnectionString e, em
seguida, use Ctrl A , Ctrl C para selecionar e copiar a cadeia + de + caracteres para a área de transferência.
1. Se você estiver usando C#, no Gerenciador de Soluções , expanda o nó Propriedades no projeto e abra
o arquivo Configurações.settings. Se você estiver usando Visual Basic, no Gerenciador de Soluções ,
clique em Mostrar Todos os Arquivos , expanda o nó Meu Project e, em seguida, abra o arquivo
Configurações.settings.
2. Na coluna Nome, insira connString .
3. Na lista Tipo, selecione (Cadeia de Conexão) .
4. Na lista Escopo, selecione Aplicativo .
5. Na coluna Valor, insira a cadeia de conexão (sem aspas externas) e salve as alterações.

NOTE
Em um aplicativo real, você deve armazenar a cadeia de conexão com segurança, conforme descrito em Cadeias de
conexão e arquivos de configuração.

Escrever o código para os formulários

Esta seção contém breves visão geral do que cada formulário faz. Ele também fornece o código que define a
lógica subjacente quando um botão no formulário é clicado.
Formulário de navegação
O formulário navegação é aberto quando você executar o aplicativo. O botão Adicionar uma conta abre o
formulário NewCustomer. O botão Preencher ou cancelar pedidos abre o formulário FillOrCancel. O botão
Sair fecha o aplicativo.
Tornar o formulário de navegação o formulário de inicialização
Se você estiver usando C#, no Gerenciador de Soluções , abra Program.cs e altere Application.Run a linha
para esta: Application.Run(new Navigation());
Se você estiver usando Visual Basic, no Gerenciador de Soluções , abra a janela Propriedades, selecione a guia
Aplicativo e, em seguida, selecione SimpleDataApp.Navigation na lista Formulário de inicialização.
Criar manipuladores de eventos gerados automaticamente
Clique duas vezes nos três botões no formulário de navegação para criar métodos de manipulador de eventos
vazios. Clicar duas vezes nos botões também adiciona código gerado automaticamente no arquivo de código do
Designer que permite que um clique de botão ative um evento.
Adicionar código para a lógica do formulário de navegação
Na página de código do formulário navegação, conclua os corpos do método para os três manipuladores de
eventos de clique de botão, conforme mostrado no código a seguir.
/// <summary>
/// Opens the NewCustomer form as a dialog box,
/// which returns focus to the calling form when it is closed.
/// </summary>
private void btnGoToAdd_Click(object sender, EventArgs e)
{
Form frm = new NewCustomer();
frm.Show();
}

/// <summary>
/// Opens the FillorCancel form as a dialog box.
/// </summary>
private void btnGoToFillOrCancel_Click(object sender, EventArgs e)
{
Form frm = new FillOrCancel();
frm.ShowDialog();
}

/// <summary>
/// Closes the application (not just the Navigation form).
/// </summary>
private void btnExit_Click(object sender, EventArgs e)
{
this.Close();
}

''' <summary>
''' Opens the NewCustomer form as a dialog box, which returns focus to the calling form when it closes.
''' </summary>
Private Sub btnGoToAdd_Click(sender As Object, e As EventArgs) Handles btnGoToAdd.Click
Dim frm As Form = New NewCustomer()
frm.Show()
End Sub

''' <summary>
''' Opens the FillOrCancel form as a dialog box.
''' </summary>
Private Sub btnGoToFillOrCancel_Click(sender As Object, e As EventArgs) Handles btnGoToFillOrCancel.Click
Dim frm As Form = New FillOrCancel()
frm.ShowDialog()
End Sub

''' <summary>
''' Closes the application (not just the navigation form).
''' </summary>
Private Sub btnExit_Click(sender As Object, e As EventArgs) Handles btnExit.Click
Me.Close()
End Sub

Formulário NewCustomer
Quando você insera um nome de cliente e, em seguida, seleciona o botão Criar Conta, o formulário
NewCustomer cria uma conta de cliente e SQL Server retorna um valor IDENTITY como a nova ID do cliente. Em
seguida, você pode fazer um pedido para a nova conta especificando um valor e uma data de pedido e
selecionando o botão Fazer Pedido.
Criar manipuladores de eventos gerados automaticamente
Crie um manipulador de eventos Click vazio para cada botão no formulário NewCustomer clicando duas vezes
em cada um dos quatro botões. Clicar duas vezes nos botões também adiciona código gerado automaticamente
no arquivo de código do Designer que permite que um clique de botão ative um evento.
Adicionar código para a lógica de formulário NewCustomer
Para concluir a lógica do formulário NewCustomer, siga estas etapas.
1. Colocar o namespace no escopo para que você não tenha que qualificar System.Data.SqlClient
totalmente os nomes de seus membros.

using System.Data.SqlClient;

Imports System.Data.SqlClient

2. Adicione algumas variáveis e métodos auxiliares à classe , conforme mostrado no código a seguir.
// Storage for IDENTITY values returned from database.
private int parsedCustomerID;
private int orderID;

/// <summary>
/// Verifies that the customer name text box is not empty.
/// </summary>
private bool IsCustomerNameValid()
{
if (txtCustomerName.Text == "")
{
MessageBox.Show("Please enter a name.");
return false;
}
else
{
return true;
}
}

/// <summary>
/// Verifies that a customer ID and order amount have been provided.
/// </summary>
private bool IsOrderDataValid()
{
// Verify that CustomerID is present.
if (txtCustomerID.Text == "")
{
MessageBox.Show("Please create customer account before placing order.");
return false;
}
// Verify that Amount isn't 0.
else if ((numOrderAmount.Value < 1))
{
MessageBox.Show("Please specify an order amount.");
return false;
}
else
{
// Order can be submitted.
return true;
}
}

/// <summary>
/// Clears the form data.
/// </summary>
private void ClearForm()
{
txtCustomerName.Clear();
txtCustomerID.Clear();
dtpOrderDate.Value = DateTime.Now;
numOrderAmount.Value = 0;
this.parsedCustomerID = 0;
}
' Storage for ID values returned from the database.
Private parsedCustomerID As Integer
Private orderID As Integer

''' <summary>
''' Verifies that the customer name text box is not empty.
''' </summary>
Private ReadOnly Property IsCustomerNameValid As Boolean
Get
If txtCustomerName.Text = "" Then
MessageBox.Show("Please enter a name.")
Return False
Else
Return True
End If
End Get
End Property

''' <summary>
''' Verifies the order data is valid.
''' </summary>
Private Function IsOrderDataValid() As Boolean

' Verify that CustomerID is present.

If txtCustomerID.Text = "" Then
MessageBox.Show("Please create a customer account before placing order.")
Return False

' Verify that order amount isn't 0.

ElseIf (numOrderAmount.Value < 1) Then
MessageBox.Show("Please specify an order amount.")
Return False
Else
' Order can be submitted.
Return True
End If
End Function

''' <summary>
''' Clears values from controls.
''' </summary>
Private Sub ClearForm()
txtCustomerName.Clear()
txtCustomerID.Clear()
dtpOrderDate.Value = DateTime.Now
numOrderAmount.Value = 0
Me.parsedCustomerID = 0
End Sub

3. Conclua os corpos do método para os manipuladores de eventos de clique de quatro botões, conforme
mostrado no código a seguir.

/// <summary>
/// Creates a new customer by calling the Sales.uspNewCustomer stored procedure.
/// </summary>
private void btnCreateAccount_Click(object sender, EventArgs e)
{
if (IsCustomerNameValid())
{
// Create the connection.
using (SqlConnection connection = new SqlConnection(Properties.Settings.Default.connString))
{
// Create a SqlCommand, and identify it as a stored procedure.
using (SqlCommand sqlCommand = new SqlCommand("Sales.uspNewCustomer", connection))
{
sqlCommand.CommandType = CommandType.StoredProcedure;
sqlCommand.CommandType = CommandType.StoredProcedure;

// Add input parameter for the stored procedure and specify what to use as its value.
sqlCommand.Parameters.Add(new SqlParameter("@CustomerName", SqlDbType.NVarChar, 40));
sqlCommand.Parameters["@CustomerName"].Value = txtCustomerName.Text;

// Add the output parameter.

sqlCommand.Parameters.Add(new SqlParameter("@CustomerID", SqlDbType.Int));
sqlCommand.Parameters["@CustomerID"].Direction = ParameterDirection.Output;

try
{
connection.Open();

// Run the stored procedure.

sqlCommand.ExecuteNonQuery();

// Customer ID is an IDENTITY value from the database.

this.parsedCustomerID = (int)sqlCommand.Parameters["@CustomerID"].Value;

// Put the Customer ID value into the read-only text box.

this.txtCustomerID.Text = Convert.ToString(parsedCustomerID);
}
catch
{
MessageBox.Show("Customer ID was not returned. Account could not be created.");
}
finally
{
connection.Close();
}
}
}
}
}

/// <summary>
/// Calls the Sales.uspPlaceNewOrder stored procedure to place an order.
/// </summary>
private void btnPlaceOrder_Click(object sender, EventArgs e)
{
// Ensure the required input is present.
if (IsOrderDataValid())
{
// Create the connection.
using (SqlConnection connection = new SqlConnection(Properties.Settings.Default.connString))
{
// Create SqlCommand and identify it as a stored procedure.
using (SqlCommand sqlCommand = new SqlCommand("Sales.uspPlaceNewOrder", connection))
{
sqlCommand.CommandType = CommandType.StoredProcedure;

// Add the @CustomerID input parameter, which was obtained from uspNewCustomer.
sqlCommand.Parameters.Add(new SqlParameter("@CustomerID", SqlDbType.Int));
sqlCommand.Parameters["@CustomerID"].Value = this.parsedCustomerID;

// Add the @OrderDate input parameter.

sqlCommand.Parameters.Add(new SqlParameter("@OrderDate", SqlDbType.DateTime, 8));
sqlCommand.Parameters["@OrderDate"].Value = dtpOrderDate.Value;

// Add the @Amount order amount input parameter.

sqlCommand.Parameters.Add(new SqlParameter("@Amount", SqlDbType.Int));
sqlCommand.Parameters["@Amount"].Value = numOrderAmount.Value;

// Add the @Status order status input parameter.

// For a new order, the status is always O (open).
sqlCommand.Parameters.Add(new SqlParameter("@Status", SqlDbType.Char, 1));
sqlCommand.Parameters["@Status"].Value = "O";

// Add the return value for the stored procedure, which is the order ID.
// Add the return value for the stored procedure, which is the order ID.
sqlCommand.Parameters.Add(new SqlParameter("@RC", SqlDbType.Int));
sqlCommand.Parameters["@RC"].Direction = ParameterDirection.ReturnValue;

try
{
//Open connection.
connection.Open();

// Run the stored procedure.

sqlCommand.ExecuteNonQuery();

// Display the order number.

this.orderID = (int)sqlCommand.Parameters["@RC"].Value;
MessageBox.Show("Order number " + this.orderID + " has been submitted.");
}
catch
{
MessageBox.Show("Order could not be placed.");
}
finally
{
connection.Close();
}
}
}
}
}

/// <summary>
/// Clears the form data so another new account can be created.
/// </summary>
private void btnAddAnotherAccount_Click(object sender, EventArgs e)
{
this.ClearForm();
}

/// <summary>
/// Closes the form/dialog box.
/// </summary>
private void btnAddFinish_Click(object sender, EventArgs e)
{
this.Close();
}

''' <summary>
''' Creates a new account by executing the Sales.uspNewCustomer
''' stored procedure on the database.
''' </summary>
Private Sub btnCreateAccount_Click(sender As Object, e As EventArgs) Handles btnCreateAccount.Click

' Ensure a customer name has been entered.

If IsCustomerNameValid Then

' Create the SqlConnection object.

Using connection As New SqlConnection(My.Settings.connString)

' Create a SqlCommand, and identify the command type as a stored procedure.
Using sqlCommand As New SqlCommand("Sales.uspNewCustomer", connection)
sqlCommand.CommandType = CommandType.StoredProcedure

' Add the customer name input parameter for the stored procedure.
sqlCommand.Parameters.Add(New SqlParameter("@CustomerName", SqlDbType.NVarChar, 40))
sqlCommand.Parameters("@CustomerName").Value = txtCustomerName.Text

' Add the customer ID output parameter.

sqlCommand.Parameters.Add(New SqlParameter("@CustomerID", SqlDbType.Int))
sqlCommand.Parameters("@CustomerID").Direction = ParameterDirection.Output
sqlCommand.Parameters("@CustomerID").Direction = ParameterDirection.Output

Try
' Open the connection.
connection.Open()

' Run the stored procedure.

sqlCommand.ExecuteNonQuery()

' Convert the Customer ID value to an Integer.

Me.parsedCustomerID = CInt(sqlCommand.Parameters("@CustomerID").Value)

' Insert the customer ID into the corresponding text box.

Me.txtCustomerID.Text = Convert.ToString(parsedCustomerID)
Catch
MessageBox.Show("Customer ID was not returned. Account could not be created.")
Finally
' Close the connection.
connection.Close()
End Try
End Using
End Using
End If
End Sub

''' <summary>
''' Places the order by executing the Sales.uspPlaceNewOrder
''' stored procedure on the database.
''' </summary>
Private Sub btnPlaceOrder_Click(sender As Object, e As EventArgs) Handles btnPlaceOrder.Click

If IsOrderDataValid() Then

' Create the connection.

Using connection As New SqlConnection(My.Settings.connString)

' Create SqlCommand and identify it as a stored procedure.

Using sqlCommand As New SqlCommand("Sales.uspPlaceNewOrder", connection)
sqlCommand.CommandType = CommandType.StoredProcedure

' Add the @CustomerID parameter, which was an output parameter from uspNewCustomer.
sqlCommand.Parameters.Add(New SqlParameter("@CustomerID", SqlDbType.Int))
sqlCommand.Parameters("@CustomerID").Value = Me.parsedCustomerID

' Add the @OrderDate parameter.

sqlCommand.Parameters.Add(New SqlParameter("@OrderDate", SqlDbType.DateTime, 8))
sqlCommand.Parameters("@OrderDate").Value = dtpOrderDate.Value

' Add the @Amount parameter.

sqlCommand.Parameters.Add(New SqlParameter("@Amount", SqlDbType.Int))
sqlCommand.Parameters("@Amount").Value = numOrderAmount.Value

' Add the @Status parameter. For a new order, the status is always O (open).
sqlCommand.Parameters.Add(New SqlParameter("@Status", SqlDbType.[Char], 1))
sqlCommand.Parameters("@Status").Value = "O"

' Add a return value parameter for the stored procedure, which is the orderID.
sqlCommand.Parameters.Add(New SqlParameter("@RC", SqlDbType.Int))
sqlCommand.Parameters("@RC").Direction = ParameterDirection.ReturnValue

Try
' Open connection.
connection.Open()

' Run the stored procedure.

sqlCommand.ExecuteNonQuery()

' Display the order number.

Me.orderID = CInt(sqlCommand.Parameters("@RC").Value)
MessageBox.Show("Order number " & (Me.orderID).ToString & " has been submitted.")
MessageBox.Show("Order number " & (Me.orderID).ToString & " has been submitted.")
Catch
' A simple catch.
MessageBox.Show("Order could not be placed.")
Finally
' Always close a connection after you finish using it,
' so that it can be released to the connection pool.
connection.Close()
End Try
End Using
End Using
End If
End Sub

''' <summary>
''' Resets the form for another new account.
''' </summary>
Private Sub btnAddAnotherAccount_Click(sender As Object, e As EventArgs) Handles
btnAddAnotherAccount.Click
Me.ClearForm()
End Sub

''' <summary>
''' Closes the NewCustomer form and returns focus to the Navigation form.
''' </summary>
Private Sub btnAddFinish_Click(sender As Object, e As EventArgs) Handles btnAddFinish.Click
Me.Close()
End Sub

Formulário FillOrCancel
O formulário FillOrCancel executa uma consulta para retornar um pedido quando você inserir uma ID do pedido
e, em seguida, clicar no botão Encontrar Pedido. A linha retornada aparece em uma grade de dados somente
leitura. Você poderá marcar o pedido como cancelado (X) se selecionar o botão Cancelar Pedido ou marcar o
pedido como preenchido (F) se selecionar o botão Ordem de Preenchimento. Se você selecionar o botão
Encontrar Pedido novamente, a linha atualizada será exibida.
Criar manipuladores de eventos gerados automaticamente
Criar manipuladores de eventos click vazios para os quatro botões no formulário FillOrCancel clicando duas
vezes nos botões. Clicar duas vezes nos botões também adiciona código gerado automaticamente no arquivo
de código do Designer que permite que um clique de botão ative um evento.
Adicionar código para a lógica do formulário FillOrCancel
Para concluir a lógica do formulário FillOrCancel, siga estas etapas.
1. Traga os dois namespaces a seguir para o escopo para que você não tenha que qualificar totalmente os
nomes de seus membros.

using System.Data.SqlClient;
using System.Text.RegularExpressions;

Imports System.Data.SqlClient
Imports System.Text.RegularExpressions

2. Adicione uma variável e um método auxiliar à classe , conforme mostrado no código a seguir.
// Storage for the order ID value.
private int parsedOrderID;

/// <summary>
/// Verifies that an order ID is present and contains valid characters.
/// </summary>
private bool IsOrderIDValid()
{
// Check for input in the Order ID text box.
if (txtOrderID.Text == "")
{
MessageBox.Show("Please specify the Order ID.");
return false;
}

// Check for characters other than integers.

else if (Regex.IsMatch(txtOrderID.Text, @"^\D*$"))
{
// Show message and clear input.
MessageBox.Show("Customer ID must contain only numbers.");
txtOrderID.Clear();
return false;
}
else
{
// Convert the text in the text box to an integer to send to the database.
parsedOrderID = Int32.Parse(txtOrderID.Text);
return true;
}
}

' Storage for OrderID.

Private parsedOrderID As Integer

''' <summary>
''' Verifies that OrderID is valid.
''' </summary>
Private Function IsOrderIDValid() As Boolean

' Check for input in the Order ID text box.

If txtOrderID.Text = "" Then
MessageBox.Show("Please specify the Order ID.")
Return False

' Check for characters other than integers.

ElseIf Regex.IsMatch(txtOrderID.Text, "^\D*$") Then
' Show message and clear input.
MessageBox.Show("Please specify integers only.")
txtOrderID.Clear()
Return False
Else
' Convert the text in the text box to an integer to send to the database.
parsedOrderID = Int32.Parse(txtOrderID.Text)
Return True
End If
End Function

3. Conclua os corpos do método para os manipuladores de eventos de clique de quatro botões, conforme
mostrado no código a seguir.

/// <summary>
/// Executes a t-SQL SELECT statement to obtain order data for a specified
/// order ID, then displays it in the DataGridView on the form.
/// </summary>
private void btnFindByOrderID_Click(object sender, EventArgs e)
{
if (IsOrderIDValid())
{
using (SqlConnection connection = new SqlConnection(Properties.Settings.Default.connString))
{
// Define a t-SQL query string that has a parameter for orderID.
const string sql = "SELECT * FROM Sales.Orders WHERE orderID = @orderID";

// Create a SqlCommand object.

using (SqlCommand sqlCommand = new SqlCommand(sql, connection))
{
// Define the @orderID parameter and set its value.
sqlCommand.Parameters.Add(new SqlParameter("@orderID", SqlDbType.Int));
sqlCommand.Parameters["@orderID"].Value = parsedOrderID;

try
{
connection.Open();

// Run the query by calling ExecuteReader().

using (SqlDataReader dataReader = sqlCommand.ExecuteReader())
{
// Create a data table to hold the retrieved data.
DataTable dataTable = new DataTable();

// Load the data from SqlDataReader into the data table.

dataTable.Load(dataReader);

// Display the data from the data table in the data grid view.
this.dgvCustomerOrders.DataSource = dataTable;

// Close the SqlDataReader.

dataReader.Close();
}
}
catch
{
MessageBox.Show("The requested order could not be loaded into the form.");
}
finally
{
// Close the connection.
connection.Close();
}
}
}
}
}

/// <summary>
/// Cancels an order by calling the Sales.uspCancelOrder
/// stored procedure on the database.
/// </summary>
private void btnCancelOrder_Click(object sender, EventArgs e)
{
if (IsOrderIDValid())
{
// Create the connection.
using (SqlConnection connection = new SqlConnection(Properties.Settings.Default.connString))
{
// Create the SqlCommand object and identify it as a stored procedure.
using (SqlCommand sqlCommand = new SqlCommand("Sales.uspCancelOrder", connection))
{
sqlCommand.CommandType = CommandType.StoredProcedure;

// Add the order ID input parameter for the stored procedure.

sqlCommand.Parameters.Add(new SqlParameter("@orderID", SqlDbType.Int));
sqlCommand.Parameters["@orderID"].Value = parsedOrderID;
sqlCommand.Parameters["@orderID"].Value = parsedOrderID;

try
{
// Open the connection.
connection.Open();

// Run the command to execute the stored procedure.

sqlCommand.ExecuteNonQuery();
}
catch
{
MessageBox.Show("The cancel operation was not completed.");
}
finally
{
// Close connection.
connection.Close();
}
}
}
}
}

/// <summary>
/// Fills an order by calling the Sales.uspFillOrder stored
/// procedure on the database.
/// </summary>
private void btnFillOrder_Click(object sender, EventArgs e)
{
if (IsOrderIDValid())
{
// Create the connection.
using (SqlConnection connection = new SqlConnection(Properties.Settings.Default.connString))
{
// Create command and identify it as a stored procedure.
using (SqlCommand sqlCommand = new SqlCommand("Sales.uspFillOrder", connection))
{
sqlCommand.CommandType = CommandType.StoredProcedure;

// Add the order ID input parameter for the stored procedure.

sqlCommand.Parameters.Add(new SqlParameter("@orderID", SqlDbType.Int));
sqlCommand.Parameters["@orderID"].Value = parsedOrderID;

// Add the filled date input parameter for the stored procedure.
sqlCommand.Parameters.Add(new SqlParameter("@FilledDate", SqlDbType.DateTime, 8));
sqlCommand.Parameters["@FilledDate"].Value = dtpFillDate.Value;

try
{
connection.Open();

// Execute the stored procedure.

sqlCommand.ExecuteNonQuery();
}
catch
{
MessageBox.Show("The fill operation was not completed.");
}
finally
{
// Close the connection.
connection.Close();
}
}
}
}
}

/// <summary>
/// <summary>
/// Closes the form.
/// </summary>
private void btnFinishUpdates_Click(object sender, EventArgs e)
{
this.Close();
}

''' <summary>
''' Executes a t-SQL SELECT query on the database to
''' obtain order data for a specified order ID.
''' </summary>
Private Sub btnFindByOrderID_Click(sender As Object, e As EventArgs) Handles btnFindByOrderID.Click

' Prepare the connection and the command.

If IsOrderIDValid() Then

' Create the connection.

Using connection As New SqlConnection(My.Settings.connString)

' Define the query string that has a parameter for orderID.
Const sql As String = "select * from Sales.Orders where orderID = @orderID"

' Create a SqlCommand object.

Using sqlCommand As New SqlCommand(sql, connection)

' Define the @orderID parameter and its value.

sqlCommand.Parameters.Add(New SqlParameter("@orderID", SqlDbType.Int))
sqlCommand.Parameters("@orderID").Value = parsedOrderID

Try
' Open connection.
connection.Open()

' Execute the query.

Dim dataReader As SqlDataReader = sqlCommand.ExecuteReader()

' Create a data table to hold the retrieved data.

Dim dataTable As New DataTable()

' Load the data from SqlDataReader into the data table.
dataTable.Load(dataReader)

' Display the data from the data table in the data grid view.
Me.dgvCustomerOrders.DataSource = dataTable

' Close the SqlDataReader.

dataReader.Close()
Catch
MessageBox.Show("The requested order could not be loaded into the form.")
Finally
' Close the connection.
connection.Close()
End Try
End Using
End Using
End If
End Sub

''' <summary>
''' Fills an order by running the Sales.uspFillOrder stored procedure on the database.
''' </summary>
Private Sub btnFillOrder_Click(sender As Object, e As EventArgs) Handles btnFillOrder.Click

' Set up and run stored procedure only if OrderID is valid.

If IsOrderIDValid() Then

' Create the connection.

' Create the connection.
Using connection As New SqlConnection(My.Settings.connString)

' Create command and identify it as a stored procedure.

Using sqlCommand As New SqlCommand("Sales.uspFillOrder", connection)

sqlCommand.CommandType = CommandType.StoredProcedure

' Add input parameter for the stored procedure.

sqlCommand.Parameters.Add(New SqlParameter("@orderID", SqlDbType.Int))
sqlCommand.Parameters("@orderID").Value = parsedOrderID

' Add second input parameter.

sqlCommand.Parameters.Add(New SqlParameter("@FilledDate", SqlDbType.DateTime, 8))
sqlCommand.Parameters("@FilledDate").Value = dtpFillDate.Value

Try
' Open the connection.
connection.Open()

' Run the SqlCommand.

sqlCommand.ExecuteNonQuery()
Catch
' A simple catch.
MessageBox.Show("The fill operation was not completed.")
Finally
' Close the connection.
connection.Close()
End Try
End Using
End Using
End If
End Sub

''' <summary>
''' Cancels an order by running the Sales.uspCancelOrder stored procedure on the database.
''' </summary>
Private Sub btnCancelOrder_Click(sender As Object, e As EventArgs) Handles btnCancelOrder.Click

' Set up and run the stored procedure only if OrderID is ready.
If IsOrderIDValid() Then

' Create the connection.

Using connection As New SqlConnection(My.Settings.connString)

' Create the command and identify it as a stored procedure.

Using sqlCommand As New SqlCommand("Sales.uspCancelOrder", connection)
sqlCommand.CommandType = CommandType.StoredProcedure

' Add input parameter for the stored procedure.

sqlCommand.Parameters.Add(New SqlParameter("@orderID", SqlDbType.Int))
sqlCommand.Parameters("@orderID").Value = parsedOrderID

Try
' Open the connection.
connection.Open()

' Run the SqlCommand.

sqlCommand.ExecuteNonQuery()
Catch
' A simple catch.
MessageBox.Show("The cancel operation was not completed.")
Finally
' Close connection.
connection.Close()
End Try
End Using
End Using
End If
End Sub
End Sub

''' <summary>
''' Closes the form and returns focus to the Navigation form.
''' </summary>
Private Sub btnFinishUpdates_Click(sender As Object, e As EventArgs) Handles btnFinishUpdates.Click
Me.Close()
End Sub

Testar o aplicativo
Selecione a tecla F5 para criar e testar seu aplicativo depois de codificar cada manipulador de eventos Click e,
em seguida, depois de concluir a codificação.

Confira também
Ferramentas de dados do Visual Studio para .NET
Criar um aplicativo de dados simples com o WPF e
o Entity Framework 6
20/11/2021 • 19 minutes to read

Este passo a passo mostra como criar um aplicativo básico de "formulários sobre dados" no Visual Studio. O
aplicativo usa SQL Server LocalDB, o banco de dados Northwind, Entity Framework 6 (não Entity Framework
Core) e Windows Presentation Foundation para .NET Framework (não o .NET Core). Ele mostra como fazer a
associação de dados básica com uma exibição mestre-detalhes e também tem um Navegador de Associação
personalizado com botões para Mover Próximo, Mover Anterior, Mover para o início, Mover para o fim,
Atualizar e Excluir .
Este artigo se concentra no uso de ferramentas de dados Visual Studio e não tenta explicar as tecnologias
subjacentes em nenhuma profundidade. Ele pressuporá que você tenha uma familiaridade básica com XAML,
Entity Framework e SQL. Este exemplo também não demonstra a arquitetura MVVM (Model-View-ViewModel),
que é padrão para aplicativos WPF. No entanto, você pode copiar esse código para seu próprio aplicativo MVVM
com poucas modificações.

Instalar e conectar-se ao Northwind

Este exemplo usa SQL Server Express LocalDB e o banco de dados de exemplo Northwind. Se o ADO.NET de
dados para esse produto for compatível com Entity Framework, ele também deverá funcionar com outros SQL
de banco de dados.
1. Se você não tiver um SQL Server Express LocalDB, instale-o na página de download SQL Server Express
oupor meio do Instalador do Visual Studio . No Instalador do Visual Studio , você pode instalar o
SQL Server Express LocalDB como parte da carga de trabalho do Desenvolvimento para desktop
com .NET ou como um componente individual.
2. Instale o banco de dados de exemplo Northwind seguindo estas etapas:
a. No Visual Studio, abra a SQL Ser ver Pesquisador de Objetos janela. (SQL Ser ver
Pesquisador de Objetos é instalado como parte da carga de trabalho armazenamento e
processamento de dados no Instalador do Visual Studio .) Expanda o SQL Ser ver nó. Clique
com o botão direito do mouse na LocalDB e selecione Nova Consulta .
Uma janela do editor de consultas é aberta.
b. Copie o script Northwind Transact-SQL para a área de transferência. Esse script T-SQL cria o banco
de dados Northwind do zero e o popula com dados.
c. Colar o script T-SQL no editor de consultas e, em seguida, escolha o botão Executar.
Após um curto período, a consulta termina a execução e o banco de dados Northwind é criado.
3. Adicione novas conexões para Northwind.

Configurar o projeto
1. No Visual Studio, crie um novo projeto de aplicativo WPF em C#.
2. Adicione o NuGet do Entity Framework 6. No Gerenciador de Soluções , selecione o nó do projeto. No
menu principal, escolha Project > Gerenciar NuGet Pacotes .
3. No NuGet Gerenciador de Pacotes , clique no link Procurar. Entity Framework é provavelmente o
pacote principal na lista. Clique em Instalar no painel direito e siga os prompts. A janela Saída informa
quando a instalação é concluída.

4. Agora você pode usar Visual Studio para criar um modelo com base no banco de dados Northwind.

Criar o modelo
1. Clique com o botão direito do mouse no nó do projeto Gerenciador de Soluções escolha Adicionar
> Novo Item . No painel esquerdo, no nó C#, escolha Dados e, no painel central, escolha ADO.NET
Modelo de Dados de Entidade .

2. Chame o modelo Northwind_model e escolha OK. O Assistente de Modelo de Dados de Entidade é

aberto. Escolha Designer do EF no banco de dados e clique em Próximo.
3. Na próxima tela, insira ou escolha sua conexão LocalDB Northwind (por exemplo,
(localdb)\MSSQLLocalDB), especifique o banco de dados Northwind e clique em Próximo.
4. Na próxima página do assistente, escolha quais tabelas, procedimentos armazenados e outros objetos de
banco de dados devem ser incluídos Entity Framework modelo. Expanda o nó dbo no modo de exibição
de árvore e escolha Clientes, Pedidos e Detalhes do Pedido . Deixe os padrões marcados e clique em
Concluir .

5. O assistente gera as classes C# que representam o Entity Framework modelo. As classes são classes C#
simples antigas e são o que podemos fazer para a interface do usuário do WPF. O arquivo .edmx descreve
as relações e outros metadados que associam as classes a objetos no banco de dados. Os arquivos .tt são
modelos T4 que geram o código que opera no modelo e salva as alterações no banco de dados. Você
pode ver todos esses arquivos Gerenciador de Soluções no nó Northwind_model:

A superfície do designer para o arquivo .edmx permite que você modifique algumas propriedades e
relações no modelo. Não vamos usar o designer neste passo a passo.
6. Os arquivos .tt são de uso geral e você precisa ajustar um deles para trabalhar com a relação de dados do
WPF, o que requer ObservableCollections. No Gerenciador de Soluções , expanda o nó
Northwind_model até encontrar Northwind_model.tt. (Certifique-se de que você não está no . Context.tt,
que está diretamente abaixo do arquivo .edmx.)
Substitua as duas ocorrências de ICollection por ObservableCollection<T> .
Substitua a primeira ocorrência de HashSet<T> por cerca da linha ObservableCollection<T> 51.
Não substitua a segunda ocorrência de HashSet.
Substitua a única ocorrência de System.Collections.Generic (em torno da linha 431) por
System.Collections.ObjectModel .
7. Pressione Ctrl + Shift + B para criar o projeto. Quando o build for final, as classes de modelo serão
visíveis para o assistente de fontes de dados.
Agora você está pronto para conectar esse modelo à página XAML para que possa exibir, navegar e modificar os
dados.

Abindar o modelo à página XAML

É possível escrever seu próprio código de abindagem de dados, mas é muito mais fácil Visual Studio fazer isso
para você.
1. No menu principal, escolha Adicionar Project nova fonte de > dados para abrir o Assistente de
Configuração da Fonte de Dados . Escolha Objeto porque você está se vinculando às classes de
modelo, não ao banco de dados:

2. Expanda o nó do projeto e selecione Cliente . (As fontes para pedidos são geradas automaticamente da
propriedade de navegação Orders no Cliente.)

3. Clique em Concluir .
4. Navegue até MainWindow.xaml na Exibição de Código. Estamos mantendo o XAML simples para os fins
deste exemplo. Altere o título de MainWindow para algo mais descritivo e aumente sua Altura e Largura
para 600 x 800 por enquanto. Você sempre pode alterá-lo mais tarde. Agora, adicione essas três
definições de linha à grade principal, uma linha para os botões de navegação, uma para os detalhes do
cliente e outra para a grade que mostra seus pedidos:

<Grid.RowDefinitions>
<RowDefinition Height="auto"/>
<RowDefinition Height="auto"/>
<RowDefinition Height="*"/>
</Grid.RowDefinitions>

5. Agora, abra MainWindow.xaml para que você o esteja exibindo no designer. Isso faz com que a janela
Fontes de Dados apareça como uma opção na margem Visual Studio janela ao lado da Caixa de
Ferramentas . Clique na guia para abrir a janela ou pressione Shift Alt D ou escolha Exibir + + Outras >
Fontes Windows > Dados . Vamos exibir cada propriedade na classe Customers em sua própria caixa
de texto individual. Primeiro, clique na seta na caixa de combinação Clientes e escolha Detalhes. Em
seguida, arraste o nó para a parte intermediária da superfície de design para que o designer saiba que
você deseja que ele vá para a linha intermediária. Se você o perder, poderá especificar a linha
manualmente posteriormente no XAML. Por padrão, os controles são colocados verticalmente em um
elemento de grade, mas, neste ponto, você pode organizá-los como quiser no formulário. Por exemplo,
pode fazer sentido colocar a caixa de texto Nome na parte superior, acima do endereço. O aplicativo de
exemplo para este artigo reordena os campos e os reorganiza em duas colunas.

Na exibição de código, agora você pode ver um novo elemento na Grid linha 1 (a linha intermediária)
da Grade pai. A Grade pai tem DataContext um atributo que se refere a um CollectionViewSource que foi
adicionado ao elemento Windows.Resources . Dado esse contexto de dados, quando a primeira caixa de
texto é vinculada a Address , esse nome é mapeado para a propriedade no objeto atual no Address
Customer CollectionViewSource.

<Grid DataContext="{StaticResource customerViewSource}">

6. Quando um cliente estiver visível na metade superior da janela, você deseja ver seus pedidos na metade
inferior. Você mostra os pedidos em um único controle de exibição de grade. Para que a vinculação de
dados mestre/detalhes funcione conforme o esperado, é importante que você a vincular à propriedade
Orders na classe Customers, não ao nó Orders separado. Arraste a propriedade Orders da classe
Customers para a metade inferior do formulário, para que o designer a coloque na linha 2:
7. Visual Studio gerou todo o código de associação que conecta os controles de interface do usuário a
eventos no modelo. Tudo o que você precisa fazer, para ver alguns dados, é escrever um código para
popular o modelo. Primeiro, navegue até MainWindow.xaml.cs e adicione um membro de dados à classe
MainWindow para o contexto de dados. Esse objeto, que foi gerado para você, atua como um controle
que rastreia alterações e eventos no modelo. Você também adicionará membros de dados
CollectionViewSource para clientes e pedidos e a lógica de inicialização do construtor associado. A parte
superior da classe deve ter esta aparência:

public partial class MainWindow : Window

{
NorthwindEntities context = new NorthwindEntities();
CollectionViewSource custViewSource;
CollectionViewSource ordViewSource;

public MainWindow()
{
InitializeComponent();
custViewSource = ((CollectionViewSource)(FindResource("customerViewSource")));
ordViewSource = ((CollectionViewSource)(FindResource("customerOrdersViewSource")));
DataContext = this;
}

Adicione uma using diretiva para System.Data.Entity para colocar o método de extensão Load no
escopo:

using System.Data.Entity;

Agora, role para baixo e encontre o Window_Loaded manipulador de eventos. Observe que Visual Studio
adicionou um objeto CollectionViewSource. Isso representa o objeto NorthwindEntities que você
selecionou quando criou o modelo. Você já adicionou isso, portanto, não precisa dele aqui. Vamos
substituir o código em para Window_Loaded que o método agora seja assim:
private void Window_Loaded(object sender, RoutedEventArgs e)
{
// Load is an extension method on IQueryable,
// defined in the System.Data.Entity namespace.
// This method enumerates the results of the query,
// similar to ToList but without creating a list.
// When used with Linq to Entities, this method
// creates entity objects and adds them to the context.
context.Customers.Load();

// After the data is loaded, call the DbSet<T>.Local property

// to use the DbSet<T> as a binding source.
custViewSource.Source = context.Customers.Local;
}

8. Pressione F5 . Você deverá ver os detalhes do primeiro cliente que foi recuperado no
CollectionViewSource. Você também deve ver seus pedidos na grade de dados. A formatação não é
ótima, portanto, vamos corrigi-la. Você também pode criar uma maneira de exibir os outros registros e
fazer operações CRUD básicas.

Ajustar o design da página e adicionar grades para novos clientes e

pedidos
A organização padrão produzida por Visual Studio não é ideal para seu aplicativo, portanto, forneceremos o
XAML final aqui para copiar em seu código. Você também precisa de alguns "formulários" (que são, na verdade,
Grades) para permitir que o usuário adicione um novo cliente ou pedido. Para poder adicionar um novo cliente
e um pedido, você precisa de um conjunto separado de caixas de texto que não são vinculadas a dados ao
CollectionViewSource . Você controlará qual grade o usuário vê a qualquer momento definindo a propriedade
Visible nos métodos do manipulador. Por fim, você adiciona um botão Excluir a cada linha na grade Pedidos para
permitir que o usuário exclua um pedido individual.
Primeiro, adicione esses estilos ao Windows.Resources elemento em MainWindow.xaml:

<Style x:Key="Label" TargetType="{x:Type Label}" BasedOn="{x:Null}">

Em seguida, substitua toda a Grade externa por esta marcação:

Adicionar botões para navegar, adicionar, atualizar e excluir

Nos Windows Forms, você obterá um objeto BindingNavigator com botões para navegar pelas linhas em um
banco de dados e fazer operações CRUD básicas. O WPF não fornece um BindingNavigator, mas é fácil criar um.
Faça isso com botões dentro de um StackPanel horizontal e associe os botões aos Comandos associados aos
métodos no code-behind.
Há quatro partes para a lógica de comando: (1) os comandos, (2) as vinculações, (3) os botões e (4) os
manipuladores de comando no code-behind.
Adicionar comandos, vinculações e botões em XAML
1. Primeiro, adicione os comandos no arquivo MainWindow.xaml dentro do Windows.Resources elemento :

<RoutedUICommand x:Key="FirstCommand" Text="First"/>

2. Um CommandBinding RoutedUICommand mapeia um evento para um método no code-behind. Adicione

este CommandBindings elemento após a marca de Windows.Resources fechamento:

<Window.CommandBindings>
<CommandBinding Command="{StaticResource FirstCommand}" Executed="FirstCommandHandler"/>
<CommandBinding Command="{StaticResource LastCommand}" Executed="LastCommandHandler"/>
<CommandBinding Command="{StaticResource NextCommand}" Executed="NextCommandHandler"/>
<CommandBinding Command="{StaticResource PreviousCommand}" Executed="PreviousCommandHandler"/>
<CommandBinding Command="{StaticResource DeleteCustomerCommand}"
Executed="DeleteCustomerCommandHandler"/>
<CommandBinding Command="{StaticResource DeleteOrderCommand}"
Executed="DeleteOrderCommandHandler"/>
<CommandBinding Command="{StaticResource UpdateCommand}" Executed="UpdateCommandHandler"/>
<CommandBinding Command="{StaticResource AddCommand}" Executed="AddCommandHandler"/>
<CommandBinding Command="{StaticResource CancelCommand}" Executed="CancelCommandHandler"/>
</Window.CommandBindings>
3. Agora, adicione o StackPanel com os botões de navegação, adicionar, excluir e atualizar. Primeiro,
adicione esse estilo a Windows.Resources :

<Style x:Key="NavButton" TargetType="{x:Type Button}" BasedOn="{x:Null}">

Em segundo lugar, colar esse código logo após o para o elemento externo, na RowDefinitions parte
superior da página Grid XAML:

<StackPanel Orientation="Horizontal" Margin="2,2,2,0" Height="36" VerticalAlignment="Top"

Background="Gainsboro" DataContext="{StaticResource customerViewSource}"
d:LayoutOverrides="LeftMargin, RightMargin, TopMargin, BottomMargin">
<Button Name="btnFirst" Content="|◄" Command="{StaticResource FirstCommand}" Style="
{StaticResource NavButton}"/>
<Button Name="btnPrev" Content="◄" Command="{StaticResource PreviousCommand}" Style="
{StaticResource NavButton}"/>
<Button Name="btnNext" Content="►" Command="{StaticResource NextCommand}" Style="{StaticResource
NavButton}"/>
<Button Name="btnLast" Content="►|" Command="{StaticResource LastCommand}" Style="{StaticResource
NavButton}"/>
<Button Name="btnDelete" Content="Delete Customer" Command="{StaticResource
DeleteCustomerCommand}" FontSize="11" Width="120" Style="{StaticResource NavButton}"/>
<Button Name="btnAdd" Content="New Customer" Command="{StaticResource AddCommand}" FontSize="11"
Width="80" Style="{StaticResource NavButton}"/>
<Button Content="New Order" Name="btnNewOrder" FontSize="11" Width="80" Style="{StaticResource
NavButton}" Click="NewOrder_click"/>
<Button Name="btnUpdate" Content="Commit" Command="{StaticResource UpdateCommand}" FontSize="11"
Width="80" Style="{StaticResource NavButton}"/>
<Button Content="Cancel" Name="btnCancel" Command="{StaticResource CancelCommand}" FontSize="11"
Width="80" Style="{StaticResource NavButton}"/>
</StackPanel>

Adicionar manipuladores de comando à classe MainWindow

O code-behind é mínimo, exceto pelos métodos add e delete. A navegação é executada chamando métodos na
propriedade View do CollectionViewSource. O DeleteOrderCommandHandler mostra como executar uma exclusão
em cascata em um pedido. Primeiro, precisamos excluir os Order_Details associados a ele. O adiciona um novo
cliente ou pedido à coleção ou apenas atualiza um cliente ou pedido existente com as alterações feitas pelo
usuário nas UpdateCommandHandler caixas de texto.
Adicione esses métodos de manipulador à classe MainWindow em MainWindow.xaml.cs. Se a tabela
CollectionViewSource para clientes tiver um nome diferente, você precisará ajustar o nome em cada um desses
métodos:

private void LastCommandHandler(object sender, ExecutedRoutedEventArgs e)

{
custViewSource.View.MoveCurrentToLast();
}

private void PreviousCommandHandler(object sender, ExecutedRoutedEventArgs e)

{
custViewSource.View.MoveCurrentToPrevious();
}

private void NextCommandHandler(object sender, ExecutedRoutedEventArgs e)

{
custViewSource.View.MoveCurrentToNext();
custViewSource.View.MoveCurrentToNext();
}

private void FirstCommandHandler(object sender, ExecutedRoutedEventArgs e)

{
custViewSource.View.MoveCurrentToFirst();
}

private void DeleteCustomerCommandHandler(object sender, ExecutedRoutedEventArgs e)

{
// If existing window is visible, delete the customer and all their orders.
// In a real application, you should add warnings and allow the user to cancel the operation.
var cur = custViewSource.View.CurrentItem as Customer;

var cust = (from c in context.Customers

where c.CustomerID == cur.CustomerID
select c).FirstOrDefault();

if (cust != null)
{
foreach (var ord in cust.Orders.ToList())
{
Delete_Order(ord);
}
context.Customers.Remove(cust);
}
context.SaveChanges();
custViewSource.View.Refresh();
}

// Commit changes from the new customer form, the new order form,
// or edits made to the existing customer form.
private void UpdateCommandHandler(object sender, ExecutedRoutedEventArgs e)
{
if (newCustomerGrid.IsVisible)
{
// Create a new object because the old one
// is being tracked by EF now.
Customer newCustomer = new Customer
{
Address = add_addressTextBox.Text,
City = add_cityTextBox.Text,
CompanyName = add_companyNameTextBox.Text,
ContactName = add_contactNameTextBox.Text,
ContactTitle = add_contactTitleTextBox.Text,
Country = add_countryTextBox.Text,
CustomerID = add_customerIDTextBox.Text,
Fax = add_faxTextBox.Text,
Phone = add_phoneTextBox.Text,
PostalCode = add_postalCodeTextBox.Text,
Region = add_regionTextBox.Text
};

// Perform very basic validation

if (newCustomer.CustomerID.Length == 5)
{
// Insert the new customer at correct position:
int len = context.Customers.Local.Count();
int pos = len;
for (int i = 0; i < len; ++i)
{
if (String.CompareOrdinal(newCustomer.CustomerID, context.Customers.Local[i].CustomerID) <
0)
{
pos = i;
break;
}
}
context.Customers.Local.Insert(pos, newCustomer);
custViewSource.View.Refresh();
custViewSource.View.Refresh();
custViewSource.View.MoveCurrentTo(newCustomer);
}
else
{
MessageBox.Show("CustomerID must have 5 characters.");
}

newCustomerGrid.Visibility = Visibility.Collapsed;
existingCustomerGrid.Visibility = Visibility.Visible;
}
else if (newOrderGrid.IsVisible)
{
// Order ID is auto-generated so we don't set it here.
// For CustomerID, address, etc we use the values from current customer.
// User can modify these in the datagrid after the order is entered.

Customer currentCustomer = (Customer)custViewSource.View.CurrentItem;

Order newOrder = new Order()

{
OrderDate = add_orderDatePicker.SelectedDate,
RequiredDate = add_requiredDatePicker.SelectedDate,
ShippedDate = add_shippedDatePicker.SelectedDate,
CustomerID = currentCustomer.CustomerID,
ShipAddress = currentCustomer.Address,
ShipCity = currentCustomer.City,
ShipCountry = currentCustomer.Country,
ShipName = currentCustomer.CompanyName,
ShipPostalCode = currentCustomer.PostalCode,
ShipRegion = currentCustomer.Region
};

try
{
newOrder.EmployeeID = Int32.Parse(add_employeeIDTextBox.Text);
}
catch
{
MessageBox.Show("EmployeeID must be a valid integer value.");
return;
}

try
{
// Exercise for the reader if you are using Northwind:
// Add the Northwind Shippers table to the model.

// Acceptable ShipperID values are 1, 2, or 3.

if (add_ShipViaTextBox.Text == "1" || add_ShipViaTextBox.Text == "2"
|| add_ShipViaTextBox.Text == "3")
{
newOrder.ShipVia = Convert.ToInt32(add_ShipViaTextBox.Text);
}
else
{
MessageBox.Show("Shipper ID must be 1, 2, or 3 in Northwind.");
return;
}
}
catch
{
MessageBox.Show("Ship Via must be convertible to int");
return;
}

try
{
newOrder.Freight = Convert.ToDecimal(add_freightTextBox.Text);
}
}
catch
{
MessageBox.Show("Freight must be convertible to decimal.");
return;
}

// Add the order into the EF model

context.Orders.Add(newOrder);
ordViewSource.View.Refresh();
}

// Save the changes, either for a new customer, a new order

// or an edit to an existing customer or order.
context.SaveChanges();
}

// Sets up the form so that user can enter data. Data is later
// saved when user clicks Commit.
private void AddCommandHandler(object sender, ExecutedRoutedEventArgs e)
{
existingCustomerGrid.Visibility = Visibility.Collapsed;
newOrderGrid.Visibility = Visibility.Collapsed;
newCustomerGrid.Visibility = Visibility.Visible;

// Clear all the text boxes before adding a new customer.

foreach (var child in newCustomerGrid.Children)
{
var tb = child as TextBox;
if (tb != null)
{
tb.Text = "";
}
}
}

private void NewOrder_click(object sender, RoutedEventArgs e)

{
var cust = custViewSource.View.CurrentItem as Customer;
if (cust == null)
{
MessageBox.Show("No customer selected.");
return;
}

existingCustomerGrid.Visibility = Visibility.Collapsed;
newCustomerGrid.Visibility = Visibility.Collapsed;
newOrderGrid.UpdateLayout();
newOrderGrid.Visibility = Visibility.Visible;
}

// Cancels any input into the new customer form

private void CancelCommandHandler(object sender, ExecutedRoutedEventArgs e)
{
add_addressTextBox.Text = "";
add_cityTextBox.Text = "";
add_companyNameTextBox.Text = "";
add_contactNameTextBox.Text = "";
add_contactTitleTextBox.Text = "";
add_countryTextBox.Text = "";
add_customerIDTextBox.Text = "";
add_faxTextBox.Text = "";
add_phoneTextBox.Text = "";
add_postalCodeTextBox.Text = "";
add_regionTextBox.Text = "";

existingCustomerGrid.Visibility = Visibility.Visible;
newCustomerGrid.Visibility = Visibility.Collapsed;
newOrderGrid.Visibility = Visibility.Collapsed;
}
}

private void Delete_Order(Order order)

{
// Find the order in the EF model.
var ord = (from o in context.Orders.Local
where o.OrderID == order.OrderID
select o).FirstOrDefault();

// Delete all the order_details that have

// this Order as a foreign key
foreach (var detail in ord.Order_Details.ToList())
{
context.Order_Details.Remove(detail);
}

// Now it's safe to delete the order.

context.Orders.Remove(ord);
context.SaveChanges();

// Update the data grid.

ordViewSource.View.Refresh();
}

private void DeleteOrderCommandHandler(object sender, ExecutedRoutedEventArgs e)

{
// Get the Order in the row in which the Delete button was clicked.
Order obj = e.Parameter as Order;
Delete_Order(obj);
}

Executar o aplicativo
Para iniciar a depuração, pressione F5 . Você deve ver os dados do cliente e do pedido preenchidos na grade, e
os botões de navegação devem funcionar conforme o esperado. Clique em Confirmação para adicionar um
novo cliente ou pedido ao modelo depois de ter inserido os dados. Clique em Cancelar para sair de um novo
cliente ou novo formulário de pedido sem salvar os dados. Você pode fazer edições para clientes e pedidos
existentes diretamente nas caixas de texto, e essas alterações são escritas no modelo automaticamente.

Confira também
Ferramentas de dados do Visual Studio para .NET
Documentação do Entity Framework
Ferramentas de dados do Visual Studio para C++
20/11/2021 • 3 minutes to read

O C++ nativo geralmente pode fornecer o desempenho mais rápido quando você está acessando fontes de
dados. No entanto, as ferramentas de dados para aplicativos C++ no Visual Studio não são tão ricas quanto
para aplicativos .NET. Por exemplo, a janela Fontes de Dados não pode ser usada para arrastar e soltar fontes
de dados em uma superfície de design C++. Se você precisar de uma camada relacional de objeto, precisará
escrever sua própria camada ou usar um produto de terceiros. O mesmo vale para a funcionalidade de
associação de dados, embora os aplicativos que usam a biblioteca do Microsoft Foundation Class possam usar
algumas classes de banco de dados, juntamente com documentos e exibições, para armazenar dados na
memória e exibi-los para o usuário. Para obter mais informações, consulte Acesso a dados Visual C++.
Para se conectar SQL bancos de dados, os aplicativos C++ nativos podem usar os drivers ODBC e OLE DB e o
provedor ADO incluídos no Windows. Eles podem se conectar a qualquer banco de dados que dá suporte a
essas interfaces. O driver ODBC é o padrão. OLE DB é fornecido para compatibilidade com backward. Para obter
mais informações sobre essas tecnologias de dados, consulte Windows Componentes de Acesso a Dados.
Para aproveitar a funcionalidade personalizada no SQL Server 2005 e posterior, use o SQL Server cliente nativo.
O cliente nativo também contém o SQL Server driver ODBC e o provedor SQL Server OLE DB em uma DLL
(biblioteca de vínculo dinâmico) nativa. Esses aplicativos são suportados usando APIs de código nativo (ODBC,
OLE DB e ADO) para Microsoft SQL Server. SQL Server Native Client é instalado com SQL Server Data Tools. O
guia de programação está aqui: SQL Server programação nativa do cliente.

Para se conectar ao localDB por meio de ODBC e SQL Native Client de

um aplicativo C++
1. Instale o SQL Server Data Tools.
2. Se você precisar de um banco SQL banco de dados de exemplo para se conectar, baixe o banco de dados
Northwind e descompixe-o para um novo local.
3. Use SQL Server Management Studio para anexar o arquivo Northwind.mdf desanexado ao localDB.
Quando SQL Server Management Studio, conecte-se a (localdb)\MSSQLLocalDB.

Em seguida, clique com o botão direito do mouse no nó localdb no painel esquerdo e escolha Anexar .
4. Baixe o exemplo de SDK do Windows ODBC e descompanha-o para um novo local. Este exemplo mostra
os comandos ODBC básicos que são usados para se conectar a um banco de dados e emitir consultas e
comandos. Você pode saber mais sobre essas funções no ODBC (Microsoft Open Database Connectivity).
Quando você carregar a solução pela primeira vez (ela está na pasta C++), o Visual Studio oferecerá a
atualização da solução para a versão atual do Visual Studio. Clique em Sim .
5. Para usar o cliente nativo, você precisa do arquivo de header e do arquivo lib. Esses arquivos contêm
funções e definições específicas SQL Server, além das funções ODBC definidas em sql.h. Em Project >
propriedades VC++ > diretórios , adicione o seguinte diretório de inclusão:
%ProgramFiles%\Microsoft SQL Ser ver\110\SDK\Include
E este diretório de biblioteca:
%ProgramFiles%\Microsoft SQL Ser ver\110\SDK\Lib
6. Adicione essas linhas em odbcsql.cpp. O #define impede que OLE DB irrelevantes de serem compiladas.

#define _SQLNCLI_ODBC_
#include <sqlncli.h>

Observe que o exemplo realmente não usa nenhuma das funcionalidades nativas do cliente, portanto, as
etapas anteriores não são necessárias para que ele seja compilado e executado. Mas o projeto agora está
configurado para você usar essa funcionalidade. Para obter mais informações, consulte SQL Server
Native Client programação.
7. Especifique qual driver usar no subsistema ODBC. O exemplo passa o atributo de cadeia de conexão
DRIVER em como um argumento de linha de comando. Na Project > Depuração > de Propriedades ,
adicione este argumento de comando:

DRIVER="SQL Server Native Client 11.0"

8. Pressione F5 para compilar e executar o aplicativo. Você deverá ver uma caixa de diálogo do driver que
solicita que você insira um banco de dados. Insira (localdb)\MSSQLLocalDB e marque Usar Conexão
Confiável . Pressione OK . Você deverá ver um console com mensagens que indicam uma conexão bem-
sucedida. Você também deve ver um prompt de comando em que você pode digitar uma SQL de
comando. A tela a seguir mostra um exemplo de consulta e os resultados:
Confira também
Acessando dados em Visual Studio
Passo a passo: criar LINQ to SQL classes usando a
herança de tabela única (Designer O/R)
20/11/2021 • 4 minutes to read

O LINQ to SQL ferramentas no Visual Studio dá suporte à herança de tabela única, pois normalmente é
implementada em sistemas relacionais. Este passo a passo se expande sobre as etapas genéricas fornecidas no
tópico Como configurar a herança usando o Designer O/R e fornece alguns dados reais para demonstrar o uso
da herança no Designer Relacional de Objetos .
Durante este passo a passo, você executará as seguintes tarefas:
Criar uma tabela de banco de dados e adicione dados a ela.
Criar um aplicativo do Windows Forms.
Adicionar um arquivo do LINQ to SQL a um projeto.
Criar novas classes de entidade.
Configurar as classes de entidade para usar herança.
Consultar a classe herdada.
Exibir os dados em um Windows Form.

Criar uma tabela da qual herdar

Para ver como funciona a herança, crie uma tabela pequena, use-a como uma classe base e crie um objeto
Person Employee que herda dela.

Para criar uma tabela base para demonstrar a herança

1. No Gerenciador de Ser vidores ou Gerenciador de Banco de Dados , clique com o botão direito do
mouse no nó Tabelas e clique em Adicionar Nova Tabela .

NOTE
Você pode usar o banco de dados Northwind ou qualquer outro banco de dados ao qual você possa adicionar
uma tabela.

2. No Designer de Tabela , adicione as seguintes colunas à tabela:

N O M E DA C O L UN A T IP O DE DA DO S P ERM IT IR N ULO S

ID int Falso

Tipo int True

Nome nvarchar(200) Falso

Sobrenome nvarchar(200) Falso

N O M E DA C O L UN A T IP O DE DA DO S P ERM IT IR N ULO S

Gerente int True

3. Defina a coluna de identificação como a chave primária.

4. Salve a tabela e dê a ela o nome de Pessoa .

Adicionar dados à tabela

Para que você possa verificar se a herança está configurada corretamente, a tabela precisa de alguns dados para
cada classe na herança de tabela única.
Para adicionar dados à tabela
1. Abra a tabela no modo de exibição de dados. (Clique com o botão direito do mouse na tabela Pessoa
Gerenciador de Ser vidores ou Gerenciador de Banco de Dados clique em Mostrar Dados da
Tabela .)
2. Copie os seguintes dados na tabela. (Você pode copiá-lo e, em seguida, colar na tabela selecionando a
linha inteira no Painel de Resultados.)

ID T IP O NOME SO B REN O M E GEREN T E

1 1 Anne Wallace NULL

2 1 Carlos Grilo NULL

3 1 Yael Peled NULL

4 2 Gatis Ozolins 1

5 2 Andreas Hauser 1

6 2 Tiffany Phuvasate 1

7 2 Alexey Orekhov 2

8 2 Michał Poliszkiewicz 2

9 2 Tai Yee 2

10 2 Fabricio Noriega 3

11 2 Mindy Mar tin 3

12 2 Ken Kwok 3

Criar um novo projeto

Agora que você criou a tabela, crie um novo projeto demonstrar a configuração de herança.
para criar o novo aplicativo Windows Forms
1. No Visual Studio, no menu Arquivo , selecione Novo > Projeto .
2. expanda o Visual C# ou Visual Basic no painel esquerdo e, em seguida, selecione Windows área de
trabalho .
3. no painel central, selecione o tipo de projeto Windows Forms aplicativo .
4. Nomeie o projeto InheritanceWalkthrough e escolha OK .
O projeto InheritanceWalkthrough é criado e adicionado ao Gerenciador de Soluções .

Adicionar um arquivo de classes do LINQ to SQL ao projeto

Para adicionar um arquivo LINQ to SQL ao projeto
1. No menu Projeto , clique em Adicionar Novo Item .
2. Clique no modelo Classes LINQ to SQL e clique em Adicionar .
O arquivo . dbml é adicionado ao projeto e o o /R Designer é aberto.

Criar a herança usando o Designer Relacional de Objetos

Configure a herança arrastando um objeto Herança da Caixa de Ferramentas para a superfície de design.
Para criar a herança
1. Em Gerenciador de ser vidores ou Gerenciador de banco de dados , navegue até a tabela Person
que você criou anteriormente.
2. Arraste a tabela Person para a superfície de design o /R Designer .
3. Arraste uma segunda tabela Person para o o /R Designer e altere seu nome para Employee .
4. Exclua a propriedade Manager do objeto Pessoa .
5. Exclua as propriedades Type , ID , FirstName e LastName do objeto Employee . (Em outras palavras,
exclua todas as propriedades exceto Gerente .)
6. Na guia Object Relational Designer da Caixa de Ferramentas , crie uma Herança entre os objetos
Pessoa e Funcionário . Para fazer isso, clique no item Herança na Caixa de Ferramentas e solte o
botão do mouse. Em seguida, clique no objeto Employee e no objeto Person no o /R Designer . A seta
na linha de herança aponta para o objeto Person .
7. Clique na linha Herança na superfície de design.
8. Defina a Propriedade Discriminatória como Tipo .
9. Defina a propriedade Valor Discriminatório da Classe Derivada como 2 .
10. Defina a propriedade Valor Discriminatório da Classe Base como 1 .
11. Defina a propriedade Padrão de Herança como Pessoa .
12. Compile o projeto.

Consultar a classe herdada e exibir os dados no formulário

Agora você adiciona um código ao formulário que consulta uma classe específica no modelo de objeto.
Para criar uma consulta LINQ e exibir os resultados no formulário
1. Arraste um controle ListBox para Form1 .
2. Clique duas vezes no formulário para criar um manipulador de eventos Form1_Load .
3. Adicione o seguinte código ao manipulador de eventos do Form1_Load :

Dim dc As New DataClasses1DataContext

Dim results = From emp In dc.Persons _
Where TypeOf emp Is Employee _
Select emp

For Each Emp As Employee In results

ListBox1.Items.Add(Emp.LastName)
Next

NorthwindDataContext dc = new DataClasses1DataContext();

var results = from emp in dc.Persons
where emp is Employee
select emp;

foreach(Employee Emp in results)

{
listBox1.Items.Add(Emp.LastName)
}

Testar o aplicativo
Execute o aplicativo e verifique se os registros exibidos na caixa de listagem são todos os funcionários (registros
que têm um valor de 2 em sua coluna de tipo ).
Para testar o aplicativo
1. Pressione F5 .
2. Verifique se apenas os registros que têm um valor de 2 na coluna Tipo são exibidos.
3. Feche o formulário. (No menu depurar , clique em parar depuração .)

Confira também
ferramentas de LINQ to SQL no Visual Studio
Passo a passo: criando classes LINQ to SQL (Designer Relacional de Objetos)
Como atribuir procedimentos armazenados para executar atualizações, inserções e exclusões (Designer
Relacional de Objetos)
LINQ to SQL
como gerar o modelo de objeto em Visual Basic ou C #
Passo a passo: criar um aplicativo de dados de n
camadas
20/11/2021 • 14 minutes to read

Os aplicativos de dados de N camadas são aplicativos que acessam dados e são separados em várias camadas
lógicas. A separação de componentes de aplicativos em camadas discretas aumenta a capacidade de
manutenção e a escalabilidade do aplicativo. Isso é feito pela adoção com mais facilidade de novas tecnologias
que podem ser aplicadas a uma única camada, sem precisar reprojetar toda a solução. A arquitetura de N
camadas inclui uma camada de apresentação, uma camada intermediária e uma camada de dados. A camada
intermediária geralmente inclui uma camada de acesso a dados, uma camada lógica de negócios e
componentes compartilhados, tais como autenticação e validação. A camada de dados inclui um banco de
dados relacional. Os aplicativos de N camadas geralmente armazenam informações confidenciais na camada de
acesso a dados da camada intermediária para manter o isolamento de usuários finais que acessam a camada de
apresentação. Para obter mais informações, consulte Visão geral de aplicativos de dados de N camadas.
Uma maneira de separar as várias camadas em um aplicativo de N camadas é criar projetos discretos para cada
camada que você deseja incluir em seu aplicativo. Os conjuntos de dados digitados contêm uma propriedade
DataSet Project que determina quais projetos o conjunto de dados gerado e o código TableAdapter devem
acessar.
Esse passo a passo demonstra como separar o conjunto de dados e o código TableAdapter em projetos de
biblioteca de classes discretas usando o Designer de Conjunto de Dados . Depois de separar o grupo de
dados e o código TableAdapter, você cria um Windows Communication Foundation Services e um WCF Data
Services no Visual Studio para chamar para a camada de acesso a dados. Por fim, você cria um Windows Forms
como a camada de apresentação. Essa camada acessa dados do serviço de dados.
Durante este passo a passo, você executará as seguintes etapas:
Crie uma nova solução de n camadas que contém vários projetos.
Adicionar dois projetos de bibliotecas de classes na solução de N camadas.
Criar um conjunto de dados tipado usando o Assistente de Configuração de Fonte de Dados .
Separe o TableAdapters gerado e o código do conjuntos de dados em projetos discretos.
Criar um serviço do Windows Communication Foundation (WCF) a ser chamado na camada de acesso a
dados.
Criar funções no serviço para recuperar dados da camada de acesso a dados.
Criar um aplicativo do Windows Forms para servir como a camada de apresentação.
Criar controles do Windows Forms associados à fonte de dados.
Gravar código para preencher as tabelas de dados.

para uma versão em vídeo deste tópico, consulte vídeo de instruções: Criando um aplicativo de dados de N
camadas.

Pré-requisitos
Este passo a passo usa SQL Server Express LocalDB e o banco de dados de exemplo Northwind.
1. Se você não tiver um SQL Server Express LocalDB, instale-o na página de download SQL Server Express
oupor meio do Instalador do Visual Studio . No Instalador do Visual Studio , você pode instalar o
SQL Server Express LocalDB como parte da carga de trabalho de desenvolvimento da área de trabalho
do .NET ou como um componente individual.
2. Instale o banco de dados de exemplo Northwind seguindo estas etapas:
a. No Visual Studio, abra a SQL Ser ver Pesquisador de Objetos janela. (SQL Ser ver
Pesquisador de Objetos é instalado como parte da carga de trabalho armazenamento e
processamento de dados no Instalador do Visual Studio.) Expanda o SQL Ser ver nó. Clique
com o botão direito do mouse na LocalDB e selecione Nova Consulta .
Uma janela do editor de consultas é aberta.
b. Copie o script Northwind Transact-SQL para a área de transferência. Esse script T-SQL cria o banco
de dados Northwind do zero e o popula com dados.
c. Colar o script T-SQL no editor de consultas e, em seguida, escolha o botão Executar.
Após um curto período, a consulta termina a execução e o banco de dados Northwind é criado.

Criar a solução de n camadas e a biblioteca de classes para manter o

conjuntos de dados (DataEntityTier)
A primeira etapa deste passo a passo é criar uma solução e dois projetos de biblioteca de classes. A primeira
biblioteca de classes contém o conjuntos de dados (a classe digitada gerada e DataSet DataTables que contém
os dados do aplicativo). Este projeto é usado como a camada de entidade de dados do aplicativo e geralmente
está localizada na camada intermediária. O conjuntos de dados cria o conjuntos de dados inicial e separa
automaticamente o código nas duas bibliotecas de classes.

NOTE
Dê o nome correto ao projeto e à solução antes de clicar em OK . Isso facilitará a conclusão deste passo a passo.

Para criar a solução de N camadas e a biblioteca de classes DataEntityTier

1. No Visual Studio, no menu Arquivo , selecione Novo > Projeto .
2. Expanda Visual C# ou Visual Basic no painel esquerdo e selecione Windows Desktop.
3. No painel central, selecione o tipo de projeto Biblioteca de Classes.
4. Nomeie o projeto como DataEntityTier .
5. Nomeia a solução NTierWalkthrough e, em seguida, escolha OK.
Uma solução NTierWalkthrough que contém o projeto DataEntityTier é criada e adicionada ao
Gerenciador de Soluções .

Criar a biblioteca de classes para manter o TableAdapters

(DataAccessTier)
A próxima etapa após a criação do projeto DataEntityTier é criar outro projeto de biblioteca de classes. Este
projeto contém os TableAdapters gerados e é chamado de camada de acesso a dados do aplicativo. A camada de
acesso a dados contém as informações necessárias para se conectar ao banco de dados e geralmente está
localizada na camada intermediária.
Para criar uma biblioteca de classes separada para TableAdapters
1. Clique com o botão direito do mouse na solução no Gerenciador de Soluções e escolha Adicionar >
Novo Projeto .
2. Na caixa de diálogo Project, no painel central, selecione Biblioteca de Classes .
3. Nomeia o projeto Como DataAccessTier e escolha OK.
O projeto DataAccessTier é criado e adicionado à solução NTierWalkthrough.

Criar o conjuntos de dados

A próxima etapa é criar um conjunto de dados tipado. Conjuntos de dados digitados são criados com a classe de
conjuntos de dados (incluindo classes) e as DataTables classes em um único TableAdapter projeto. (Todas as
classes são geradas em um único arquivo.) Quando você separa o conjuntos de dados e TableAdapters em
projetos diferentes, é a classe de conjuntos de dados que é movida para o outro projeto, deixando as classes no
TableAdapter projeto original. Portanto, crie o conjuntos de dados no projeto que, por fim, conterá os
TableAdapters (o projeto DataAccessTier). Você cria o conjuntos de dados usando o Assistente de
Configuração da Fonte de Dados .

NOTE
É preciso ter acesso ao banco de dados de exemplo Northwind para criar a conexão. Para obter informações sobre como
configurar o banco de dados de exemplo Northwind, consulte Como instalar bancos de dados de exemplo.

Para criar o conjunto de dados

1. Selecione DataAccessTier no Gerenciador de Soluções .
2. No menu Dados, selecione Mostrar Fontes de Dados .
A janela Fontes de Dados é aberta.
3. Na janela Fontes de Dados, selecione Adicionar Nova Fonte de Dados para iniciar o Assistente de
Configuração da Fonte de Dados .
4. Na página Escolher um Tipo de Fonte de Dados, selecione Banco de Dados e, em seguida, selecione
Próximo.
5. Na página Escolha a Conexão de Dados , execute uma das seguintes ações:
Se uma conexão de dados com o banco de dados de exemplo Northwind estiver disponível na lista
suspensa, selecione-o.
-ou-
Selecione Nova Conexão para abrir a caixa de diálogo Adicionar Conexão .
6. Se o banco de dados exigir uma senha, selecione a opção para incluir dados confidenciais e, em seguida,
escolha Próximo .

NOTE
Se você escolheu um arquivo do banco de dados local (em vez de se conectar ao SQL Server), talvez seja
perguntado se deseja adicionar o arquivo ao projeto. Escolha Sim para adicionar o arquivo de banco de dados ao
projeto.

7. Selecione Próximo na página Salvar a Cadeia de Conexão no Arquivo de Configuração de Aplicativo.

8. Expanda o nó Tabelas na página Escolher Seus Objetos de Banco de Dados.
9. Marque as caixas de seleção para as tabelas Clientes e Pedidos e escolha Concluir .
NorthwindDataSet é adicionado ao projeto DataAccessTier e aparece na janela Fontes de Dados .

Separar os TableAdapters do dataset

Depois de criar o conjunto de dados, separe a classe do conjunto de dados gerada a partir dos TableAdapters.
Você faz isso ao configurar a propriedade Projeto do Conjunto de Dados para o nome do projeto que
armazenará a classe do conjunto de dados separada.
Para separar os TableAdapters do Conjunto de Dados
1. Clique duas vezes em Nor thwindDataSet.xsd no Gerenciador de Soluções para abrir o conjunto de
dados no Designer de Conjunto de Dados .
2. Selecione uma área vazia no designer.
3. Localize o nó Projeto do Conjunto de Dados na janela Propriedades .
4. Na lista DataSet Project, selecione DataEntityTier.
5. No menu Build , selecione Compilar Solução .
O conjunto de dados e os TableAdapters são separados em dois projetos de biblioteca de classes. O
projeto que originalmente continha todo o DataSet ( DataAccessTier ) agora contém apenas os
TableAdapters. o projeto designado no conjunto de Project propriedade ( DataEntityTier ) contém o
dataset tipado: NorthwindDataSet. DataSet. Designer. vb (ou NorthwindDataSet. dataset. designer. cs).

NOTE
Quando você separa os conjuntos de dados e os TableAdapters (configurando a propriedade Projeto de Conjunto de
Dados ), as classes dos conjuntos de dados parciais existentes no projeto não são movidas automaticamente. As classes
parciais do conjunto de dados existentes devem ser movidas manualmente para o projeto do conjunto de dados.

Criar um novo aplicativo de serviço

Este tutorial demonstra como acessar a camada de acesso a dados usando um serviço WCF, portanto, vamos
criar um novo aplicativo de serviço WCF.
Para criar um novo aplicativo de Serviço WCF
1. Clique com o botão direito do mouse na solução no Gerenciador de Soluções e escolha Adicionar >
Novo Projeto .
2. na caixa de diálogo novo Project , no painel esquerdo, selecione WCF . No painel central, selecione
biblioteca de ser viços WCF .
3. Nomeie o projeto como DataSer vice e selecione OK .
O projeto DataService é criado e adicionado à solução NTierWalkthrough.

Criar métodos na camada de acesso a dados para retornar os dados

dos clientes e pedidos
O serviço de dados precisa chamar dois métodos na camada de acesso a dados: GetCustomers e GetOrders .
Esses métodos retornam a Northwind Customers e as Orders tabelas. Crie os GetCustomers GetOrders
métodos e no DataAccessTier projeto.
Para criar um método na camada de acesso a dados que retorna a tabela Clientes
1. Em Gerenciador de soluções , clique duas vezes em Nor thwindDataSet. xsd para abrir o conjunto de
um.
2. Clique com o botão direito do mouse em CustomersTableAdapter e clique em Adicionar consulta .
3. Na página Escolher um Tipo de Comando , mantenha o valor padrão de Usar instruções SQL e
clique em Próximo .
4. Na página Escolher um Tipo de Consulta , mantenha o valor padrão de SELECT que retorna linhas
e clique em Próximo .
5. Na página Especificar uma instrução SQL SELECT , mantenha a consulta padrão e clique em
Próximo .
6. Na página Escolher Métodos a Serem Gerados , digite GetCustomers para o Nome do método na
seção Retornar uma DataTable .
7. Clique em Concluir .
Para criar um método na camada de acesso a dados que retorna a tabela Pedidos
1. Clique com o botão direito do mouse em OrdersTableAdapter e clique em Adicionar Consulta .
2. Na página Escolher um Tipo de Comando , mantenha o valor padrão de Usar instruções SQL e
clique em Próximo .
3. Na página Escolher um Tipo de Consulta , mantenha o valor padrão de SELECT que retorna linhas
e clique em Próximo .
4. Na página Especificar uma instrução SQL SELECT , mantenha a consulta padrão e clique em
Próximo .
5. Na página Escolher Métodos a Serem Gerados , digite GetOrders para o Nome do método na
seção Retornar uma DataTable .
6. Clique em Concluir .
7. No menu Compilar , clique em Compilar Solução .

Adicionar uma referência à entidade de dados e às camadas de

acesso a dados para o serviço de dados
Como o serviço de dados requer informações do conjunto de dados e dos TableAdapters, adicione referências
aos projetos DataEntityTier e DataAccessTier .
Para adicionar referência aos serviço de dados
1. Clique com o botão direito do mouse em DataSer vice no Gerenciador de Soluções e clique em
Adicionar Referência .
2. Clique na guia Projetos na caixa de diálogo Adicionar Referência .
3. Escolha os projetos DataAccessTier e DataEntityTier .
4. Clique em OK .

Adicionar funções ao serviço para chamar os métodos GetCustomers

e GetOrders na camada de acesso a dados
Agora que a camada de acesso a dados contém os métodos para retornar dados, crie métodos no serviço de
dados para chamar os métodos na camada de acesso a dados.

NOTE
Para projetos C#, adicione uma referência ao assembly System.Data.DataSetExtensions para que o código a seguir seja
compilado.

Para criar as funções GetCustomers e GetOrders no serviço de dados

1. No projeto DataSer vice , clique duas vezes em ISer vice1.vb ou ISer vice1.cs .
2. Adicione o seguinte código no comentário Adicionar suas operações de ser viço aqui :

<OperationContract()> _
Function GetCustomers() As DataEntityTier.NorthwindDataSet.CustomersDataTable

<OperationContract()> _
Function GetOrders() As DataEntityTier.NorthwindDataSet.OrdersDataTable

[OperationContract]
DataEntityTier.NorthwindDataSet.CustomersDataTable GetCustomers();

[OperationContract]
DataEntityTier.NorthwindDataSet.OrdersDataTable GetOrders();

3. No projeto DataService, clique duas vezes em Ser vice1. vb (ou Ser vice1. cs ).
4. Adicione o seguinte código à classe Ser vice1 :

Public Function GetCustomers() As DataEntityTier.NorthwindDataSet.CustomersDataTable Implements

IService1.GetCustomers
Dim CustomersTableAdapter1 As New
DataAccessTier.NorthwindDataSetTableAdapters.CustomersTableAdapter
Return CustomersTableAdapter1.GetCustomers()
End Function

Public Function GetOrders() As DataEntityTier.NorthwindDataSet.OrdersDataTable Implements

IService1.GetOrders
Dim OrdersTableAdapter1 As New DataAccessTier.NorthwindDataSetTableAdapters.OrdersTableAdapter
Return OrdersTableAdapter1.GetOrders()
End Function

public DataEntityTier.NorthwindDataSet.CustomersDataTable GetCustomers()

{
DataAccessTier.NorthwindDataSetTableAdapters.CustomersTableAdapter
CustomersTableAdapter1
= new DataAccessTier.NorthwindDataSetTableAdapters.CustomersTableAdapter();
return CustomersTableAdapter1.GetCustomers();
}
public DataEntityTier.NorthwindDataSet.OrdersDataTable GetOrders()
{
DataAccessTier.NorthwindDataSetTableAdapters.OrdersTableAdapter
OrdersTableAdapter1
= new DataAccessTier.NorthwindDataSetTableAdapters.OrdersTableAdapter();
return OrdersTableAdapter1.GetOrders();
}

5. No menu Compilar , clique em Compilar Solução .

Criar uma camada de apresentação para exibir dados do serviço de
dados
Agora que a solução contém o serviço de dados que tem métodos, que chamam a camada de acesso a dados,
crie outro projeto que chame o serviço de dados e apresente os dados aos usuários. Neste passo a passo, crie
um aplicativo do Windows Forms, o qual será a camada de apresentação do aplicativo de N camadas.
Para criar o projeto da camada de apresentação
1. Clique com o botão direito do mouse na solução no Gerenciador de Soluções e escolha Adicionar >
Novo Projeto .
2. na caixa de diálogo novo Project , no painel esquerdo, selecione Windows área de trabalho . no
painel central, selecione Windows Forms aplicativo .
3. Nomeie o projeto como PresentationTier e clique em OK .
O projeto PresentationTier é criado e adicionado à solução NTierWalkthrough.

Definir o projeto PresentationTier como o projeto de inicialização

Vamos definir o projeto PresentationTier como o projeto de inicialização para a solução, porque ele é o
aplicativo cliente real que apresenta e interage com os dados.
Para configurar o novo projeto de camada de apresentação como o projeto de inicialização
Em Gerenciador de Soluções , clique com o botão direito do mouse em PresentationTier e clique em
Definir como Projeto de Inicialização .

Adicionar referências à camada de apresentação

O aplicativo cliente PresentationTier requer uma referência de serviço para o serviço de dados para acessar os
métodos no serviço. Além disso, uma referência ao conjunto de dados é necessária para permitir o
compartilhamento de tipos pelo serviço WCF. Até que você habilite o compartilhamento de tipo por meio do
serviço de dados, o código adicionado à classe de DataSet parcial não estará disponível para a camada de
apresentação. Como você normalmente adiciona código, como código de validação para os eventos de
alteração de linha e coluna de uma tabela de dados, é provável que você queira acessar esse código do cliente.
Para adicionar uma referência à camada de apresentação
1. Em Gerenciador de soluções , clique com o botão direito do mouse em PresentationTier e selecione
Adicionar referência .
2. Na caixa de diálogo Adicionar referência , selecione a guia projetos .
3. Selecione DataEntityTier e escolha OK .
Para adicionar uma referência de serviço à camada de apresentação
1. Em Gerenciador de soluções , clique com o botão direito do mouse em PresentationTier e selecione
Adicionar referência de ser viço .
2. Na caixa de diálogo Adicionar referência de ser viço , selecione descobrir .
3. Selecione Ser vice1 e escolha OK .

NOTE
Se você tiver vários serviços no computador atual, selecione o serviço que você criou anteriormente neste passo a
passos (o serviço que contém os GetCustomers GetOrders métodos e).
Adicione DataGridViews ao formulário para exibir os dados
retornados pelo serviço de dados
Depois de adicionar a referência de serviço ao serviço de dados, a janela Fontes de Dados é preenchida
automaticamente com os dados retornados pelo serviço.
Para adicionar duas associações de dados DataGridViews ao formulário
1. No Gerenciador de Soluções , escolha o projeto PresentationTier .
2. Na janela Fontes de Dados , expanda Nor thwindDataSet e localize o nó Clientes .
3. Arraste o nó Clientes para Form1.
4. Na janela Fontes de Dados , expanda o nó Clientes e localize o nó Pedidos relacionado (o nó Pedidos
aninhado no nó Clientes ).
5. Arraste o nó Pedidos relacionado para Form1.
6. Crie um manipulador de eventos Form1_Load ao clicar duas vezes em uma área vazia do formulário.
7. Adicione o seguinte código ao manipulador de eventos do Form1_Load .

Dim DataSvc As New ServiceReference1.Service1Client

NorthwindDataSet.Customers.Merge(DataSvc.GetCustomers)
NorthwindDataSet.Orders.Merge(DataSvc.GetOrders)

ServiceReference1.Service1Client DataSvc =
new ServiceReference1.Service1Client();
northwindDataSet.Customers.Merge(DataSvc.GetCustomers());
northwindDataSet.Orders.Merge(DataSvc.GetOrders());

Aumentar o tamanho máximo de mensagem permitido pelo serviço

O valor padrão para maxReceivedMessageSize não é grande o suficiente para manter os dados recuperados
Customers das Orders tabelas e. Nas etapas a seguir, você aumentará o valor para 6553600. Você altera o valor
no cliente, que atualiza automaticamente a referência de serviço.

NOTE
O menor tamanho padrão se destina a limitar a exposição para ataques de negação de serviço (DoS). Para obter mais
informações, consulte MaxReceivedMessageSize.

Para aumentar o valor maxReceivedMessageSize

1. No Gerenciador de Soluções , clique duas vezes no arquivo app.config no projeto PresentationTier .
2. Encontre o atributo de tamanho maxReceivedMessage e altere o valor para 6553600 .

Testar o aplicativo
Execute o aplicativo pressionando F5 . Os dados das Customers tabelas e Orders são recuperados do serviço de
dados e exibidos no formulário.

Próximas etapas
Dependendo dos requisitos do aplicativo, existem várias etapas que você talvez queira realizar após salvar os
dados relacionados no aplicativo baseado em Windows. Por exemplo, você poderia fazer as seguintes melhorias
a este aplicativo:
Adicionar validação ao conjunto de dados.
Adicionar métodos adicionais ao serviço para atualizar dados novamente no banco de dados.

Confira também
Trabalhar com conjuntos de dados em aplicativos de n camadas
Atualização hierárquica
Acessando dados no Visual Studio
Sistemas de banco de dados compatíveis para
Visual Studio
20/11/2021 • 3 minutes to read

Para desenvolver um aplicativo conectado a dados no Visual Studio, você normalmente instala o sistema de
banco de dados em seu computador de desenvolvimento local e, em seguida, implanta o aplicativo e o banco de
dados em um ambiente de produção quando eles estão prontos. Visual Studio instala SQL Server Express
LocalDB em seu computador como parte da carga de trabalho armazenamento e processamento de dados.
Essa LocalDB é útil para desenvolver aplicativos conectados a dados de maneira rápida e fácil.
Para que um sistema de banco de dados seja acessível por meio de aplicativos .NET e que seja visível Visual
Studio janelas de ferramentas de dados, ele deve ter um provedor ADO.NET dados. Um provedor deve dar
suporte especificamente Entity Framework se você planeja usar modelos de dados de entidade em seu
aplicativo .NET. Muitos provedores são oferecidos por meio do NuGet Gerenciador de Pacotes ou por meio do
Visual Studio Marketplace.
Se você estiver usando APIs de armazenamento do Azure, instale os emuladores de armazenamento do Azure
em seu computador local durante o desenvolvimento para evitar encargos até que você esteja pronto para
implantar em produção. Para saber mais, confira Usar o Emulador de Armazenamento do Azure para
desenvolvimento e teste.
A lista a seguir inclui alguns dos sistemas de banco de dados mais populares que podem ser usados em Visual
Studio projetos. A lista não é completa. Para ver uma lista de fornecedores de terceiros que oferecem
provedores ADO.NET de dados que permitem a integração profunda com ferramentas Visual Studio, consulte
ADO.NET provedores de dados.

Microsoft SQL Server

SQL Server é a oferta de banco de dados de flagship da Microsoft. SQL Server 2016 oferece desempenho
inovador, segurança avançada e relatórios e análises avançados e integrados. Ela é fornecidas em várias edições
projetadas para usos diferentes: da análise de negócios altamente escalonável e de alto desempenho para uso
em um único computador. SQL Server Express é uma edição completa do SQL Server personalizada para
redistribuição e incorporação. LocalDB é uma edição simplificada do SQL Server Express que não requer
nenhuma configuração e é executado no processo do aplicativo. Você pode baixar um ou ambos os produtos da
página SQL Server Express download do . Muitos dos exemplos SQL nesta seção usam SQL Server LocalDB.
SQL Server Management Studio (SSMS) é um aplicativo de gerenciamento de banco de dados autônomo que
tem mais funcionalidade do que o fornecido no Visual Studio SQL Server Pesquisador de Objetos. Você pode
obter SSMS do link anterior.

Oracle
Você pode baixar uma edição paga ou gratuita do banco de dados Oracle na página da rede de tecnologia
Oracle. Para suporte em tempo de design para Entity Framework e TableAdapters, você precisará do oracle
Ferramentas de desenvolvedor para Visual Studio. Outros produtos oficiais da Oracle, incluindo o Oracle Instant
Client, estão disponíveis por meio do NuGet Gerenciador de Pacotes. Você pode baixar esquemas de exemplo do
Oracle seguindo as instruções na documentação online do Oracle.

MySQL
O MySQL é um sistema de banco de dados de código aberto popular amplamente usado em empresas e sites.
Os downloads para MySQL, MySQL para Visual Studio e produtos relacionados estão no MySQL no Windows.
Terceiros oferecem várias extensões Visual Studio e aplicativos de gerenciamento autônomos para MySQL. Você
pode procurar as ofertas no NuGet Gerenciador de Pacotes (Ferramentas > NuGet Gerenciador de Pacotes
> Gerenciar pacotes NuGet para Solução).

PostgreSQL
O PostgreSQL é um sistema de banco de dados relacional de objeto de código aberto gratuito. Para instalá-lo
Windows, você pode baixá-lo na página de download do PostgreSQL. Você também pode criar o PostgreSQL
com base no código-fonte. O sistema principal do PostgreSQL inclui uma interface de linguagem C. Muitos
terceiros fornecem NuGet para usar o PostgreSQL de aplicativos .NET. Você pode procurar as ofertas no NuGet
Gerenciador de Pacotes (Ferramentas > NuGet Gerenciador de Pacotes > Gerenciar pacotes NuGet
para Solução). Talvez o pacote mais popular seja fornecido pelo npgsql.org.

SQLite
O SQLite é um mecanismo SQL banco de dados inserido que é executado no próprio processo do aplicativo.
Você pode baixá-lo na página de download do SQLite. Muitos pacotes de NuGet de terceiros para SQLite
também estão disponíveis. Você pode procurar as ofertas no NuGet Gerenciador de Pacotes (Ferramentas >
NuGet Gerenciador de Pacotes > Gerenciar pacotes NuGet para Solução).

Firebird
Firebird é um sistema de banco de dados SQL open-source. Você pode baixá-lo na página de download do
Firebird. Um ADO.NET de dados está disponível por meio do NuGet Gerenciador de Pacotes.

Confira também
Acessando dados em Visual Studio
Como determinar a versão e a edição do SQL Server e seus componentes
Ferramentas de dados do Visual Studio para .NET
20/11/2021 • 2 minutes to read

Visual Studio e .NET juntos fornecem amplo suporte de API e ferramentas para se conectar a bancos de dados,
modelar dados na memória e exibir os dados na interface do usuário. As classes .NET que fornecem a
funcionalidade de acesso a dados são conhecidas como ADO.NET. ADO.NET, juntamente com as ferramentas de
dados no Visual Studio, foi projetado principalmente para dar suporte a bancos de dados relacionais e XML.
Atualmente, muitos fornecedores de banco de dados NoSQL, ou terceiros, oferecem ADO.NET provedores.
O .NET Core dá suporte ADO.NET, exceto para conjuntos de dados e seus tipos relacionados. Se você estiver
direcionando o .NET Core e precisar de uma camada ORM (mapeamento relacional de objeto), use Entity
Framework Core.
O diagrama a seguir mostra uma exibição simplificada da arquitetura básica:

Fluxo de trabalho típico

O fluxo de trabalho típico é este:
1. Instale um banco de dados de desenvolvimento ou teste em seu computador local. Consulte Instalando
sistemas de banco de dados, ferramentas e exemplos. Se você estiver usando um serviço de dados do
Azure, essa etapa não será necessária.
2. Teste a conexão com o banco de dados (ou serviço ou arquivo local) no Visual Studio. Consulte Adicionar
novas conexões.
3. (Opcional) Use as ferramentas para gerar e configurar um novo modelo. Modelos baseados em Entity
Framework são a recomendação padrão para novos aplicativos. O modelo, o que você usar, é a fonte de
dados com a qual o aplicativo interage. O modelo fica logicamente entre o banco de dados ou o serviço e
o aplicativo. Consulte Adicionar novas fontes de dados.
4. Arraste a fonte de dados da janela Fontes de Dados para uma superfície de design Windows Forms,
ASP.NET ou Windows Presentation Foundation para gerar o código de associação de dados que exibirá os
dados para o usuário da maneira que você especificar. Consulte Vincular controles a dados no Visual
Studio.
5. Adicione código personalizado para coisas como regras de negócio, pesquisa e validação de dados ou
para aproveitar a funcionalidade personalizada que o banco de dados subjacente expõe.
Você pode ignorar a etapa 3 e programar um aplicativo .NET para emitir comandos diretamente para um banco
de dados, em vez de usar um modelo. Nesse caso, você encontrará a documentação relevante aqui: ADO.NET.
Observe que você ainda pode usar o Assistente de Configuração de Fonte de Dados e designers para gerar
código de associação de dados quando preencher seus próprios objetos na memória e, em seguida, vincular
controles de interface do usuário a esses objetos.

Confira também
Acessar dados no Visual Studio
Entity Framework Tools em Visual Studio
20/11/2021 • 3 minutes to read

Entity Framework é uma tecnologia de mapeamento relacional de objeto que permite que os desenvolvedores
do .NET trabalhem com dados relacionais usando objetos específicos de domínio. Com ele, não há a
necessidade da maioria dos códigos de acesso a dados que os desenvolvedores geralmente precisam para
escrever. Entity Framework é a tecnologia de modelagem de ORM (mapeamento relacional de objeto)
recomendada para novos aplicativos .NET.
Entity Framework Tools são projetadas para ajudá-lo a criar aplicativos de Entity Framework (EF). A
documentação completa para Entity Framework está aqui: visão geral – EF 6.

NOTE
O Entity Framework Tools descrito nesta página é usado para gerar arquivos . edmx , que não têm suporte no EF Core.
Para gerar um modelo de EF Core de um banco de dados existente, consulte engenharia reversa-EF Core. Para obter mais
informações sobre as diferenças entre o EF 6 e o EF Core, consulte comparar o EF 6 e o EF Core.

Com Entity Framework Tools, você pode criar um modelo conceitual a partir de um banco de dados existente e,
em seguida, Visualizar graficamente e editar seu modelo conceitual. Ou, você pode criar graficamente um
modelo conceitual primeiro e, em seguida, gerar um banco de dados que dê suporte ao seu modelo. Em ambos
os casos, você pode atualizar automaticamente seu modelo quando o banco de dados subjacente é alterado e
gerar automaticamente o código de camada de objeto para seu aplicativo. A geração de banco de dados e a
geração de código de camada de objeto são personalizáveis.
as ferramentas de Entity Framework são instaladas como parte da carga de trabalho de processamento e
armazenamento de dados no Instalador do Visual Studio. Você também pode instalá-los como um
componente individual na categoria SDKs, bibliotecas e estruturas .
Estas são as ferramentas específicas que compõem Entity Framework ferramentas no Visual Studio:
Você pode usar o ADO.NET Modelo de Dados de Entidade Designer (Entity designer ) para criar e
modificar visualmente entidades, associações, mapeamentos e relações de herança. O Entity designer
também gera C# ou o Visual Basic código de camada de objeto.
Você pode usar o Modelo de Dados de Entidade Assistente para gerar um modelo conceitual a
partir de um banco de dados existente e adicionar informações de conexão de banco de dados ao seu
aplicativo.
Você pode usar o Assistente para criar banco de dados para criar um modelo conceitual primeiro e,
em seguida, criar um banco de dados que ofereça suporte ao modelo.
Você pode usar o Assistente de atualização de modelo para atualizar seu modelo conceitual, o
modelo de armazenamento e os mapeamentos quando forem feitas alterações no banco de dados
subjacente.

NOTE
a partir do Visual Studio 2010, não há suporte para ferramentas de Entity Framework SQL Server 2000 .

As ferramentas geram ou modificam um arquivo . edmx . Esse arquivo . edmx contém informações que
descrevem o modelo conceitual, o modelo de armazenamento e os mapeamentos entre eles. Para obter mais
informações, consulte edmx.
O Entity Framework 6 Power Tools ajuda você a criar aplicativos que usam o modelo de dados de entidade. O
Power Tools pode gerar um modelo conceitual, validar um modelo existente, produzir arquivos de código-fonte
que contêm classes de objeto com base no modelo conceitual e produzir arquivos de código-fonte que
contenham exibições geradas pelo modelo. Para obter informações detalhadas, consulte exibições de
mapeamento geradas previamente.

Tópicos relacionados
T ÍT ULO DESC RIÇ Ã O

ADO.NET Entity Framework Descreve como usar Modelo de Dados de Entidade

ferramentas, que o Entity Framework fornece, para criar
aplicativos.

Modelo de Dados de Entidade Fornece links e informações para trabalhar com dados que
são usados por aplicativos criados no Entity Framework .

Documentação do Entity Framework (EF)) Fornece um índice de vídeos, tutoriais e documentação

avançada para ajudá-lo a aproveitar ao máximo Entity
Framework.

Confira também
Ferramentas de dados do Visual Studio para .NET
Ferramentas de conjunto de dados no Visual Studio
20/11/2021 • 3 minutes to read

NOTE
Conjuntos de dados e classes relacionadas são tecnologias herdadas do .NET do início dos anos 2000 que permitem que
os aplicativos trabalhem com dados na memória enquanto os aplicativos são desconectados do banco de dados. Eles são
especialmente úteis para aplicativos que permitem que os usuários modifiquem dados e persistam as alterações de volta
ao banco de dados. Embora os conjuntos de dados tenham se mostrado uma tecnologia muito bem-sucedida,
recomendamos que novos aplicativos .NET usem Entity Framework. Entity Framework fornece uma maneira mais natural
de trabalhar com dados tabular como modelos de objeto e tem uma interface de programação mais simples.

Um DataSet objeto é um objeto na memória que é essencialmente um mini-banco de dados. Ele contém
objetos , e nos quais você pode armazenar e modificar dados de um ou mais bancos de dados sem precisar
DataTable DataColumn manter uma conexão DataRow aberta. O conjuntos de dados mantém informações
sobre alterações em seus dados, portanto, as atualizações podem ser rastreadas e enviadas de volta ao banco
de dados quando o aplicativo é reconectado.
Conjuntos de dados e classes relacionadas são definidos System.Data no namespace na API do .NET. Você pode
criar e modificar conjuntos de dados dinamicamente no código usando ADO.NET. A documentação nesta seção
mostra como trabalhar com conjuntos de dados usando Visual Studio designers. Conjuntos de dados criados
por meio de designers usam objetos TableAdapter para interagir com o banco de dados. Conjuntos de dados
criados programaticamente usam objetos DataAdapter. Para obter informações sobre como criar conjuntos
de dados programaticamente, consulte DataAdapters e DataReaders.
Se seu aplicativo precisar apenas ler dados de um banco de dados e não executar atualizações, adicionações ou
exclusões, geralmente você pode obter um melhor desempenho usando um objeto para recuperar dados em
um objeto genérico ou em outro objeto de DataReader List coleção. Se você estiver exibindo os dados, poderá
vincular dados à interface do usuário à coleção.

Fluxo de trabalho do conjuntos de dados

Visual Studio fornece ferramentas para simplificar o trabalho com conjuntos de dados. O fluxo de trabalho
básico de ponta a ponta é:
Use a janela Fontes de Dados para criar um novo conjuntos de dados de uma ou mais fontes de dados.
Use o Designer de Conjunto de Dados para configurar o conjunto de dados e definir suas
propriedades. Por exemplo, você precisa especificar quais tabelas da fonte de dados incluir e quais
colunas de cada tabela. Escolha cuidadosamente para conservar a quantidade de memória que o
conjuntos de dados requer. Para obter mais informações, consulte Create and configure datasets (Criar e
configurar conjuntos de dados).
Especifique as relações entre as tabelas para que as chaves estrangeiras sejam tratadas corretamente.
Para obter mais informações, consulte Preencher conjuntos de dados usando TableAdapters.
Use o Assistente de Configuração de TableAdapter para especificar a consulta ou o procedimento
armazenado que popula o conjuntos de dados e quais operações de banco de dados (atualização,
exclusão e assim por diante) implementar. Para saber mais, consulte esses tópicos:
Preencher conjuntos de dados usando TableAdapters
Editar dados em conjuntos de dados
Validar dados em conjuntos de dados
Salvar dados novamente no banco de dados
Consulte e pesquise os dados no conjuntos de dados. Para obter mais informações, consulte Consultar
conjuntos de dados. LINQ to DataSethabilita LINQ (Consulta Integrada à Linguagem) sobre dados em um
DataSet objeto . Para obter mais informações, consulte LINQ to DataSet.
Use a janela Fontes de Dados para vincular controles de interface do usuário ao conjuntos de dados ou
suas colunas individuais e especificar quais colunas são editáveis pelo usuário. Para obter mais
informações, confira Associar controles a dados no Visual Studio.

Conjuntos de dados e arquitetura de N camadas

Para obter informações sobre conjuntos de dados em aplicativos de N camadas, consulte Trabalhar com
conjuntos de dados em aplicativos de n camadas.

Conjuntos de dados e XML

Para obter informações sobre como converter conjuntos de dados de e para XML, consulte Ler dados XML em
um conjuntos de dados e Salvar um conjuntos de dados como XML.

Confira também
Ferramentas de dados do Visual Studio para .NET
Conjuntos de dados tipados versus. não tipados
20/11/2021 • 3 minutes to read

Um conjuntos de dados digitado é um primeiro derivado da classe base e, em seguida, usa informações do
Designer de Conjunto de Dados , que é armazenado em um arquivo DataSet .xsd, para gerar uma nova classe de
conjuntos de dados fortemente digitada. As informações do esquema (tabelas, colunas e assim por diante) são
geradas e compiladas nessa nova classe de conjunto de dados como um conjunto de propriedades e objetos de
primeira classe. Como um conjuntos de dados digitados herda da classe base, a classe digitada assume toda a
funcionalidade da classe e pode ser usada com métodos que assumem uma instância de uma classe como
DataSet DataSet um DataSet parâmetro.
Um conjuntos de dados sem tipo, por outro lado, não tem nenhum esquema integrado correspondente. Assim
como em um conjunto de dados digitado, um conjunto de dados sem tipo contém tabelas, colunas e assim por
diante, mas eles são expostos apenas como coleções. (No entanto, depois de criar manualmente as tabelas e
outros elementos de dados em um conjuntos de dados sem tipo, você pode exportar a estrutura do conjuntos
de dados como um esquema usando o método do conjuntos de WriteXmlSchema dados.)

Contrastar o acesso a dados em conjuntos de dados digitados e não

digitados
A classe de um conjuntos de dados digitado tem um modelo de objeto no qual suas propriedades se baseam
nos nomes reais das tabelas e colunas. Por exemplo, se você estiver trabalhando com um conjuntos de dados
digitados, poderá referenciar uma coluna usando código como o seguinte:

// This accesses the CustomerID column in the first row of the Customers table.
string customerIDValue = northwindDataSet.Customers[0].CustomerID;

' This accesses the CustomerID column in the first row of the Customers table.
Dim customerIDValue As String = NorthwindDataSet.Customers(0).CustomerID

Por outro lado, se você estiver trabalhando com um conjuntos de dados sem tipo, o código equivalente será:

string customerIDValue = (string)

dataset1.Tables["Customers"].Rows[0]["CustomerID"];

Dim customerIDValue As String =

CType(dataset1.Tables("Customers").Rows(0).Item("CustomerID"), String)

O acesso digitado não só é mais fácil de ler, mas também é totalmente suportado pelo IntelliSense no Editor de
Código Visual Studio . Além de ser mais fácil de trabalhar, a sintaxe do conjuntos de dados digitado fornece
verificação de tipo em tempo de compilação, reduzindo consideravelmente a possibilidade de erros na
atribuição de valores a membros do conjuntos de dados. Se você alterar o nome de uma coluna em sua classe e
DataSet compilar seu aplicativo, receberá um erro de build. Clicando duas vezes no erro de build no Lista de
Tarefas , você pode ir diretamente para a linha ou linhas de código que referenciam o nome da coluna antiga. O
acesso a tabelas e colunas em um conjunto de dados digitado também é um pouco mais rápido em tempo de
executar porque o acesso é determinado em tempo de compilação, não por meio de coleções em tempo de
executar.
Embora os conjuntos de dados digitados tenham muitas vantagens, um conjuntos de dados sem tipo é útil em
várias circunstâncias. O cenário mais óbvio é quando nenhum esquema está disponível para o conjuntos de
dados. Isso pode ocorrer, por exemplo, se seu aplicativo estiver interagindo com um componente que retorna
um conjuntos de dados, mas você não sabe com antecedência qual é sua estrutura. Da mesma forma, há
ocasiões em que você está trabalhando com dados que não têm uma estrutura estática e previsível. Nesse caso,
é impraticável usar um conjuntos de dados digitado, pois você teria que regenerar a classe de conjuntos de
dados digitado com cada alteração na estrutura de dados.
Em geral, há muitas vezes que você pode criar um conjuntos de dados dinamicamente sem ter um esquema
disponível. Nesse caso, o conjuntos de dados é simplesmente uma estrutura conveniente na qual você pode
manter informações, desde que os dados possam ser representados de maneira relacional. Ao mesmo tempo,
você pode aproveitar os recursos do conjuntos de dados, como a capacidade de serializar as informações para
passar para outro processo ou gravar um arquivo XML.

Confira também
Ferramentas de conjuntos de dados
Preencher conjuntos de dados usando
TableAdapters
20/11/2021 • 9 minutes to read

Um componente TableAdapter preenche um DataSet com dados do banco de dados, com base em uma ou mais
consultas ou procedimentos armazenados que você especificar. Os TableAdapters também podem executar
adições, atualizações e exclusões no banco de dados para manter as alterações que você faz no DataSet. Você
também pode emitir comandos globais que não estão relacionados a nenhuma tabela específica.

NOTE
os tableadapters são gerados por Visual Studio designers. Se você estiver criando conjuntos de itens programaticamente,
use DataAdapter, que é uma classe .NET.

Para obter informações detalhadas sobre as operações do TableAdapter, você pode pular diretamente para um
destes tópicos:

TÓ P IC O DESC RIÇ Ã O

Criar e configurar TableAdapters Como usar os designers para criar e configurar

TableAdapters

Criar consultas TableAdapter parametrizadas Como permitir que os usuários forneçam argumentos para
procedimentos ou consultas do TableAdapter

Acessar o banco de dados diretamente com um Como usar os métodos DbDirect de TableAdapters
TableAdapter

Desabilitar restrições ao preencher um conjunto de dados Como trabalhar com restrições de chave estrangeira ao
atualizar dados

Como estender a funcionalidade de um TableAdapter Como adicionar código personalizado a TableAdapters

Ler dados XML em um conjunto de dados Como trabalhar com XML

Visão geral de TableAdapter

Os TableAdapters são componentes gerados pelo designer que se conectam a um banco de dados, executam
consultas ou procedimentos armazenados e preenchem sua DataTable com os dados retornados. Os
TableAdapters também enviam dados atualizados do seu aplicativo de volta para o banco de dados. Você pode
executar Quantas consultas desejar em um TableAdapter, desde que elas retornem dados que estejam de acordo
com o esquema da tabela com a qual o TableAdapter está associado. O diagrama a seguir mostra como os
TableAdapters interagem com bancos de dados e outros objetos na memória:
Embora os TableAdapters sejam projetados com o Designer de conjunto de dados , as classes do
TableAdapter não são geradas como classes aninhadas de DataSet . Eles estão localizados em namespaces
separados que são específicos para cada conjunto de informações. Por exemplo, se você tiver um conjunto de
um DataSet chamado NorthwindDataSet , os TableAdapters associados a DataTable s no NorthwindDataSet
estarão no NorthwindDataSetTableAdapters namespace. Para acessar um TableAdapter específico de forma
programática, você deve declarar uma nova instância do TableAdapter. Por exemplo:

NorthwindDataSet northwindDataSet = new NorthwindDataSet();

NorthwindDataSetTableAdapters.CustomersTableAdapter customersTableAdapter =
new NorthwindDataSetTableAdapters.CustomersTableAdapter();

customersTableAdapter.Fill(northwindDataSet.Customers);

Dim northwindDataSet As New NorthwindDataSet()

Dim customersTableAdapter As New NorthwindDataSetTableAdapters.CustomersTableAdapter()

customersTableAdapter.Fill(northwindDataSet.Customers)

Esquema DataTable associado

Quando você cria um TableAdapter, usa a consulta inicial ou o procedimento armazenado para definir o
esquema de associado do TableAdapter DataTable . Você executa essa consulta inicial ou procedimento
armazenado chamando o método do TableAdapter Fill (que preenche a associação do TableAdapter DataTable
). As alterações feitas na consulta principal do TableAdapter são refletidas no esquema da tabela de dados
associada. Por exemplo, remover uma coluna da consulta principal também remove a coluna da tabela de dados
associada. se quaisquer consultas adicionais no TableAdapter usarem SQL instruções que retornam colunas que
não estão na consulta principal, o designer tentará sincronizar as alterações de coluna entre a consulta principal
e as consultas adicionais.

Comandos de atualização do TableAdapter

A funcionalidade de atualização de um TableAdapter depende da quantidade de informações disponíveis na
consulta principal no Assistente TableAdapter . Por exemplo, os TableAdapters que são configurados para
buscar valores de várias tabelas (usando um JOIN ), valores escalares, exibições ou os resultados de funções de
agregação não são criados inicialmente com a capacidade de enviar atualizações de volta para o banco de dados
subjacente. No entanto, você pode configurar os INSERT UPDATE comandos, e DELETE manualmente na janela
Propriedades .

consultas TableAdapter

Os TableAdapters podem conter várias consultas para preencher suas tabelas de dados associadas. Você pode
definir tantas consultas para um TableAdapter quanto seu aplicativo exigir, desde que cada consulta retorne
dados que estejam de acordo com o mesmo esquema da tabela de dados associada. Esse recurso permite que
um TableAdapter carregue resultados diferentes com base em diferentes critérios.
Por exemplo, se seu aplicativo contiver uma tabela com nomes de clientes, você poderá criar uma consulta que
preencha a tabela com cada nome de cliente que começa com uma determinada letra e outra que preencha a
tabela com todos os clientes que estão localizados no mesmo estado. Para preencher uma Customers tabela
com clientes em um determinado Estado, você pode criar uma FillByState consulta que usa um parâmetro
para o valor de estado da seguinte maneira: SELECT * FROM Customers WHERE State = @State . Você executa a
consulta chamando o FillByState método e passando o valor do parâmetro como este:
CustomerTableAdapter.FillByState("WA") .

Além de adicionar consultas que retornam dados do mesmo esquema que a tabela de dados do TableAdapter,
você pode adicionar consultas que retornam valores escalares (únicos). Por exemplo, uma consulta que retorna
uma contagem de Customers ( SELECT Count(*) From Customers ) é válida para um CustomersTableAdapter, ,
embora os dados retornados não estejam de acordo com o esquema da tabela.

Propriedade ClearBeforeFill
Por padrão, sempre que você executa uma consulta para preencher uma tabela de dados do TableAdapter, os
dados existentes são apagados e somente os resultados da consulta são carregados na tabela. Defina a
propriedade do TableAdapter ClearBeforeFill como false se você quiser adicionar ou mesclar os dados
retornados de uma consulta para os dados existentes em uma tabela de dados. Independentemente de você
limpar os dados, você precisará enviar explicitamente atualizações de volta para o banco de dado, se desejar
mantê-los. Portanto, lembre-se de salvar as alterações nos dados na tabela antes de executar outra consulta que
preenche a tabela. Para obter mais informações, consulte atualizar dados usando um TableAdapter.
Herança do TableAdapter
Os TableAdapters estendem a funcionalidade de adaptadores de dados padrão encapsulando uma classe
configurada DataAdapter . Por padrão, o TableAdapter herda da Component classe e não pode ser convertido
para a DataAdapter classe. A conversão de um TableAdapter para a DataAdapter classe resulta em um
InvalidCastException erro. Para alterar a classe base de um TableAdapter, você pode especificar uma classe
derivada de Component na propriedade da classe base do TableAdapter no Designer de conjunto de
dados .

Métodos e propriedades do TableAdapter

A classe TableAdapter não é um tipo .NET. Isso significa que você não pode procurar na documentação ou no
pesquisador de objetos . Ele é criado em tempo de design quando você usa um dos assistentes mencionados
anteriormente. O nome atribuído a um TableAdapter quando você o cria é baseado no nome da tabela com a
qual você está trabalhando. Por exemplo, quando você cria um TableAdapter com base em uma tabela em um
banco de dados chamado Orders , o TableAdapter é nomeado OrdersTableAdapter . O nome de classe do
TableAdapter pode ser alterado usando a propriedade Name na Designer de conjunto de dados .
A seguir estão os métodos comumente usados e as propriedades de TableAdapters:

M EM B RO DESC RIÇ Ã O

TableAdapter.Fill Popula a tabela de dados associada do TableAdapter com os

resultados do comando do TableAdapter SELECT .

TableAdapter.Update Envia as alterações de volta ao banco de dados e retorna um

inteiro que representa o número de linhas afetadas pela
atualização. Para obter mais informações, consulte atualizar
dados usando um TableAdapter.

TableAdapter.GetData Retorna um novo DataTable que é preenchido com dados.

TableAdapter.Insert Cria uma nova linha na tabela de dados. Para obter mais
informações, consulte inserir novos registros em um banco
de dados.

TableAdapter.ClearBeforeFill Determina se uma tabela de dados é esvaziada antes de

chamar um dos Fill métodos.

Método de atualização do TableAdapter

Os TableAdapters usam comandos de dados para ler e gravar no banco de dado. Use a Fill consulta inicial
(principal) do TableAdapter como a base para criar o esquema da tabela de dados associada, bem como os
InsertCommand comandos, UpdateCommand e associados ao DeleteCommand TableAdapter.Update método.
Chamar um método do TableAdapter Update executa as instruções que foram criadas quando o TableAdapter
foi originalmente configurado, não uma das consultas adicionais que você adicionou com o Assistente de
configuração de consulta do TableAdapter .
Quando você usa um TableAdapter, ele executa efetivamente as mesmas operações com os comandos que você
normalmente executaria. Por exemplo, quando você chama o método do adaptador Fill , o adaptador executa
o comando de dados em sua SelectCommand propriedade e usa um leitor de dados (por exemplo, SqlDataReader
) para carregar o conjunto de resultados na tabela de dados. Da mesma forma, quando você chama o Update
método do adaptador, ele executa o comando apropriado ( UpdateCommand nas InsertCommand Propriedades, e
DeleteCommand ) para cada registro alterado na tabela de dados.
NOTE
Se houver informações suficientes na consulta principal, os InsertCommand UpdateCommand comandos, e
DeleteCommand serão criados por padrão quando o TableAdapter for gerado. Se a consulta principal do TableAdapter for
mais do que uma instrução de tabela única SELECT , é possível que o designer não possa gerar InsertCommand ,
UpdateCommand e DeleteCommand . Se esses comandos não forem gerados, você poderá receber um erro ao executar o
TableAdapter.Update método.

GenerateDbDirectMethods do TableAdapter
Além de InsertCommand , os UpdateCommand DeleteCommand TableAdapters são criados com métodos que você
pode executar diretamente no banco de dados. Você pode chamar esses métodos ( TableAdapter.Insert ,
TableAdapter.Update e TableAdapter.Delete ) diretamente para manipular dados no banco de dado. Isso
significa que você pode chamar esses métodos individuais do seu código em vez de chamar
TableAdapter.Update para manipular as inserções, atualizações e exclusões que estão pendentes para a tabela
de dados associada.
Se você não quiser criar esses métodos diretos, defina a propriedade GenerateDBDirectMethods do
TableAdapter como false (na janela Propriedades ). Consultas adicionais que são adicionadas ao
TableAdapter são consultas autônomas — elas não geram esses métodos.

Suporte do TableAdapter para tipos anuláveis

TableAdapters são suportados por tipos que podem ser Nullable(Of T) anulados e T? . Para obter mais
informações sobre tipos que permitem valor nulo no Visual Basic, consulte Tipos de valores que permitem valor
nulo. Para obter mais informações sobre tipos que podem ser anulados em C#, consulte Usar tipos que podem
ser anulados.

Referência de TableAdapterManager
Por padrão, uma classe TableAdapterManager gera quando você cria um conjuntos de dados que contém
tabelas relacionadas. Para impedir que a classe seja gerada, altere o valor da Hierarchical Update propriedade
do conjuntos de dados para false. Quando você arrasta uma tabela que tem uma relação para a superfície de
design de um formulário Windows ou página WPF, o Visual Studio declara uma variável de membro da classe .
Se você não usar a adição de dados, será necessário declarar manualmente a variável.
A classe TableAdapterManager não é um tipo .NET. Portanto, você não pode procurar na documentação. Ele é
criado em tempo de design como parte do processo de criação do conjuntos de dados.
A seguir estão os métodos e propriedades usados com frequência da TableAdapterManager classe :

M EM B RO DESC RIÇ Ã O

Método UpdateAll Salva todos os dados de todas as tabelas de dados.

Propriedade BackUpDataSetBeforeUpdate Determina se é preciso criar uma cópia de backup do

conjunto de dados antes de executar o
TableAdapterManager.UpdateAll método . Boolean.
M EM B RO DESC RIÇ Ã O

tableName TableAdapter Propriedade Representa um TableAdapter. O TableAdapterManager

gerado contém uma propriedade para cada TableAdapter
um que gerencia. Por exemplo, um conjuntos de dados com
uma tabela Customers e Orders é gerado com um
TableAdapterManager que contém
CustomersTableAdapter as OrdersTableAdapter
propriedades e .

Propriedade UpdateOrder Controla a ordem dos comandos de inserção, atualização e

exclusão individuais. De definido como um dos valores na
TableAdapterManager.UpdateOrderOption enumeração .

Por padrão, o UpdateOrder é definido como

Inser tUpdateDelete. Isso significa que inserções,
atualizações e exclusões são executadas para todas as
tabelas no conjuntos de dados.

Segurança
Ao usar comandos de dados com uma propriedade CommandType definida como , verifique cuidadosamente as
informações enviadas de um cliente antes de passá-las Text para o banco de dados. Usuários maliciosos podem
tentar enviar (injetar) instruções SQL modificadas ou adicionais para obter acesso não autorizado ou para
danificar o banco de dados. Antes de transferir a entrada do usuário para um banco de dados, sempre verifique
se as informações são válidas. Uma melhor prática é sempre usar consultas parametrizadas ou procedimentos
armazenados quando possível.

Confira também
Ferramentas de conjuntos de dados
Trabalhar com conjuntos de dados em aplicativos
de n camadas
20/11/2021 • 2 minutes to read

Aplicativos de dados de N camadas são aplicativos centrados em dados separados em várias camadas lógicas
(ou camadas). Em outras palavras, um aplicativo de dados de N camadas é um aplicativo separado em vários
projetos, com camada de acesso a dados, camada lógica de negócios e camada de apresentação em seu próprio
projeto. Para obter mais informações, consulte Visão geral de aplicativos de dados de N camadas.
Os conjuntos de dados tipados foram aprimorados para que as classes TableAdapters e de conjuntos de dados
possam ser geradas em projetos discretos. Com isso, é possível separar com rapidez as camadas de aplicativos
e gerar aplicativos de dados de N camadas.
O suporte de N camadas em conjuntos de dados digitados permite o desenvolvimento iterativo da arquitetura
do aplicativo para um design de n camadas. Ele também remove o requisito de separar manualmente o código
em mais de um projeto. Comece a criar a camada de dados usando o Designer de Conjunto de Dados .
Quando você estiver pronto para aplicar a arquitetura do aplicativo a um projeto de N camadas, configure a
propriedade Projeto de Conjunto de Dados de um conjunto de dados para gerar a classe do conjunto de
dados em um projeto separado.

Referência
DataSet
TypedTableBase<T>

Confira também
Visão geral de aplicativos de dados de N camadas
Passo a passo: criando um aplicativo de dados de n camadas
Adicionar código a TableAdapters em aplicativos de n camadas
Adicionar código a conjuntos de dados em aplicativos de n camadas
Adicionar validação a um conjunto de dados de n camadas
Conjuntos de dados e TableAdapters separados m diferentes projetos
Atualização hierárquica
Ferramentas de conjunto de dados no Visual Studio
Acessando dados em Visual Studio
Criar e configurar TableAdapters
Aplicativos remotos e de N camadas com LINQ to SQL
Projetos de banco de dados e aplicativos da
camada de dados
20/11/2021 • 2 minutes to read

Você pode usar projetos de banco de dados para criar novos bancos de dados, novos DACs (aplicativos da
camada de dados) e atualizar bancos de dados existentes e aplicativos da camada de dados. Os projetos de
banco de dados e os projetos de DAC permitem que você aplique técnicas de controle de versão e
gerenciamento de projetos aos seus esforços de desenvolvimento de banco de dados da mesma maneira que
aplica essas técnicas ao código gerenciado ou nativo. Você pode ajudar sua equipe de desenvolvimento a
gerenciar alterações em bancos de dados e servidores de banco de dados criando um projeto de DAC, um
projeto de banco de dados ou um projeto de servidor e colocando-o sob controle de versão. Os membros da
sua equipe podem fazer check-out de arquivos para fazer, criar e testar alterações em um ambiente de
desenvolvimento isolado ou em uma área de trabalho, antes de compartilhar com a equipe. Para ajudar a
garantir a qualidade do código, sua equipe pode concluir e testar todas as alterações para uma versão específica
do banco de dados em um ambiente de preparação antes de implantar as alterações na produção.
Para ver uma lista dos recursos de banco de dados com suporte por aplicativos da camada de dados, confira
Suporte do DACpara SQL Server objetos . Se você usar recursos em seu banco de dados que não têm suporte
de aplicativos da camada de dados, deverá usar um projeto de banco de dados para gerenciar alterações no
banco de dados.

Tarefas comuns de alto nível

H IGH - L EVEL TA REFA C O N T EÚDO DE SUP O RT E

Inicie o desenvolvimento de um aplicativo da - Aplicativos da camada de dados

camada de dados: O conceito de um DAC (aplicativo da - SQL Server Management Studio
camada de dados) foi introduzido com o SQL Server 2008.
Um DAC contém a definição de um banco de dados SQL
Server e os objetos de instância de suporte usados por um
aplicativo cliente-servidor ou de três camadas. Um DAC
inclui objetos de banco de dados, como tabelas e exibições,
junto com entidades de instância, como logons. Você pode
usar Visual Studio para criar um projeto de DAC, criar um
arquivo de pacote do DAC e enviar o arquivo de pacote do
DAC para um administrador de banco de dados para
implantação em uma instância do mecanismo de banco de
dados SQL Server.

Executando o desenvolvimento iterativo de banco - Project de banco de dados offline orientado a SQL Server
de dados: Os desenvolvedores podem conferir partes do Data Tools)
projeto e atualizá-las em um ambiente de desenvolvimento - Depurador SQL transact-SQL Server Management Studio)
isolado. Usando esse tipo de ambiente, você pode testar
suas alterações sem afetar outros membros da equipe.
Depois que as alterações são concluídas, você verifica os
arquivos novamente no controle de versão, em que outros
membros da equipe podem obter suas alterações, criar e
implantá-las em um servidor de teste.
H IGH - L EVEL TA REFA C O N T EÚDO DE SUP O RT E

Criação de protótipos, verificação de resultados de - Editores de consulta e texto (SQL Server Management
teste e modificação de scripts e objetos de banco de Studio)
dados: Você pode usar o editor transact-SQL para executar
qualquer uma dessas tarefas comuns.

Confira também
Ferramentas de dados do Visual Studio para .NET
Visão geral de aplicativos de dados de N camadas
20/11/2021 • 3 minutes to read

Os aplicativos de dados de N camadas são aplicativos de dados separados em várias camadas. Também
chamados de "aplicativos distribuídos" e "aplicativos multicamadas", aplicativos de n camadas separam o
processamento em camadas discretas que são distribuídas entre o cliente e o servidor. Ao desenvolver
aplicativos que acessam dados, você deve ter uma separação clara entre as várias camadas que compõem o
aplicativo.
Um aplicativo de n camadas típico inclui uma camada de apresentação, uma camada intermediária e uma
camada de dados. A maneira mais fácil de separar as várias camadas em um aplicativo de n camadas é criar
projetos discretos para cada camada que você deseja incluir em seu aplicativo. por exemplo, a camada de
apresentação pode ser um aplicativo Windows Forms, enquanto a lógica de acesso a dados pode ser uma
biblioteca de classes localizada na camada intermediária. Além disso, a camada de apresentação pode se
comunicar com a lógica de acesso de dados na camada intermediária por meio de um serviço, como um serviço
Web. Dividir componentes do aplicativo em camadas separadas aumenta a facilidade de manutenção e a
escalabilidade do aplicativo. Ele faz isso habilitando a adoção mais fácil de novas tecnologias que podem ser
aplicadas a uma única camada sem a necessidade de reprojetar a solução inteira. Além disso, os aplicativos de n
camadas normalmente armazenam informações confidenciais na camada intermediária, o que mantém o
isolamento da camada de apresentação.
o Visual Studio contém vários recursos para ajudar os desenvolvedores a criar aplicativos de n camadas:
o conjunto de dados fornece um conjunto de dados Project propriedade que permite que você separe o
conjunto de dados (camada de entidade de dado) e tableadapters (camada de acesso a dados) em
projetos discretos.
as ferramentas de LINQ to SQL no Visual Studio fornecem configurações para gerar o DataContext e as
classes de dados em namespaces separados. Isso permite a separação lógica das camadas de acesso a
dados e de entidade de dados.
LINQ to SQL fornece o Attach método que permite reunir o DataContext de diferentes camadas em um
aplicativo. Para obter mais informações, consulte N camadas e aplicativos remotos com LINQ to SQL.

Camada de apresentação
A camada de apresentação é a camada na qual os usuários interagem com um aplicativo. Ele geralmente
também contém lógica adicional do aplicativo. Os componentes típicos da camada de apresentação incluem o
seguinte:
Componentes de vinculação de dados, como o BindingSource e o BindingNavigator .
representações de objeto de dados, como LINQ to SQL classes de entidade para uso na camada de
apresentação.
a camada de apresentação normalmente acessa a camada intermediária usando uma referência de serviço (por
exemplo, um Windows Communication Foundation serviços e WCF Data Services no aplicativo Visual Studio ).
A camada de apresentação não acessa diretamente a camada de dados. A camada de apresentação se comunica
com a camada de dados por meio do componente de acesso a dados na camada intermediária.

Camada intermediária
A camada intermediária é a camada que a camada de apresentação e a camada de dados usam para se
comunicar entre si. Os componentes típicos da camada intermediária incluem o seguinte:
Lógica de negócios, como regras de negócio e validação de dados.
Componentes de acesso a dados e lógica, como o seguinte:
TableAdapters e dataadaptadores e datalêrs.
representações de objeto de dados, como LINQ to SQL classes de entidade.
Serviços de aplicativos comuns, como autenticação, autorização e personalização.
a ilustração a seguir mostra os recursos e as tecnologias que estão disponíveis no Visual Studio e onde eles
podem se ajustar à camada intermediária de um aplicativo de n camadas.

A camada intermediária normalmente se conecta à camada de dados usando uma conexão de dados. Essa
conexão de dados normalmente é armazenada no componente de acesso a dados.

Camada de dados
A camada de dados é basicamente o servidor que armazena os dados de um aplicativo (por exemplo, um
servidor que executa o SQL Server).
a ilustração a seguir mostra os recursos e as tecnologias que estão disponíveis no Visual Studio e onde eles
podem se ajustar à camada de dados de um aplicativo de n camadas.

A camada de dados não pode ser acessada diretamente do cliente na camada de apresentação. Em vez disso, o
componente de acesso a dados na camada intermediária é usado para comunicação entre as camadas de
apresentação e de dados.

Ajuda para o desenvolvimento de n camadas

Os tópicos a seguir fornecem informações sobre como trabalhar com aplicativos de n camadas:
Conjuntos de dados e TableAdapters separados m diferentes projetos
Walkthrough: Criando um aplicativo de dados de n camadas
Aplicativos de N camadas e remotos com LINQ to SQL

Confira também
Walkthrough: Criando um aplicativo de dados de n camadas
Atualização hierárquica
Ferramentas de conjunto de dados no Visual Studio
Acessando dados no Visual Studio
Criar um banco de dados e adicionar tabelas no
Visual Studio
20/11/2021 • 6 minutes to read

Você pode usar o Visual Studio para criar e atualizar um arquivo de banco de dados local no SQL Server Express
LocalDB. Você também pode criar um banco de dados executando instruções Transact-SQL na janela de
ferramentas SQL Server Pesquisador de Objetos no Visual Studio. Neste tópico, criaremos um arquivo .mdf e
adicionaremos tabelas e chaves usando o Designer de Tabela.

Pré-requisitos
Para concluir este passo a passo, você precisará das cargas de trabalho de desenvolvimento da área de trabalho
do .NET e armazenamento de dados e processamento instaladas no Visual Studio. Para instalá-los, abra
Instalador do Visual Studio e escolha Modificar (ou Modificar mais ) ao lado da versão do Visual Studio que
você > deseja modificar.

NOTE
Os procedimentos neste artigo se aplicam somente a projetos .NET Framework Windows Forms, não a projetos do .NET
Core Windows Forms.

Criar um projeto e um arquivo de banco de dados local

1. Crie um novo projeto Windows Forms (.NET Framework) e nomee-o
SampleDatabaseWalkthrough .
2. Na barra de menus, selecione Project Adicionar > Novo Item .
3. Na lista de modelos de item, role para baixo e selecione Banco de Dados baseado em ser viço .
4. Nomeia o banco de dados SampleDatabase e clique em Adicionar .
Adicionar uma fonte de dados
1. Se a janela Fontes de Dados não estiver aberta, abra-a pressionando Shift Alt D ou selecionando Exibir
Windows Fontes de Dados na + + barra > > de menus.
2. Na janela Fontes de Dados, selecione Adicionar Nova Fonte de Dados .

O Assistente de Configuração da Fonte de Dados é aberto.

3. Na página Escolher um Tipo de Fonte de Dados, escolha Banco de Dados e, em seguida, escolha
Próximo.
4. Na página Escolher um Modelo de Banco de Dados, escolha Próximo para aceitar o padrão
(Dataset).
5. Na página Escolher Sua Conexão de Dados, selecione o arquivo SampleDatabase.mdf na listada e,
em seguida, escolha Próximo .
6. Na página Salvar a Cadeia de Conexão no Arquivo de Configuração de Aplicativo, escolha
Próximo.
7. Na página Escolher seus Objetos de Banco de Dados, você verá uma mensagem informando que o
banco de dados não contém nenhum objeto. Escolha Concluir .
Exibir propriedades da conexão de dados
Você pode exibir a cadeia de conexão para o arquivo SampleDatabase.mdf abrindo o janela Propriedades da
conexão de dados:
Selecione Exibir > SQL Ser ver Pesquisador de Objetos para abrir a SQL Ser ver Pesquisador de
Objetos janela. Expanda (localdb)\MSSQLLocalDB Databases e clique com o botão direito do mouse
em > SampleDatabase.mdf e selecione Propriedades .
Como alternativa, você pode selecionar > Exibir Gerenciador de Ser vidores , se essa janela ainda não
estiver aberta. Abra o janela Propriedades expandindo o nó Conexões de Dados, clicando com o botão
direito do mouse em SampleDatabase.mdf e selecionando Propriedades .

TIP
Se você não puder expandir o nó Conexões de Dados ou a conexão SampleDatabase.mdf não estiver listada,
selecione o botão Conexão para Banco de Dados na barra de ferramentas Gerenciador de Servidores dados. Na
caixa de diálogo Adicionar Conexão, certifique-se de que Microsoft SQL Server arquivo de banco de dados está
selecionado em Fonte de dados e, em seguida, navegue até e selecione o arquivo SampleDatabase.mdf. Termine
de adicionar a conexão selecionando OK.

Criar tabelas e chaves usando Designer de Tabela

Nesta seção, você criará duas tabelas, uma chave primária em cada tabela e algumas linhas de dados de
exemplo. Você também criará uma chave estrangeira para especificar como os registros em uma tabela
correspondem aos registros na outra tabela.
Criar a tabela Clientes
1. No Gerenciador de Ser vidores , expanda o nó Conexões de Dados e expanda o nó
SampleDatabase.mdf.
Se você não puder expandir o nó Conexões de Dados ou a conexão SampleDatabase.mdf não estiver
listada, selecione o botão Conexão para Banco de Dados na barra de ferramentas Gerenciador de
Servidores dados. Na caixa de diálogo Adicionar Conexão, certifique-se de que Microsoft SQL Server
arquivo de banco de dados está selecionado em Fonte de dados e, em seguida, navegue até e selecione o
arquivo SampleDatabase.mdf. Termine de adicionar a conexão selecionando OK.
2. Clique com o botão direito do mouse em Tabelas e selecione Adicionar Nova Tabela .
O Designer de Tabela é aberto e mostra uma grade com uma linha padrão, que representa uma única
coluna na tabela que você está criando. Adicionando linhas à grade, você adicionará colunas na tabela.
3. Na grade, adicione uma linha para cada uma das seguintes entradas:

N O M E DA C O L UN A T IP O DE DA DO S P ERM IT IR N ULO S

CustomerID nchar(5) Falso (desmarcado)

CompanyName nvarchar(50) Falso (desmarcado)

ContactName nvarchar (50) Verdadeiro (marcado)

Phone nvarchar (24) Verdadeiro (marcado)

4. Clique com o botão direito do mouse CustomerID na linha e selecione Definir Chave Primária .
5. Clique com o botão direito do mouse na linha padrão ( Id ) e selecione Excluir .
6. Nomeie a tabela Clientes atualizando a primeira linha no painel de script de acordo com o seguinte
exemplo:

CREATE TABLE [dbo].[Customers]

Você deverá ver algo como:

7. No canto superior esquerdo do Designer de Tabela , selecione Atualizar ou pressione Shift + Alt + U .
8. Na caixa de diálogo Visualizar Atualizações de Banco de Dados, selecione Atualizar Banco de Dados .
A tabela Clientes é criada no arquivo de banco de dados local.
Criar a tabela Orders
1. Adicione outra tabela e uma linha para cada entrada na seguinte tabela:

N O M E DA C O L UN A T IP O DE DA DO S P ERM IT IR N ULO S

OrderID int Falso (desmarcado)

CustomerID nchar(5) Falso (desmarcado)

OrderDate datetime Verdadeiro (marcado)

OrderQuantity int Verdadeiro (marcado)

2. Demarque OrderID como a chave primária e exclua a linha padrão.

3. Nomeie a tabela Orders atualizando a primeira linha no painel de script de acordo com o seguinte
exemplo:

CREATE TABLE [dbo].[Orders]

4. No canto superior esquerdo do Designer de Tabela , selecione Atualizar ou pressione Shift + Alt + U ..
5. Na caixa de diálogo Visualizar Atualizações de Banco de Dados, selecione Atualizar Banco de Dados .
A tabela Orders é criada no arquivo de banco de dados local. Se você expandir o nó Tabelas Gerenciador
de Servidores, verá as duas tabelas:
Se você não a vir, clique no botão Atualizar barra de ferramentas.
Criar uma chave estrangeira
1. No painel de contexto à direita da grade Designer de Tabela para a tabela Pedidos, clique com o botão
direito do mouse em Chaves Estrangeiras e selecione Adicionar Nova Chave Estrangeira .

2. Na caixa de texto exibida, substitua o texto ToTable por Clientes .

3. No painel T-SQL, atualize a última linha para corresponder ao exemplo a seguir:

CONSTRAINT [FK_Orders_Customers] FOREIGN KEY ([CustomerID]) REFERENCES [Customers]([CustomerID])

4. No canto superior esquerdo do Designer de Tabela , selecione Atualizar (Shift + Alt + U ).

5. Na caixa de diálogo Visualizar Atualizações de Banco de Dados, selecione Atualizar Banco de Dados .
A chave estrangeira é criada.

Popular as tabelas com dados

1. No Gerenciador de Ser vidores ou SQL Ser ver Pesquisador de Objetos , expanda o nó do banco
de dados de exemplo.
2. Abra o menu de atalho do nó Tabelas, selecione Atualizar e expanda o nó Tabelas.
3. Abra o menu de atalho da tabela Clientes e selecione Exibir Dados .
4. Adicione os dados que você quiser para alguns clientes.
É possível especificar cinco caracteres desejados como IDs de cliente, mas escolha pelo menos um do
qual é possível se lembrar para uso posteriormente neste procedimento.
5. Abra o menu de atalho da tabela Pedidos e selecione Mostrar Dados da Tabela .
6. Adicione dados para alguns pedidos. Conforme você inssira cada linha, ela é salva no banco de dados.

IMPORTANT
Certifique-se de que todas as IDs de pedido e quantidades de pedido sejam inteiros e se cada ID do cliente
corresponde a um valor especificado na coluna CustomerID da tabela Customers.

Parabéns! Agora você sabe como criar tabelas, vinculá-las a uma chave estrangeira e adicionar dados.

Confira também
Acessando dados no Visual Studio
Adicionar novas conexões
20/11/2021 • 3 minutes to read

você pode testar a conexão com um banco de dados ou serviço e explorar o conteúdo e os esquemas do banco
de dados, usando Gerenciador de Ser vidores , Cloud Explorer ou SQL Server pesquisador de objetos . A
funcionalidade dessas janelas se sobrepõe a alguma extensão. As diferenças básicas são:
Gerenciador de Servidores
Instalado por padrão no Visual Studio. pode ser usado para testar conexões e exibir SQL Server bancos
de dados, qualquer outro banco de dados que tenha um provedor de ADO.NET instalado e alguns
serviços do Azure. Também mostra objetos de baixo nível, como contadores de desempenho do sistema,
logs de eventos e filas de mensagens. se uma fonte de dados não tiver um provedor de ADO.NET, ela não
aparecerá aqui, mas você ainda poderá usá-la de Visual Studio conectando programaticamente.
Gerenciador de Nuvem
instale essa janela manualmente como uma extensão de Visual Studio do Visual Studio Marketplace.
Fornece uma funcionalidade especializada para explorar e se conectar aos serviços do Azure.
Pesquisador de Objetos do SQL Server
instalado com SQL Server Data Tools e visível no menu exibir . se você não o vir lá, vá para programas
e recursos no painel de controle, localize Visual Studio e, em seguida, selecione alterar para executar
novamente o instalador depois de marcar a caixa de seleção para SQL Server Data Tools. Use SQL
Ser ver pesquisador de objetos para exibir SQL bancos de dados (se eles tiverem um provedor de
ADO.NET), criar novos bancos de dados, modificar esquemas, criar procedimentos armazenados,
recuperar cadeias de conexão, exibir e muito mais. SQL bancos de dados que não têm um provedor de
ADO.NET instalado não aparecerão aqui, mas você ainda poderá se conectar a eles de forma
programática.

Adicionar uma conexão no Gerenciador de Servidores

Para criar uma conexão com o banco de dados, clique no ícone Adicionar conexão no Gerenciador de
ser vidores ou clique com o botão direito do mouse em Gerenciador de ser vidores no nó conexões de
dados e selecione Adicionar conexão . a partir daqui, você também pode se conectar a um banco de dados
em outro servidor, um serviço SharePoint ou um serviço do Azure.

Isso abre a caixa de diálogo Adicionar conexão . aqui, inserimos o nome da instância de LocalDB SQL Server.
Alterar o provedor
se a fonte de dados não for o que você deseja, clique no botão alterar para escolher uma nova fonte de dados
e/ou um novo provedor de dados de ADO.NET. O novo provedor pode solicitar suas credenciais, dependendo de
como você a configurou.

NOTE
se você estiver usando Visual Studio 2022 para se conectar a provedores de dados OLEDB ou ODBC, será necessário
estar ciente de que Visual Studio 2022 agora é um processo de 64 bits.
isso significa que algumas das ferramentas de dados no Visual Studio não poderão se conectar a bancos de dados OLEDB
ou ODBC usando provedores de data de 32 bits. Isso inclui o provedor de dados OLEDB de 32 bits do Microsoft Access,
bem como outros provedores de 32 bits de terceiros.
se precisar manter aplicativos de 32 bits que se conectam ao OLEDB ou ODBC, você ainda poderá compilar e executar o
aplicativo com Visual Studio 2022. no entanto, se você precisar usar qualquer uma das ferramentas de dados de Visual
Studio como Gerenciador de Servidores, assistente de fonte de dados ou o Designer de DataSet, será necessário usar uma
versão anterior do Visual Studio que ainda seja um processo de 32 bits. a última versão do Visual Studio que era um
processo de 32 bits foi Visual Studio 2019.
Se você planeja converter o projeto para ser um processo de 64 bits, precisará atualizar as conexões de dados OLEDB e
ODBC para usar provedores de dados de 64 bits.
se o seu aplicativo usa bancos de dados do microsoft Access e pode converter o projeto para 64 bits, é recomendável que
você use o Mecanismo de Banco de Dados do Microsoft access de 64 bits, também chamado de ACE (mecanismo de
conectividade de acesso). Consulte o provedor de OLE DB para Jet e driver ODBC são versões de 32 bits apenas para
obter mais informações.
Se você estiver usando um provedor de dados de terceiros, é recomendável conectar-se com seu fornecedor para ver se
eles oferecem um provedor de 64 bits antes de converter o projeto para 64 bits.
Testar a conexão
Depois de escolher a fonte de dados, clique em testar conexão . Se não tiver sucesso, será necessário
solucionar problemas com base na documentação do fornecedor.

se o teste for bem sucedido, você estará pronto para criar uma fonte de dados, que é um termo de Visual Studio
que significa realmente um modelo de dados com base no serviço ou banco subjacente.

Confira também
Ferramentas de dados do Visual Studio para .NET
Como salvar e editar cadeias de conexão
20/11/2021 • 3 minutes to read

as cadeias de conexão no Visual Studio aplicativos são salvas no arquivo de configuração do aplicativo (também
conhecido como configurações do aplicativo) ou embutidas em código diretamente em seu aplicativo. Salvar
cadeias de conexão no arquivo de configuração do aplicativo simplifica a tarefa de realizar a manutenção de seu
aplicativo. Se a cadeia de conexão precisar ser alterada, você poderá atualizá-la no arquivo de configurações do
aplicativo (em vez de alterá-la no código-fonte e recompilar o aplicativo).
O armazenamento das informações confidenciais (tal como a senha) dentro da cadeia de conexão pode afetar a
segurança do aplicativo. Cadeias de conexão salvas no arquivo de configuração do aplicativo não são
criptografadas nem ofuscadas, de modo que talvez seja possível que alguém acesse o arquivo e exiba seu
conteúdo. O uso da segurança integrada do Windows é uma maneira mais segura de controlar o acesso a um
banco de dados.
Se você optar por não usar a segurança integrada do Windows e seu banco de dados exigir um nome de
usuário e uma senha, você poderá omiti-los da cadeia de conexão, mas seu aplicativo precisará fornecer essas
informações para se conectar com êxito ao banco de dados. Por exemplo, você pode criar uma caixa de diálogo
que solicita ao usuário essas informações e compila dinamicamente a cadeia de conexão no tempo de execução.
A segurança ainda pode ser um problema se as informações forem interceptadas no caminho para o banco de
dados. Para obter mais informações, confira Protegendo informações de conexão.

Para salvar uma cadeia de conexão de dentro do assistente de

configuração da fonte de dados
No Assistente de configuração da fonte de dados , selecione a opção para salvar a conexão na página
salvar a cadeia de conexão no arquivo de configuração do aplicativo .

Para salvar uma cadeia de conexão diretamente nas configurações do

aplicativo
1. No Gerenciador de Soluções , clique duas vezes no ícone Meu Projeto (Visual Basic) ou no ícone
Propriedades (C#) para abrir o Designer de Projeto .
2. Selecione a guia Settings (Configurações).
3. Insira um Nome para a cadeia de conexão. Consulte esse nome ao acessar a cadeia de conexão no código.
4. Configure o Tipo como (Cadeia de conexão ).
5. Mantenha o Escopo configurado como Aplicativo .
6. Digite a cadeia de conexão no campo valor ou clique no botão de reticências (...) no campo valor para
abrir a caixa de diálogo Propriedades da conexão para criar a cadeia de conexão.

Editar cadeias de conexão armazenadas nas configurações do

aplicativo
Você pode modificar as informações da conexão que são salvas nas configurações do aplicativo usando o
Designer de Projeto .
Para editar uma cadeia de conexão nas configurações do aplicativo
1. No Gerenciador de Soluções , clique duas vezes no ícone Meu Projeto (Visual Basic) ou no ícone
Propriedades (C#) para abrir o Designer de Projeto .
2. Selecione a guia Settings (Configurações).
3. Localize a conexão que você deseja editar e selecione o texto no campo valor .
4. Edite a cadeia de conexão no campo valor ou clique no botão de reticências (...) no campo valor para
editar a conexão com a caixa de diálogo Propriedades da conexão .

Editar cadeias de conexão para conjuntos de os

Você pode modificar as informações de conexão para cada TableAdapter em um conjunto de dados.
Para editar uma cadeia de conexão para um TableAdapter em um DataSet
1. Em Gerenciador de soluções , clique duas vezes no conjunto de arquivos (arquivo . xsd ) que tem a
conexão que você deseja editar.
2. Selecione o TableAdapter ou a consulta que tem a conexão que você deseja editar.
3. Na janela Propriedades , expanda o nó conexão .
4. Para modificar rapidamente a cadeia de conexão, edite a propriedade ConnectionString ou clique na seta
para baixo na propriedade de conexão e escolha nova conexão .

Segurança
O armazenamento das informações confidenciais (tal como uma senha) dentro da cadeia de conexão pode
afetar a segurança do aplicativo. O uso da segurança integrada do Windows é uma maneira mais segura de
controlar o acesso a um banco de dados. Para obter mais informações, confira Protegendo informações de
conexão.

Confira também
Adicionando conexões
Conectar-se a dados em um banco de dados
20/11/2021 • 10 minutes to read

Você pode se conectar a um banco de dados do Access (um arquivo . mdb ou . accdb ) usando Visual Studio.
Depois de definir a conexão, os dados são exibidos na janela Fontes de Dados . A partir daí, você pode arrastar
tabelas ou exibições para a superfície de design.

NOTE
se estiver usando Visual Studio para se conectar aos bancos de dados do Access, você precisará estar ciente de que
versões do Visual Studio antes do Visual Studio 2022 são processos de 32 bits. isso significa que algumas das ferramentas
de dados no Visual Studio 2019 e anteriores só poderão se conectar a bancos de dados do Access usando provedores de
data de 32 bits.
se você estiver usando Visual Studio 2022 para se conectar aos bancos de dados do Access, será necessário estar ciente
de que Visual Studio 2022 agora é um processo de 64 bits. isso significa que algumas das ferramentas de dados no Visual
Studio não poderão se conectar a bancos de dados do Access usando provedores de data de 32 bits.
se precisar manter aplicativos de 32 bits que se conectam a bancos de dados do Access, você ainda poderá compilar e
executar o aplicativo com Visual Studio 2022. no entanto, se você precisar usar qualquer uma das ferramentas de dados
de Visual Studio como Gerenciador de Servidores, assistente de fonte de dados ou o Designer de DataSet, será necessário
usar uma versão anterior do Visual Studio que ainda seja um processo de 32 bits. a última versão do Visual Studio que era
um processo de 32 bits foi Visual Studio 2019.
se você planeja converter o projeto para ser um processo de 64 bits, é recomendável usar o Mecanismo de Banco de
Dados do Microsoft access de 64 bits, também chamado de ACE (mecanismo de conectividade de acesso). Consulte o
provedor de OLE DB para Jet e driver ODBC são versões de 32 bits apenas para obter mais informações.

Pré-requisitos
para usar esses procedimentos, você precisa de um projeto Windows Forms ou WPF e um banco de dados do
access (arquivo . accdb ) ou um banco de dados do access 2000-2003 (arquivo . mdb ). Siga o procedimento
correspondente ao tipo de arquivo.

Criar um conjunto de um DataSet para um arquivo. accdb

Conexão a bancos de dados criados com Microsoft 365, Access 2016, access 2013, access 2010 ou access 2007
usando o procedimento a seguir.
1. abra um projeto de aplicativo Windows Forms ou WPF no Visual Studio.
2. Para abrir a janela fontes de dados , pressione Ctrl + Q , insira "dados" na caixa de pesquisa e escolha a
janela fontes de dados . ou, no menu exibir , selecione outras > fontes de dados de Windows. Ou,
no teclado, pressione Shift + ALT + D .
3. Na janela Fontes de Dados , clique em Adicionar Nova Fonte de Dados .
O Assistente de configuração de fonte de dados é aberto.
4. Selecione banco de dados na página escolher um tipo de fonte de dado e, em seguida, selecione
Avançar .
5. Selecione DataSet na página escolher um modelo de banco de dados e, em seguida, selecione
Avançar .

6. Na página Escolha a Conexão de Dados , selecione Nova Conexão para configurar uma nova
conexão de dados.
A caixa de diálogo Adicionar conexão é aberta.
7. Se a fonte de dados não estiver definida como arquivo de banco de dado do Microsoft Access ,
selecione o botão alterar .
A caixa de diálogo Alterar fonte de dados é aberta. Na lista de fontes de dados, escolha arquivo de
banco de dado do Microsoft Access . a opção .NET Framework Provedor de Dados para OLE DB
já está selecionada. Selecione OK .
8. Escolha procurar ao lado de nome do arquivo de banco de dados e, em seguida, navegue até o
arquivo . accdb e escolha abrir .

NOTE
se o bit de bits (32 bits ou 64 bits) de Microsoft Office e Visual Studio não corresponder, você verá um erro ao
conectar-se a um banco de dados do Access. no Visual Studio 2019, você receberá um erro informando que o
provedor de banco de dados não está registrado. no Visual Studio 2022, você verá um erro informando que não é
possível se conectar a um provedor de dados de 32 bits. para resolver esse erro, certifique-se de que, se estiver
usando uma versão de 32 bits do Office, você está usando Visual Studio 2019 ou anterior; para uma versão de 64
bits do Office, você precisa Visual Studio 2022 ou posterior.

9. Insira um nome de usuário e uma senha (se necessário) e, em seguida, escolha OK .

13. Selecione as tabelas ou exibições que você deseja incluir no conjunto de seus conjuntos de seus e, em
seguida, selecione concluir .
O Conjunto de Dados é adicionado ao projeto e as tabelas e as exibições são mostradas na janela Fontes
de Dados .

Criar um conjunto de um DataSet para um arquivo. accdb

3. Na janela Fontes de Dados , clique em Adicionar Nova Fonte de Dados .

O Assistente de configuração de fonte de dados é aberto.
4. Selecione banco de dados na página escolher um tipo de fonte de dado e, em seguida, selecione
Avançar .
5. Selecione DataSet na página escolher um modelo de banco de dados e, em seguida, selecione
Avançar .
6. Na página Escolha a Conexão de Dados , selecione Nova Conexão para configurar uma nova
conexão de dados.

A caixa de diálogo Adicionar conexão é aberta.

7. Se a fonte de dados não estiver definida como arquivo de banco de dado do Microsoft Access ,
selecione o botão alterar .
A caixa de diálogo Alterar fonte de dados é aberta. Na lista de fontes de dados, escolha arquivo de
banco de dado do Microsoft Access . a opção .NET Framework Provedor de Dados para OLE DB
já está selecionada. Selecione OK .
8. Escolha procurar ao lado de nome do arquivo de banco de dados e, em seguida, navegue até o
arquivo . accdb e escolha abrir .

9. Insira um nome de usuário e uma senha (se necessário) e, em seguida, escolha OK .

10. Selecione Avançar na página escolher sua conexão de dados .
Você pode receber uma caixa de diálogo informando que o arquivo de dados não está em seu projeto
atual. Selecione Sim ou não .
11. Selecione Avançar na página salvar cadeia de conexão no arquivo de configuração do
aplicativo .
12. Expanda o nó Tabelas na página Escolher Objetos do Banco de Dados .
13. Selecione as tabelas ou exibições que você deseja incluir no conjunto de seus conjuntos de seus e, em
seguida, selecione concluir .
O Conjunto de Dados é adicionado ao projeto e as tabelas e as exibições são mostradas na janela Fontes
de Dados .

Criar um conjunto de um DataSet para um arquivo. accdb

Conexão aos bancos de dados criados com Microsoft 365, acesse 2013, acesse 2010 ou acesse 2007 usando o
procedimento a seguir.
1. abra um projeto de aplicativo Windows Forms ou WPF no Visual Studio.
2. Para abrir a janela fontes de dados , pressione Ctrl + Q , insira "dados" na caixa de pesquisa e escolha a
janela fontes de dados . ou, no menu exibir , selecione outras > fontes de dados de Windows. Ou,
no teclado, pressione Shift + Alt + D.
3. Na janela Fontes de Dados , clique em Adicionar Nova Fonte de Dados .
O Assistente de Configuração da Fonte de Dados é aberto.
4. Selecione Banco de Dados na página Escolher um Tipo de Fonte de Dados e, em seguida, selecione
Próximo.
5. Selecione Conjuntos de Dados na página Escolher um Modelo de Banco de Dados e, em seguida,
selecione Próximo.
6. Na página Escolha a Conexão de Dados , selecione Nova Conexão para configurar uma nova
conexão de dados.
A caixa de diálogo Adicionar Conexão é aberta.
7. Se Fonte de dados não estiver definida como Arquivo de Banco de Dados do Microsoft Access,
selecione o botão Alterar.
A caixa de diálogo Alterar Fonte de Dados é aberta. Na lista de fontes de dados, escolha Arquivo de
Banco de Dados do Microsoft Access. Na lista do provedor de dados, selecione .NET Framework
Provedor de Dados para OLE DB e, em seguida, escolha OK.
8. Escolha Procurar ao lado de Nome do arquivo de banco de dados e navegue até o arquivo .accdb e
escolha Abrir .
9. Insira um nome de usuário e senha (se necessário) e escolha OK.
10. Selecione Próximo na página Escolher sua Conexão de Dados.
Você pode receber uma caixa de diálogo que diz que o arquivo de dados não está em seu projeto atual.
Selecione Sim ou Não.
11. Selecione Próximo na página Salvar cadeia de conexão no arquivo configuração de aplicativo.
12. Expanda o nó Tabelas na página Escolher Objetos do Banco de Dados .
13. Selecione as tabelas ou exibições que você deseja incluir no seu conjuntos de dados e, em seguida,
selecione Concluir .
O Conjunto de Dados é adicionado ao projeto e as tabelas e as exibições são mostradas na janela Fontes
de Dados .

Criar um conjuntos de dados para um arquivo .mdb

Conexão bancos de dados criados com o Access 2000-2003 usando o procedimento a seguir.
1. Abra um projeto de Windows Forms ou WPF no Visual Studio.
2. No menu Exibir, selecione Outros Windows > Fontes de Dados .
3. Na janela Fontes de Dados , clique em Adicionar Nova Fonte de Dados .
O Assistente de Configuração da Fonte de Dados é aberto.
4. Selecione Banco de Dados na página Escolher um Tipo de Fonte de Dados e, em seguida, selecione
Próximo.
5. Selecione Conjuntos de Dados na página Escolher um Modelo de Banco de Dados e, em seguida,
selecione Próximo.
6. Na página Escolha a Conexão de Dados , selecione Nova Conexão para configurar uma nova
conexão de dados.
7. Se a fonte de dados não for o Arquivo de Banco de Dados do Microsoft Access (OLE DB), selecione
Alterar para abrir a caixa de diálogo Alterar Fonte de Dados e selecione Arquivo de Banco de Dados do
Microsoft Access e, em seguida, selecione OK .
8. No Nome do arquivo de banco de dados , especifique o caminho e o nome do arquivo .mdb ao qual
você deseja se conectar e selecione OK.
9. Selecione Próximo na página Escolher sua Conexão de Dados.
10. Selecione Próximo na página Salvar cadeia de conexão no arquivo configuração de aplicativo.
11. Expanda o nó Tabelas na página Escolher Objetos do Banco de Dados .
12. Selecione as tabelas ou exibições que você deseja no seu conjuntos de dados e, em seguida, selecione
Concluir .
O Conjunto de Dados é adicionado ao projeto e as tabelas e as exibições são mostradas na janela Fontes
de Dados .

Próximas etapas
O conjuntos de dados que você acabou de criar está disponível na janela Fontes de Dados. Agora é possível
realizar qualquer uma das seguintes tarefas:
Selecione itens na janela Fontes de Dados e arraste-os para o formulário ou a superfície de design
(consulte Vincular controles do Windows Forms aos dados na visão geral Visual Studio associação de
dados do WPF ou do WPF).
Abra a fonte de dados no Designer de Conjunto de Dados para adicionar ou editar os objetos que
constituem o conjunto de dados.
Adicione a lógica de validação ao evento ou das tabelas de dados no conjunto de dados
ColumnChanging RowChanging (consulte Validar dados em conjuntos de dados).

Confira também
Adicionar conexões
Visão geral da associação de dados do WPF
Windows Associação de dados de formulários
Adicionar novas fontes de dados
20/11/2021 • 6 minutes to read

NOTE
Os recursos descritos neste artigo se aplicam ao .NET Framework Windows Forms e ao desenvolvimento do WPF. Os
recursos não têm suporte para o desenvolvimento do .NET Core, tanto para WPF quanto para Windows Forms.

No contexto das ferramentas de dados do .NET no Visual Studio, o termo fonte de dados refere-se a objetos
.NET que se conectam a um armazenamento de dados e disponibilizam os dados para um aplicativo .NET. Os
Visual Studio designers podem consumir a saída da fonte de dados para gerar o código clichê que vincula os
dados aos formulários quando você arrasta e solta objetos de banco de dados da janela Fontes de Dados. Esse
tipo de fonte de dados pode ser:
Uma classe em um Entity Framework que está associado a algum tipo de banco de dados.
Um conjuntos de dados associado a algum tipo de banco de dados.
Uma classe que representa um serviço de rede, como um serviço de dados Windows Communication
Foundation (WCF) ou um serviço REST.
Uma classe que representa um SharePoint serviço.
Uma classe ou coleção em sua solução.

NOTE
Se você não estiver usando recursos de associação de dados, conjuntos de dados, Entity Framework, LINQ to SQL, WCF
ou SharePoint, o conceito de uma "fonte de dados" não se aplicará. Basta conectar-se diretamente ao banco de dados
usando os objetos SQLCommand e comunicar-se diretamente com o banco de dados.

Você cria e edita fontes de dados usando o Assistente de Configuração de Fonte de Dados em um Windows
Forms ou Windows Presentation Foundation aplicativo. Por Entity Framework, primeiro crie suas classes de
entidade e inicie o assistente selecionando Project Adicionar Nova Fonte de Dados (descrito em mais detalhes
posteriormente > neste artigo).
janela Fontes de Dados
Depois de criar uma fonte de dados, ela aparecerá na janela de ferramentas Fontes de Dados.

TIP
Para abrir a janela Fontes de Dados, certifique-se de que seu projeto está aberto e pressione Shift Alt D ou escolha
Exibir Outros Windows + + Fontes > > de Dados .

Você pode arrastar uma fonte de dados da janela Fontes de Dados para uma superfície de design de formulário
ou controle. Isso faz com que o código clichê seja gerado que exibe os dados do armazenamento de dados.
A ilustração a seguir mostra um conjuntos de dados que foi descartado em um formulário Windows dados. Se
você selecionar F5 no aplicativo, os dados do banco de dados subjacente aparecerão nos controles do
formulário.

Fonte de dados para um banco de dados ou um arquivo de banco de

dados
Você pode criar um modelo de Entity Framework de dados a ser usado como uma fonte de dados para um
banco de dados ou arquivo de banco de dados.
Conjunto de dados
Para criar um conjuntos de dados como uma fonte de dados, execute o Assistente de Configuração da Fonte de
Dados selecionando Project > Adicionar Nova Fonte de Dados . Escolha o tipo de fonte de dados banco de
dados e siga os prompts para especificar uma conexão de banco de dados nova ou existente ou um arquivo de
banco de dados.
Classes de entidade
Para criar um modelo Entity Framework como uma fonte de dados:
1. Execute o assistente Modelo de Dados de Entidade para criar as classes de entidade. Selecione
Project > Adicionar Novo Item > ADO.NET Modelo de Dados de Entidade .
2. Escolha o método pelo qual você deseja gerar o modelo.

3. Adicione o modelo como uma fonte de dados. As classes geradas aparecem no Assistente de
Configuração da Fonte de Dados quando você escolhe a categoria Objetos.

Fonte de dados para um serviço

Para criar uma fonte de dados de um serviço, execute o Assistente de Configuração da Fonte de Dados e escolha
o tipo de fonte de dados de serviço. Este é apenas um atalho para a Adicionar Referência de Ser viço caixa
de diálogo, que você também pode acessar clicando com o botão direito do mouse no projeto no Gerenciador
de Soluções e selecionando Adicionar referência de ser viço .
Quando você cria uma fonte de dados de um serviço, Visual Studio adiciona uma referência de serviço ao seu
projeto. Visual Studio também cria objetos proxy que correspondem aos objetos que o serviço retorna. Por
exemplo, um serviço que retorna um conjuntos de dados é representado em seu projeto como um conjuntos de
dados; um serviço que retorna um tipo específico é representado em seu projeto como o tipo retornado.
Você pode criar uma fonte de dados com os seguintes tipos de serviços:
WCF Data Services
Serviços WCF
Serviços da Web
NOTE
Os itens que aparecem na janela Fontes de Dados dependem dos dados que o serviço retorna. Alguns serviços
podem não fornecer informações suficientes para o Assistente de Configuração de Fonte de Dados criar
objetos associáveis. Por exemplo, se o serviço retornar um conjuntos de dados sem tipo, nenhum item aparecerá
na janela Fontes de Dados quando você concluir o assistente. Isso acontece porque conjuntos de dados sem tipo
não fornecem um esquema e, portanto, o assistente não tem informações suficientes para criar a fonte de dados.

Fonte de dados para um objeto

Você pode criar uma fonte de dados de qualquer objeto que expõe uma ou mais propriedades públicas
executando o Assistente de Configuração da Fonte de Dados e selecionando o tipo de fonte de dados Object.
Todas as propriedades públicas de um objeto são exibidas na janela Fontes de Dados. Se você estiver usando
Entity Framework e tiver gerado um modelo, será aqui que você encontrará as classes de entidade que são as
fontes de dados para seu aplicativo.
Na página Selecionar os Objetos de Dados, expanda os nós no exibição de árvore para localizar os objetos
aos que você deseja se vincular. A exibição de árvore contém nós para seu projeto e para assemblies e outros
projetos que são referenciados pelo seu projeto.
Se você quiser se vincular a um objeto em um assembly ou projeto que não aparece no exibição de árvore,
clique em Adicionar Referência e use a Caixa de Diálogo Adicionar Referência para adicionar uma referência ao
assembly ou projeto. Depois de adicionar a referência, o assembly ou o projeto é adicionado ao exibição de
árvore.

NOTE
Talvez seja necessário criar o projeto que contém seus objetos antes que os objetos apareçam no exibição de árvore.

NOTE
Para dar suporte à associação de dados do tipo "arrastar e soltar", os objetos que implementam ITypedList a interface ou
devem ter um construtor IListSource padrão. Caso contrário, Visual Studio não pode criar uma inciação do objeto de fonte
de dados e exibe um erro quando você arrasta o item para a superfície de design.

Fonte de dados para uma lista SharePoint dados

Você pode criar uma fonte de dados de SharePoint lista executando o Assistente de Configuração da Fonte de
Dados e selecionando o tipo SharePoint fonte de dados. SharePoint expõe dados por meio WCF Data Services,
portanto, criar uma fonte de dados SharePoint é o mesmo que criar uma fonte de dados de um serviço.
Selecionar o item SharePoint no Assistente de Configuração da Fonte de Dados abre a caixa de diálogo
Adicionar Referência de Ser viço, em que você se conecta ao serviço de dados SharePoint apontando para o
servidor SharePoint. Isso requer o SharePoint SDK.

Confira também
Ferramentas de dados do Visual Studio para .NET
Ferramentas do LINQ to SQL no Visual Studio
20/11/2021 • 6 minutes to read

LINQ to SQL foi a primeira tecnologia de mapeamento relacional de objeto lançada pela Microsoft. ele funciona
bem em cenários básicos e continua a ter suporte no Visual Studio, mas não está mais sob o desenvolvimento
ativo. use LINQ to SQL ao manter um aplicativo herdado que já o esteja usando, ou em aplicativos simples que
usam SQL Server e não exigem mapeamento de várias tabelas. Em geral, novos aplicativos devem usar o Entity
Framework quando uma camada de mapeador relacional de objeto é necessária.

instalar as ferramentas de LINQ to SQL

no Visual Studio, você cria LINQ to SQL classes que representam SQL tabelas usando o Object Relational
Designer (o /R Designer ). O o/R Designer é a interface do usuário para edição de arquivos. dbml. a edição de
arquivos. dbml com uma superfície de designer requer as ferramentas de LINQ to SQL que não são instaladas
por padrão como parte de qualquer uma das cargas de trabalho do Visual Studio.
para instalar as ferramentas de LINQ to SQL, inicie o instalador do Visual Studio, escolha modificar , selecione a
guia componentes individuais e, em seguida, selecione LINQ to SQL ferramentas na categoria
ferramentas de código .

O que é o o/R Designer

O o /R Designer tem duas áreas distintas em sua superfície de design: o painel entidades à esquerda e o painel
métodos à direita. O painel das entidades é a principal superfície de design que exibe as classes de entidade, as
associações, e hierarquias de herança. O painel de métodos é a superfície de design que exibe os métodos do
DataContext que são mapeados para os procedimentos armazenados e as funções.
o o /R Designer fornece uma superfície de design visual para criar LINQ to SQL classes de entidade e
associações (relações) que se baseiam em objetos em um banco de dados. Em outras palavras, o /R Designer
cria um modelo de objeto em um aplicativo que mapeia para objetos em um banco de dados. Ele também gera
um tipo fortemente tipado DataContext que envia e recebe dados entre as classes de entidade e o banco de
dado. O o /R Designer também fornece funcionalidade para mapear procedimentos armazenados e funções
para DataContext métodos de retorno de dados e preenchimento de classes de entidade. Por fim, o o /R
Designer fornece a capacidade de projetar relações de herança entre classes de entidade.

Abrir o o/R Designer

para adicionar um modelo de entidade LINQ to SQL ao seu projeto, escolha Project > adicionar novo Item e,
em seguida, selecione LINQ to SQL Classes na lista de itens de projeto:
Visual Studio cria um arquivo . dbml e o adiciona à sua solução. Este é o arquivo de mapeamento XML e seus
arquivos de código relacionados.

quando você seleciona o arquivo . dbml , Visual Studio mostra a superfície o/R Designer que permite criar
visualmente o modelo. A ilustração a seguir mostra o designer depois que a Northwind Customers e as Orders
tabelas foram arrastadas de Gerenciador de ser vidores . Observe a relação entre as tabelas.
IMPORTANT
O o /R Designer é um mapeador relacional de objeto simples, pois dá suporte apenas a relações de mapeamento 1:1.
Em outras palavras, uma classe de entidade pode ter apenas uma relação de mapeamento de 1:1 com uma tabela ou
exibição de banco de dados. Não há suporte para mapeamento complexo, como mapear uma classe de entidade para
uma tabela unida; Use o Entity Framework para mapeamento complexo. Além disso, o designer é um gerador de código
unidirecional. Isso significa que somente as alterações feitas à superfície de designer são refletidas no arquivo de código.
As alterações manuais no arquivo de código não são refletidas no designer o/R. As alterações feitas manualmente no
arquivo de código são substituídas quando o designer é salvo e o código é regenerado. Para obter informações sobre
como adicionar código de usuário e estender as classes geradas pela Relational Designer , consulte como: Estender o
código gerado pelo Designer Relacional de Objetos.

Criar e configurar o DataContext

depois de adicionar um item de Classes de LINQ to SQL a um projeto e abrir o o /R Designer , a superfície
de design vazia representa um vazio DataContext pronto para ser configurado. O DataContext é configurado
com as informações de conexão fornecidas pelo primeiro item que é arrastado para a superfície de design.
Portanto, o DataContext é configurado usando as informações de conexão do primeiro item solto na superfície
de design. Para obter mais informações sobre a DataContext classe, consulte métodos DataContext (o/R
Designer).

Criar classes de entidade que são mapeadas para exibições e tabelas

de banco de dados
Você pode criar classes de entidade mapeadas para tabelas e exibições arrastando tabelas e exibições de banco
de dados de Gerenciador de ser vidores ou Gerenciador de banco de dados para o o /R Designer .
Conforme indicado na seção anterior, o DataContext é configurado com as informações de conexão fornecidas
pelo primeiro item que é arrastado para a superfície de design. Se um item subsequente que usa uma conexão
diferente for adicionado ao o /R Designer , você poderá alterar a conexão para o DataContext . para obter mais
informações, consulte como: criar classes de LINQ to SQL mapeadas para tabelas e exibições (O/R Designer).

Criar métodos DataContext que chamam procedimentos e funções

armazenados
Você pode criar DataContext métodos que chamam (são mapeados para) procedimentos armazenados e
funções arrastando-os de Gerenciador de Ser vidores ou Gerenciador de banco de dados para o o /R
Designer . Os procedimentos armazenados e funções são adicionados ao o /R Designer como métodos do
DataContext .

NOTE
Quando você arrasta procedimentos armazenados e funções de Gerenciador de ser vidores ou Gerenciador de
banco de dados para o o /R Designer , o tipo de retorno do DataContext método gerado difere dependendo de onde
você solta o item. Para obter mais informações, consulte métodos DataContext (O/R Designer).

Configurar um DataContext para usar procedimentos armazenados a

fim de salvar dados entre classes de entidade e um banco de dados
Conforme observado anteriormente, você pode criar os métodos de DataContext que chamam procedimentos
armazenados e funções. além disso, você também pode atribuir procedimentos armazenados que são usados
para o comportamento padrão LINQ to SQL tempo de execução, que executa inserções, atualizações e
exclusões. Para obter mais informações, consulte como: atribuir procedimentos armazenados para executar
atualizações, inserções e exclusões (O/R Designer).

Herança e Designer Relacional de Objetos

assim como outros objetos, LINQ to SQL classes podem usar a herança e serem derivadas de outras classes. Em
uma base de dados, as relações de herança são criadas de várias maneiras. O o /R Designer dá suporte ao
conceito de herança de tabela única, pois ela geralmente é implementada em sistemas relacionais. Para obter
mais informações, consulte como: configurar a herança usando o o/R Designer.

Consultas do LINQ to SQL

As classes de entidade criadas pelo o /R Designer são projetadas para uso com LINQ (consulta integrada à
linguagem). Para obter mais informações, consulte como consultar informações.

Separar o DataContext gerado e o código de classe de entidade em

namespaces diferentes
O o /R Designer fornece as propriedades de namespace de contexto e de namespace de entidade no
DataContext . Essas propriedades que determinam o namespace DataContext e o código de classe de entidade
são gerados. Por padrão, essas propriedades são vazios e DataContext e classes de entidade são gerados no
namespace do aplicativo. Para gerar código em um namespace diferente do namespace do aplicativo, insira um
valor nas propriedades do Namespace do Contexto e/ou do Namespace da Entidade .

Conteúdo de referência
System.Linq
System.Data.Linq

Confira também
LINQ to SQL (.NET Framework)
Perguntas frequentes (.NET Framework)
Como alterar o tipo de retorno de um método
DataContext (Designer Relacional de Objetos)
20/11/2021 • 2 minutes to read

O tipo de retorno de um método (criado com base em um procedimento armazenado ou função) é diferente
dependendo de onde você solta o procedimento armazenado ou a função no DataContext Designer de O/R.
Se você soltar um item diretamente em uma classe existente de entidade, um método de DataContext que tem o
tipo de retorno de classe de entidade é criado (se o esquema dos dados retornados por correspondências
armazenadas do procedimento ou função a forma de classe de entidade). Se você soltar um item em uma área
vazia do Designer O/R, um método que retorna um tipo DataContext gerado automaticamente será criado.
Você pode alterar o tipo de retorno de um método de DataContext depois de adicioná-lo ao painel de métodos.
Verificar ou altere o tipo de retorno de um método de DataContext, selecione-o e clique na propriedade de Tipo
de Retorno na janela Propriedades .

NOTE
Você não pode reverter os métodos de DataContext que tem um tipo de retorno definida como uma classe de entidade
para retornar o tipo gerado automaticamente usando a janela Propriedades . Para reverter um método para retornar um
tipo gerado automaticamente, arraste o objeto de banco de dados original para o DataContext Designer de Objetos
novamente.

Para alterar o tipo de retorno de um método DataContext do tipo

gerado automaticamente a uma entidade
1. Selecione o método de DataContext no painel de métodos.
2. Selecione Tipo de Retorno na janela Propriedades e então selecione uma classe de entidade
disponível na lista de Tipo de Retorno . Se a classe de entidade desejada não estiver na lista, adicione-a
ou crie-a no Designer O/R para adicioná-la à lista.
3. Salve o arquivo .dbml.

Para alterar o tipo de retorno de um método DataContext de uma

classe de entidade de volta para o tipo gerado automaticamente
1. Selecione o DataContext método no painel Métodos e exclua-o.
2. Arraste o objeto de banco de Gerenciador de Ser vidores ou Gerenciador de Banco de Dados para
uma área vazia do Designer O/R.
3. Salve o arquivo .dbml.
Confira também
LINQ to SQL ferramentas no Visual Studio
LINQ to SQL
Métodos DataContext (Designer O/R)
Como criar métodos DataContext mapeados para procedimentos armazenados e funções (Designer
Relacional de Objetos)
Como criar métodos DataContext mapeados para
procedimentos armazenados e funções (Designer
Relacional de Objetos)
20/11/2021 • 2 minutes to read

Você pode adicionar procedimentos armazenados e funções ao o /R Designer como DataContext métodos.
Chamar o método e passar os parâmetros necessários leva à execução do procedimento ou da função
armazenada no banco de dados e ao retorno dos dados no tipo de retorno do método DataContext. Para obter
informações detalhadas sobre DataContext métodos, consulte métodos DataContext (O/R Designer).

NOTE
Você também pode usar procedimentos armazenados para substituir o LINQ to SQL comportamento de tempo de
execução padrão que executa inserções, atualizações e exclusões quando as alterações são salvas de classes de entidade
em um banco de dados. Para obter mais informações, consulte como: atribuir procedimentos armazenados para executar
atualizações, inserções e exclusões (O/R Designer).

Criar métodos DataContext

Você pode criar DataContext métodos arrastando procedimentos armazenados ou funções de Gerenciador de
ser vidores ou * * Gerenciador de banco de dados para o o /R Designer .

NOTE
O tipo de retorno do DataContext método gerado difere dependendo de onde você remove o procedimento armazenado
ou a função no designer o/R. Soltar itens diretamente em uma classe de entidade existente cria um método
DataContext com o tipo de retorno da classe de entidade. Soltar itens em uma área vazia do o /R Designer cria um
DataContext método que retorna um tipo gerado automaticamente. Você pode alterar o tipo de retorno de um método
DataContext após adicioná-lo ao painel Métodos . Para inspecionar ou alterar o tipo de retorno de um método
DataContext, selecione-o e inspecione a propriedade Tipo de Retorno na janela Propriedades . Para obter mais
informações, consulte como alterar o tipo de retorno de um método DataContext (O/R Designer).

Para criar métodos DataContext que retornam tipos gerados automaticamente

1. Em Gerenciador de ser vidores ou Gerenciador de banco de dados , expanda o nó
procedimentos armazenados do banco de dados com o qual você está trabalhando.
2. Localize o procedimento armazenado desejado e arraste-o para uma área vazia do o /R Designer .
O método DataContext é criado com um tipo de retorno gerado automaticamente e aparece no painel
Métodos .
Para criar métodos DataContext com o tipo de retorno de uma classe de entidade
1. Em Gerenciador de ser vidores ou Gerenciador de banco de dados , expanda o nó
procedimentos armazenados do banco de dados com o qual você está trabalhando.
2. Localize o procedimento armazenado desejado e arraste-o para uma classe de entidade existente no o /R
Designer .
O método DataContext é criado com o tipo de retorno da classe de entidade selecionada e aparece no
painel Métodos .

NOTE
Para obter informações sobre como alterar o tipo de retorno de existentes DataContext métodos, consulte como: Alterar
o tipo de retorno de um método DataContext (Designer Relacional de Objetos).

Confira também
ferramentas de LINQ to SQL no Visual Studio
Métodos DataContext (O/R Designer)
Walkthrough: criando classes de LINQ to SQL
LINQ to SQL
Introdução a LINQ no Visual Basic
LINQ em C#
Como configurar a herança usando o Designer
Relacional de Objetos
20/11/2021 • 3 minutes to read

O Object Relational Designer (Designer O/R ) dá suporte ao conceito de herança de tabela única, pois
geralmente é implementado em sistemas relacionais. Na herança de tabela única, há uma única tabela de banco
de dados que contém campos para informações pai e informações filho. Com os dados relacionais, uma coluna
de discriminador contém o valor que determina qual classe qualquer registro pertence.
Por exemplo, considere uma Persons tabela que contém todos os funcionários de uma empresa. Algumas
pessoas são funcionários e algumas pessoas são gerentes. A tabela contém uma coluna chamada que tem um
valor de 1 para gerentes e um valor de 2 para Persons EmployeeType funcionários; essa é a coluna
discriminadora. Nesse cenário, você pode criar uma subclasse de funcionários e preencher a classe com apenas
os registros que têm um valor de EmployeeType de 2. Você pode também remover colunas que não se aplicam
de cada uma das classes.
Criar um modelo de objeto que usar herança (e corresponde a dados relacionais) pode ser um pouco confuso. O
procedimento a seguir descreve as etapas necessárias para configurar a herança com o Designer de O/R.
Seguir etapas genéricas sem se referir a uma tabela e colunas existentes pode ser difícil, portanto, um passo a
passo que usa dados é fornecido. Para instruções passo a passo detalhadas para configurar a herança usando o
Relational Designer , consulte passo a passo: Criando o LINQ to SQL classes por meio de herança de tabela
única (O/R Designer).

Para criar classes de dados herdadas

1. Abra o Designer O/R adicionando um item classes LINQ to SQL a um projeto Visual Basic ou C#
existente.
2. Arraste a tabela que você deseja usar como a classe base para o Designer O/R.
3. Arraste uma segunda cópia da tabela para o Designer de O/R e renomeie-a. Esta é a classe derivada,
ou subclasse.
4. Clique na guia Herança no Object Relational Designer da Caixa de Ferramentas e em seguida,
clique na subclasse (a tabela que você renomeou) e conecta-se a classe base.

NOTE
Clique no item de Herança em Caixa de Ferramentas e solte o botão do mouse, clique na segunda cópia de
classe que você criou na etapa 3 e depois clique na primeira classe que você criou na etapa 2. A seta na linha de
herança aponta para a primeira classe.

5. Em cada classe, excluir todas as propriedades do objeto que você não deseja que apareça e que não são
usadas para associações. Você receberá um erro se tentar excluir propriedades de objeto usadas para
associações: a propriedade não pode ser excluída porque está participando <property name> da
associação <association name> .
NOTE
Como uma classe derivada herda as propriedades definidas na sua classe base, as mesmas colunas não podem ser
definidas em cada classe. (As colunas são implementadas como propriedades.) Você pode habilitar a criação de
colunas na classe derivada definindo o modificador de herança na propriedade na classe base. Para obter mais
informações, consulte Noções básicas de herança (Visual Basic).

6. Selecione a linha de herança no Designer de O/R.

7. Na janela Propriedades, de definir a Propriedade Discriminadora como o nome da coluna que
distingue os registros em suas classes.
8. Defina a propriedade Valor Discriminatório da Classe Derivada para o valor no banco de dados que
designa o registro como o tipo herdado. (Esse é o valor armazenado na coluna discriminadora e é usado
para designar a classe herdada.)
9. De definir a propriedade Valor discriminador de classe base como o valor que designa o registro
como um tipo base. (Esse é o valor armazenado na coluna discriminadora e é usado para designar a
classe base.)
10. Opcionalmente, você pode também definir a propriedade de Padrão de Herança para designar um tipo
em uma hierarquia de herança que é usada para carregar as linhas que não correspondem nenhum
código de herança definido. Em outras palavras, se um registro tiver um valor em sua coluna
discriminadora que não corresponder ao valor nas propriedades Valor Discriminador de Classe Derivada
ou Valor Discriminador de Classe Base, o registro será carregado no tipo designado como Padrão de
Herança.

Confira também
LINQ to SQL ferramentas no Visual Studio
Passo a passo: criando classes LINQ to SQL (Designer Relacional de Objetos)
Acessando dados em Visual Studio
LINQ to SQL
Passo a passo: criando LINQ to SQL classes usando herança de tabela única (Designer O/R)
Noções básicas de herança (Visual Basic)
Herança
Como criar classes LINQ to SQL mapeadas para
tabelas e exibições (Designer Relacional de Objetos)
20/11/2021 • 3 minutes to read

LINQ to SQL classes mapeadas para tabelas e exibições de banco de dados são chamadas de classes de
entidade. A classe de entidade mapeia para um registro, enquanto as propriedades individuais de uma classe de
entidade são mapeadas para as colunas individuais que compoem um registro. Crie classes de entidade
baseadas em tabelas ou exibições de banco de dados arrastando tabelas ou exibições de Gerenciador de
Servidores ou Gerenciador de Banco de Dados para as ferramentas LINQ to SQL no Visual Studio. O
Designer de O/R gera as classes e aplica os atributos específicos para habilitar a funcionalidade (os recursos
de comunicação e edição de LINQ to SQL LINQ to SQL dados do DataContext ). Para obter informações
detalhadas sobre LINQ to SQL classes, consulte The LINQ to SQL object model.

NOTE
O Designer relacional O/R é um mapeado relacional de objeto simples porque dá suporte apenas a relações de
mapeamento 1:1. Em outras palavras, uma classe de entidade pode ter apenas uma relação de mapeamento de 1:1 com
uma tabela ou exibição de banco de dados. O mapeamento complexo, como o mapeamento de uma classe de entidade
para várias tabelas, não tem suporte. No entanto, você pode mapear uma classe de entidade para uma exibição que une
várias tabelas relacionadas.

Criar classes LINQ to SQL que são mapeadas para tabelas ou

exibições de banco de dados
Arrastar tabelas ou exibições de Gerenciador de Ser vidores ou Gerenciador de Banco de Dados para o
Designer O/R cria classes de entidade, além dos métodos usados para executar DataContext atualizações.
Por padrão, o runtime do LINQ to SQL cria a lógica para salvar alterações de uma classe de entidade atualizável
de volta para o banco de dados. Essa lógica é baseada no esquema da tabela (as definições de coluna e
informações de chave primária). Se você não quiser esse comportamento, poderá configurar uma classe de
entidade para usar procedimentos armazenados para executar inserções, atualizações e exclusões em vez de
usar o comportamento de tempo de execução LINQ to SQL padrão. Para obter mais informações, consulte
Como atribuir procedimentos armazenados para executar atualizações, inserções e exclusões (Designer O/R).

Para criar classes LINQ to SQL que são mapeadas para tabelas ou exibições de banco de dados
1. No Ser vidor /Gerenciador de Banco de Dados , expanda Tabelas ou Modos de exibição e localize a
tabela ou exibição de banco de dados que você quer usar em seu aplicativo.
2. Arraste a tabela ou a exibição para o Designer de O/R.
Uma classe de entidade é criada e aparece na superfície de design. A classe de entidade tem propriedades
que mapeiam para as colunas na tabela ou exibição selecionada.
Crie um objeto de fonte de dados e exiba os dados em um formulário
Depois de criar classes de entidade usando o Designer de Objetos , você pode criar uma fonte de dados de
objeto e preencher a janela Fontes de Dados com as classes de entidade.
Para criar uma fonte de dados de objeto com base nas classes de entidade do LINQ to SQL
1. No menu Compilar , clique em Compilar Solução para criar o seu projeto.
2. Para abrir a janela Fontes de Dados, no menu Dados, clique em Mostrar Fontes de Dados .
3. Na janela Fontes de Dados , clique em Adicionar Nova Fonte de Dados .
4. Clique em Objeto na página Escolher um Tipo de Fonte de Dados e clique em Avançar .
5. Expanda os nós e localize e selecione sua classe.

NOTE
Se a classe Customer não estiver disponível, cancele o assistente, compile o projeto e execute o assistente
novamente.

6. Clique em Concluir para criar a fonte de dados e adicionar a classe de entidade Customer à janela
Fontes de Dados .
7. Arraste itens da janela de Fontes de Dados para um formulário.

Confira também
LINQ to SQL ferramentas no Visual Studio
Passo a passo: criando classes LINQ to SQL (Designer Relacional de Objetos)
Métodos DataContext (Designer O/R)
Como criar métodos DataContext mapeados para procedimentos armazenados e funções (Designer
Relacional de Objetos)
O LINQ to SQL modelo de objeto
Passo a passo: personalizando a inserção, a atualização e o comportamento de exclusão de classes de
entidade
Como criar uma associação (relação) entre classes LINQ to SQL (Designer Relacional de Objetos)
Como estender o código gerado pelo Designer
Relacional de Objetos
20/11/2021 • 2 minutes to read

O código gerado pelo Designer O/R é regenerado quando são feitas alterações nas classes de entidade e em
outros objetos na superfície do designer. Devido a essa regeneração de código, qualquer código que você
adicionar ao código gerado seja substituído normalmente quando o código de regenerados de designer. O
Designer de O/R fornece a capacidade de gerar arquivos de classe parciais nos quais você pode adicionar
código que não é substituído. Um exemplo de como adicionar seu próprio código ao código gerado pelo
Designer O/R é adicionar validação de dados a LINQ to SQL classes (entidade). Para obter mais informações,
consulte Como adicionar validação a classes de entidade.

Adicionar código a uma classe de entidade

Para criar uma classe parcial e adicione o código para uma classe de entidade
1. Abra ou crie um novo arquivo LINQ to SQL Classes (arquivo .dbml) no Designer O/R. (Clique duas
vezes no arquivo .dbml Gerenciador de Soluções ou Gerenciador de Banco de Dados .)
2. No Designer Relacional de Objetos , clique com o botão direito do mouse na classe para qual você
deseja adicionar validação e clique em Exibir Código .
O editor de códigos abre com uma classe parcial para a classe de entidade selecionada.
3. Adicione o código na declaração de classe parcial para a classe de entidade.

Adicionar código a um DataContext

Para criar uma classe parcial e adicione o código a um DataContext
1. Abra ou crie um novo arquivo LINQ to SQL Classes (arquivo .dbml) no Designer O/R. (Clique duas
vezes no arquivo .dbml Gerenciador de Soluções ou Gerenciador de Banco de Dados .)
2. No Designer de O/R , clique com o botão direito do mouse em uma área vazia no designer e clique em
Exibir Código .
O editor de códigos abre com uma classe parcial para o DataContext.
3. Adicione o código na declaração de classe parcial para o DataContext.

Confira também
LINQ to SQL ferramentas no Visual Studio
Passo a passo: criando classes LINQ to SQL (Designer Relacional de Objetos)
LINQ to SQL
Como criar uma associação entre classes LINQ to
SQL (Designer O/R)
20/11/2021 • 2 minutes to read

As associações entre classes de entidade no LINQ to SQL são análogas às relações entre tabelas em um banco
de dados. Você pode criar associações entre classes de entidade usando a caixa de diálogo Editor de
Associação .
Você deve selecionar uma classe pai e uma classe filho ao usar a caixa de diálogo Editor de Associação para
criar uma associação. A classe pai é a classe de entidade que contém a chave primária; a classe filho é a classe de
entidade que contém a chave estrangeira. Por exemplo, se classes de entidade fossem criadas que mapeiam
para as tabelas e , a classe seria a classe pai e a classe Northwind Customers Orders seria a classe Customer
Order filho.

NOTE
Quando você arrasta tabelas de Gerenciador de Ser vidores ou Gerenciador de Banco de Dados para o Object
Relational Designer (Designer O/R), as associações são criadas automaticamente com base nas relações de chave
estrangeira existentes no banco de dados.

Propriedades de associação
Depois de criar uma associação, quando você seleciona a associação no Designer Relacional de Objetos , há
algumas propriedades configuráveis na janela Propriedades . (A associação é a linha entre as classes
relacionadas.) A tabela a seguir fornece descrições para as propriedades de uma associação.

P RO P RIEDA DE DESC RIÇ Ã O

Cardinalidade Controla se a associação é de um-para-muitos ou um-para-

um.

Propriedade Filho Especifica se deve ser criada uma propriedade no pai que é
uma coleção ou referência para os registros filho na parte da
chave estrangeira da associação. Por exemplo, na associação
entre e , se a Propriedade Filho estiver definida como True ,
uma propriedade chamada será Customer Order criada
na classe Orders pai.

Propriedade Pai A propriedade na classe filho que referencia a classe pai

associada. Por exemplo, na associação entre e , uma
propriedade chamada que faz referência ao cliente associado
para um pedido é Customer Order criada na classe
Customer Order .

Propriedades par ticipantes Exibe as propriedades de associação e fornece um botão de

reticências (...) que reabre a caixa de diálogo Editor de
Associação .

Exclusivo Especifica se as colunas de destino estrangeiras têm uma

restrição de exclusividade.
Para criar uma associação entre classes de entidade
1. Clique com o botão direito do mouse na classe de entidade que representa a classe pai na associação,
aponte-a para Adicionar e clique em Associação .
2. Verifique se a Classe Pai correta está selecionada na caixa de diálogo Editor de Associação .
3. Selecione a Classe Filho na caixa de combinação.
4. Selecione as Propriedades de Associação que relacionam as classes. Geralmente, isso mapeia para a
relação de chave estrangeira definida no banco de dados. Por exemplo, na associação Customers e , as
Propriedades de Orders Associação são o para CustomerID cada classe.
5. Clique em OK para criar a associação.

Confira também
LINQ to SQL ferramentas no Visual Studio
Passo a passo: criando LINQ to SQL classes
LINQ to SQL
Métodos DataContext (Designer O/R)
Como representar chaves primárias
Como adicionar validação a classes de entidade
20/11/2021 • 4 minutes to read

Validar classes de entidade é o processo que confirma que os valores inseridos em objetos de dados estão de
acordo com as restrições do esquema de um objeto e também as regras estabelecidas para o aplicativo. Validar
dados antes de enviar atualizações para o base de dados subjacente é uma boa prática que reduz erros. Também
reduz o número potencial de processamentos entre um aplicativo e o base de dados.
As ferramentas LINQ to SQL no Visual Studio fornece métodos parciais que permitem aos usuários estender o
código gerado pelo designer que é executado durante inserções, atualizações e exclusões de entidades
completas e também durante e após alterações de coluna individuais.

NOTE
Este tópico fornece as etapas básicas para adicionar validação a classes de entidade usando o Designer O/R. Como pode
ser difícil seguir essas etapas genéricas sem se referir a uma classe de entidade específica, um passo a passo que usa
dados reais é fornecido.

Adicionar validação para alterações ao valor em uma coluna específica

Este procedimento mostra como validar dados quando o valor em uma coluna é alterado. Uma vez que a
validação é executada na definição de classe (em vez de na interface do usuário), será lançada uma exceção se o
valor causar a falha da validação. Implementar manipulação de erro para o código em seu aplicativo que tenta
alterar os valores de coluna.

Para validar dados durante o valor de uma coluna alterar

1. Abra ou crie um novo arquivo LINQ to SQL Classes (arquivo .dbml) no Designer O/R. (Clique
duas vezes no arquivo .dbml em Gerenciador de Soluções .)
2. No Designer Relacional de Objetos , clique com o botão direito do mouse na classe para qual você
deseja adicionar validação e clique em Exibir Código .
O editor de códigos abre com uma classe parcial para a classe de entidade selecionada.
3. Coloque o cursor na classe parcial.
4. Para projetos do Visual Basic:
a. Expanda a lista Nome do Método .
b. Localize o método OnCOLUMNNAMEChanging para a coluna à que você deseja adicionar a
validação.
c. Um método OnCOLUMNNAMEChanging é adicionado à classe parcial.
d. Adicione o seguinte código para primeiro verificar que um valor está inserido e para garantir em
que o valor inserido para a coluna é aceitável para seu aplicativo. O argumento de value contém
o valor proposto, para adicionar a lógica para confirmar que é um valor válido:

If value.HasValue Then
' Add code to ensure that the value is acceptable.
' If value < 1 Then
' Throw New Exception("Invalid data!")
' End If
End If

Para projetos C#:

Como os projetos C# não geram manipuladores de eventos automaticamente, você pode usar o
IntelliSense para criar os métodos parciais que mudam de coluna. Tipo partial e um espaço para
acessar a lista de métodos parciais disponíveis. Clique no método de alteração para a coluna que você
deseja adicionar validação para. O código a seguir é semelhante ao código gerado quando você seleciona
um método parcial de alteração de coluna:

partial void OnCOLUMNNAMEChanging(COLUMNDATATYPE value)

{
throw new System.NotImplementedException();
}

Adicionar validação para atualizações a uma classe de entidade

Além de verificar valores alterações pendentes, você também pode validar dados quando é feita uma tentativa
de atualizar uma classe completa de entidade. A validação durante uma atualização tentada permite que você
comparar valores em várias colunas se as regras comerciais exigem esta. O procedimento a seguir mostra como
validar quando é feita uma tentativa de atualizar uma classe completa de entidade.

NOTE
O código de validação para que as atualizações terminem classes de entidade é executado na classe parcial de
DataContext (em vez de na classe parcial de uma classe específica de entidade).

Para validar dados durante uma atualização para uma entidade

1. Abra ou crie um novo arquivo LINQ to SQL Classes (arquivo .dbml) no Designer O/R. (Clique
duas vezes no arquivo .dbml em Gerenciador de Soluções .)
2. Clique com o botão direito do mouse em uma área vazia no Designer Relacional de Objetos e clique
em Exibir Código .
O editor de códigos abre com uma classe parcial para DataContext .
3. Coloque o cursor na classe parcial para DataContext .
4. Para projetos do Visual Basic:
a. Expanda a lista Nome do Método .
b. Clique em UpdateENTITYCL ASSNAME.
c. Um método UpdateENTITYCLASSNAME é adicionado à classe parcial.
d. Acessar valores de colunas individuais usando o argumento de instance , conforme mostrado no
código o seguir:
If (instance.COLUMNNAME = x) And (instance.COLUMNNAME = y) Then
Dim ErrorMessage As String = "Invalid data!"
Throw New Exception(ErrorMessage)
End If

Para projetos C#:

Como os projetos C# não geram manipuladores de eventos automaticamente, você pode usar o
IntelliSense para criar o método UpdateCLASSNAME parcial. Tipo partial e um espaço para acessar a lista
de métodos parciais disponíveis. Clique no método update para a classe na qual você deseja adicionar
validação. O código a seguir se assemelha ao código gerado quando você seleciona um UpdateCLASSNAME
método parcial:

partial void UpdateCLASSNAME(CLASSNAME instance)

{
if ((instance.COLUMNNAME == x) && (instance.COLUMNNAME = y))
{
string ErrorMessage = "Invalid data!";
throw new System.Exception(ErrorMessage);
}
}

Confira também
LINQ to SQL ferramentas no Visual Studio
Validando dados
LINQ to SQL (.NET Framework)
Walkthrough: personalizar o comportamento de
inserção, atualização e exclusão de classes de
entidade
20/11/2021 • 10 minutes to read

as ferramentas de LINQ to SQL no Visual Studio fornecem uma superfície de design Visual para criar e editar
classes de LINQ to SQL (classes de entidade) que se baseiam em objetos em um banco de dados. usando LINQ
to SQL, você pode usar a tecnologia LINQ para acessar bancos de dados do SQL. Para obter mais informações,
consulte LINQ (consulta integrada à linguagem).
por padrão, a lógica para executar atualizações é fornecida pelo LINQ to SQL runtime. O tempo de execução
Insert cria Update instruções padrão, e Delete com base no esquema da tabela (as definições de coluna e
informações de chave primária). Quando você não deseja usar o comportamento padrão, poderá configurar o
comportamento de atualização e designar procedimentos armazenados específicos para executar as inserções,
as atualizações e as exclusões necessárias para trabalhar com os dados no banco de dados. Você também pode
fazer isso quando o comportamento padrão não é gerado, por exemplo, quando as classes de entidade
mapeiam para as exibições. Além disso, você pode substituir o comportamento de atualização padrão quando o
banco de dados exige acesso à tabela por meio dos procedimentos armazenados. Para obter mais informações,
consulte Personalizando operações usando procedimentos armazenados.

NOTE
Essa explicação passo a passo exige a disponibilidade dos procedimentos armazenados Inser tCustomer ,
UpdateCustomer e DeleteCustomer para o banco de dados Northwind.

este tutorial fornece as etapas que você deve seguir para substituir o comportamento padrão LINQ to SQL
tempo de execução para salvar dados de volta em um banco de dado usando procedimentos armazenados.
Durante este passo a passos, você aprenderá a executar as seguintes tarefas:
crie um novo aplicativo Windows Forms e adicione um arquivo de LINQ to SQL a ele.
Crie uma classe de entidade que seja mapeada para a Customers tabela Northwind.
crie uma fonte de dados de objeto que faça referência à Customer classe LINQ to SQL.
crie um formulário de Windows que contenha um DataGridView que esteja associado à Customer classe.
Implemente a funcionalidade de salvar para o formulário.
Crie DataContext métodos adicionando procedimentos armazenados ao o /R Designer .
Configure a Customer classe para usar procedimentos armazenados para executar inserções,
atualizações e exclusões.

Pré-requisitos
este passo a passos usa SQL Server Express LocalDB e o banco de dados de exemplo Northwind.
1. se você não tiver SQL Server Express LocalDB, instale-o na página de download SQL Server Expressou
por meio do Instalador do Visual Studio . no Instalador do Visual Studio , você pode instalar SQL
Server Express LocalDB como parte da carga de trabalho de armazenamento e processamento de
dados ou como um componente individual.
2. Instale o banco de dados de exemplo Northwind seguindo estas etapas:
a. no Visual Studio, abra a janela pesquisador de objetos do SQL Ser ver . (SQL Ser ver o
pesquisador de objetos é instalado como parte da carga de trabalho de armazenamento e
processamento de dados no Instalador do Visual Studio .) expanda o nó SQL Ser ver .
clique com o botão direito do mouse em sua instância do LocalDB e selecione nova consulta .
Uma janela do editor de consultas é aberta.
b. copie o script Northwind Transact-SQL para a área de transferência. esse script T-SQL cria o banco
de dados Northwind do zero e popula-o com eles.
c. cole o script T-SQL no editor de consultas e, em seguida, escolha o botão executar .
Após um curto período, a consulta terminará de ser executada e o banco de dados Northwind será
criado.

Criando um aplicativo e adicionando classes LINQ to SQL

como você está trabalhando com classes de LINQ to SQL e exibindo os dados em um formulário de Windows,
crie um novo aplicativo de Windows Forms e adicione um arquivo de classes de LINQ to SQL.

para criar um novo projeto de aplicativo Windows Forms que contém LINQ to SQL classes
1. No Visual Studio, no menu Arquivo , selecione Novo > Projeto .
2. expanda o Visual C# ou Visual Basic no painel esquerdo e, em seguida, selecione Windows área de
trabalho .
3. no painel central, selecione o tipo de projeto Windows Forms aplicativo .
4. Nomeie o projeto UpdatingWithSProcsWalkthrough e escolha OK .
O projeto de UpdatingWithSProcsWalkthrough é criado e adicionado ao Gerenciador de Soluções .
5. No menu Projeto , clique em Adicionar Novo Item .
6. Clique no modelo Classes LINQ to SQL e digite Nor thwind.dbml na caixa Nome .
7. Clique em Adicionar .
um arquivo de Classes de LINQ to SQL vazio (Nor thwind. dbml ) é adicionado ao projeto e o /R
Designer é aberto.

Criar a classe de entidade do cliente e a fonte de dados do objeto

crie LINQ to SQL classes que são mapeadas para tabelas de banco de dados arrastando tabelas de
Gerenciador de Ser vidores ou Gerenciador de Banco de Dados para o o /R Designer . O resultado são
classes de entidade do LINQ to SQL que mapeiam para as tabelas no banco de dados. Depois de criar classes de
entidade, elas podem ser usadas como fontes de dados de objeto assim como outras classes que têm
propriedades públicas.
Para criar uma classe de entidade Customer e configurar uma fonte de dados com ela
1. em Gerenciador de Ser vidores ou Gerenciador de Banco de Dados , localize a tabela cliente na
versão SQL Server do banco de dados de exemplo Northwind.
2. Arraste o nó clientes do Gerenciador de ser vidores ou Gerenciador de banco de dados na
superfície *o/R Designer .
Uma classe de entidade chamada Customer é criada. Ela tem propriedades que correspondem às
colunas na tabela Customers. A classe de entidade é chamada de Customer (e não Customers ) porque
representa um único cliente da tabela Customers.

NOTE
Esse comportamento de renomeação é chamado de pluralização. Ele pode ser ativado ou desativado na caixa de
diálogo opções. Para obter mais informações, consulte como ativar e desativar a pluralização (O/R Designer).

3. No menu Compilar , clique em Compilar UpdatingwithSProcsWalkthrough para criar o projeto.

4. Para abrir a janela fontes de dados , no menu dados , clique em mostrar fontes de dados .
5. Na janela Fontes de Dados , clique em Adicionar Nova Fonte de Dados .
6. Clique em Objeto na página Escolher um Tipo de Fonte de Dados e clique em Avançar .
7. Expanda o nó UpdatingwithSProcsWalkthrough e localize e selecione a classe Customer .

NOTE
Se a classe Customer não estiver disponível, cancele o assistente, compile o projeto e execute o assistente
novamente.

8. Clique em Concluir para criar a fonte de dados e adicionar a classe de entidade Customer à janela
Fontes de Dados .

criar um DataGridView para exibir os dados do cliente em um

formulário de Windows
crie controles associados a classes de entidade arrastando LINQ to SQL itens de fonte de dados da janela fontes
de dados para um formulário Windows.
Para adicionar controles que estão associados às classes de entidade
1. Abra o Form1 no modo de exibição de design.
2. Da janela Fontes de Dados , arraste o nó Customer para o Form1 .

NOTE
Para exibir a janela Fontes de Dados , clique em Mostrar Fontes de Dados no menu Dados .

3. Abra o Form1 no editor de códigos.

4. Adicione o seguinte código ao formulário, global ao formulário, fora de qualquer método específico, mas
dentro da Form1 classe:
Private NorthwindDataContext1 As New NorthwindDataContext

private NorthwindDataContext northwindDataContext1

= new NorthwindDataContext();

5. Crie um manipulador de eventos para o evento Form_Load e adicione o seguinte código ao manipulador:

CustomerBindingSource.DataSource = NorthwindDataContext1.Customers

customerBindingSource.DataSource
= northwindDataContext1.Customers;

Implementar funcionalidade de salvamento

Por padrão, o botão de salvar não está habilitado e a funcionalidade de salvar não está implementada. Além
disso, o código não será automaticamente adicionado para salvar dados modificados no banco de dados
quando os controles associados a dados forem criados para fontes de dados de objeto. esta seção explica como
habilitar o botão salvar e implementar a funcionalidade salvar para objetos do LINQ to SQL.
Para implementar a funcionalidade de salvar
1. Abra o Form1 no modo de exibição de design.
2. Selecione o botão de salvar no CustomerBindingNavigator (o botão com o ícone de disquete).
3. Na janela Propriedades , defina a propriedade Habilitado como True .
4. Clique duas vezes no botão de salvar para criar um manipulador de eventos e alternar para o Editor de
Códigos.
5. Adicione o código a seguir no manipulador de eventos do botão de salvar:

NorthwindDataContext1.SubmitChanges()

northwindDataContext1.SubmitChanges();

Substituir o comportamento padrão para executar atualizações

(inserções, atualizações e exclusões)
Para substituir o comportamento padrão de atualização
1. abra o arquivo LINQ to SQL no Designer do o/R . (Clique duas vezes no arquivo Nor thwind.dbml no
Gerenciador de Soluções .)
2. Em Gerenciador de Ser vidores /Gerenciador de Banco de Dados , expanda o nó Procedimentos
Armazenados de bancos de dados Northwind e localize os procedimentos armazenados
Inser tCustomers , UpdateCustomers e DeleteCustomers .
3. Arraste todos os três procedimentos armazenados para o o /R Designer .
Os procedimentos armazenados são adicionados ao painel dos métodos como métodos DataContext.
Para obter mais informações, consulte métodos DataContext (O/R Designer).
4. Selecione a classe de entidade Customer no o /R Designer .
5. Na janela Propriedades , selecione a propriedade Inser t .
6. Clique nas reticências (… ) ao lado de Usar runtime para abrir a caixa de diálogo Configurar
Compor tamento .
7. Selecione Personalizar .
8. Selecione o método Inser tCustomers na lista Personalizar .
9. Clique em Aplicar para salvar a configuração para a Classe e o Comportamento selecionados.

NOTE
Você pode continuar a configurar o comportamento para cada combinação de classe/comportamento quando
você clica em Aplicar depois de cada alteração. Se você alterar a classe ou o comportamento antes de clicar em
aplicar , uma caixa de diálogo de aviso que fornece uma oportunidade para aplicar as alterações será exibida.

10. Selecione Atualizar na lista Compor tamento .

11. Selecione Personalizar .
12. Selecione o método UpdateCustomers na lista Personalizar .
Inspecione a lista de Argumentos de Método e de Propriedades de Classe e observe que há dois
Argumentos de Método e duas Propriedades de Classe para algumas colunas na tabela. Isso facilita
controlar as alterações e criar as instruções que conferem a existência de violações de simultaneidade.
13. Mapeie o argumento do método Original_CustomerID para a propriedade de classe CustomerID
(Original) .

NOTE
Por padrão, os argumentos do método mapearão para as propriedades da classe quando os nomes
corresponderem. Se os nomes de propriedade forem alterados e não corresponderem mais entre a tabela e a
classe de entidade, talvez seja necessário selecionar a propriedade de classe equivalente para mapear se o o /R
Designer não puder determinar o mapeamento correto. Além disso, se os argumentos do método não tiverem
propriedades da classe válidas para a qual mapear, você poderá definir o valor de Propriedades de Classe como
(Nenhum) .

14. Clique em Aplicar para salvar a configuração para a Classe e o Comportamento selecionados.
15. Selecione Excluir na lista Compor tamento .
16. Selecione Personalizar .
17. Selecione o método DeleteCustomers na lista Personalizar .
18. Mapeie o argumento do método Original_CustomerID para a propriedade de classe CustomerID
(Original) .
19. Clique em OK .
NOTE
embora não seja um problema para esse passo-a particular, vale a pena observar que LINQ to SQL trata valores gerados
pelo banco de dados automaticamente para identidade (incremento automático), rowguidcol (GUID gerado por banco de
dados) e colunas de carimbo de data/hora durante inserções e atualizações. Os valores gerados pelo banco de dados em
outros tipos de coluna resultarão inesperadamente em um valor nulo. Para retornar os valores gerados pelo banco de
dados, você deve definir manualmente IsDbGenerated como true e AutoSync como um dos seguintes: AutoSync.
Always, AutoSync. OnInsertou AutoSync. OnUpdate.

Testar o aplicativo
Execute o aplicativo novamente para verificar se o procedimento armazenado UpdateCustomers atualiza
corretamente o registro do cliente no banco de dados.
1. Pressione F5 .
2. Modifique um registro na grade para testar o comportamento de atualização.
3. Adicione um novo registro para testar o comportamento de inserção.
4. Clique no botão de salvar para salvar as alterações de volta para o banco de dados.
5. Feche o formulário.
6. Pressione F5 e verifique se o registro atualizado e o registro recentemente inserido persistiram.
7. Exclua o novo registro que você criou na etapa 3 para testar o comportamento de exclusão.
8. Clique no botão de salvar para enviar as alterações e remova o registro excluído do banco de dados.
9. Feche o formulário.
10. Pressione F5 e verifique se o registro excluído foi removido do banco de dados.

NOTE
Se o aplicativo usar o SQL Server Express Edition, dependendo do valor da propriedade Copiar para Diretório
de Saída do arquivo de banco de dados, as alterações poderão não aparecer quando você pressiona F5 na etapa
10.

Próximas etapas
dependendo dos requisitos do aplicativo, há várias etapas que você pode querer executar depois de criar LINQ
to SQL classes de entidade. Entre algumas das melhorias que você pode fazer neste aplicativo estão:
Implementar verificação de simultaneidade durante atualizações. Para obter informações, consulte
simultaneidade otimista: visão geral.
Adicionar consultas LINQ para filtrar dados. Para obter informações, consulte introdução às consultas
LINQ (C#).

Confira também
ferramentas de LINQ to SQL no Visual Studio
Métodos DataContext
Como: atribuir procedimentos armazenados para executar atualizações, inserções e exclusões
LINQ to SQL
consultas de LINQ to SQL
Como atribuir procedimentos armazenados para
executar atualizações, inserções e exclusões
(Designer Relacional de Objetos)
20/11/2021 • 3 minutes to read

Os procedimentos armazenados podem ser adicionados ao Designer Relacional de Objetos e executados

como métodos típicos do DataContext. eles também podem ser usados para substituir o comportamento
padrão LINQ to SQL tempo de execução que executa inserções, atualizações e exclusões quando as alterações
são salvas de classes de entidade em um banco de dados (por exemplo, ao chamar o SubmitChanges método).

NOTE
Se seu procedimento armazenado retornar valores que precisem ser reenviados ao cliente (por exemplo, valores
calculados no procedimento armazenado), crie parâmetros de saída em seus procedimentos armazenados. Se você não
pode usar parâmetros de saída, escreva uma implementação de método parcial em vez de depender das substituições
geradas pelo Designer Relacional de Objetos. Os membros mapeados para os valores gerados por banco de dados
precisam ser definidos para valores apropriados após a conclusão com êxito de operações INSERT ou UPDATE. Para obter
mais informações, consulte responsabilidades do desenvolvedor ao substituir o comportamento padrão.

NOTE
LINQ to SQL manipula valores gerados pelo banco de dados automaticamente para identidade (incremento automático),
rowguidcol (GUID gerado pelo banco de dados) e colunas de carimbo de data/hora. Os valores gerados pelo banco de
dados em outros tipos de coluna resultarão inesperadamente em um valor nulo. Para retornar os valores gerados pelo
banco de dados, você deve definir manualmente IsDbGenerated como true e AutoSync como um dos seguintes:
AutoSync. Always, AutoSync. OnInsertou AutoSync. OnUpdate.

Configurar o comportamento de atualização de uma classe de

entidade
por padrão, a lógica para atualizar um banco de dados (inserções, atualizações e exclusões) com alterações que
foram feitas em LINQ to SQL classes de entidade é fornecida pelo LINQ to SQL runtime. O runtime cria
comandos padrão INSERT, UPDATE e DELETE que se baseiam no esquema da tabela (as informações de coluna e
chave primária). Quando o comportamento padrão não é desejado, você pode configurar o comportamento de
atualização atribuindo procedimentos armazenados específicos para executar as inserções, atualizações e
exclusões necessárias para manipular os dados em sua tabela. Você também pode fazer isso quando o
comportamento padrão não é gerado, por exemplo, quando as classes de entidade mapeiam para as exibições.
Finalmente, você pode substituir o comportamento de atualização padrão quando o banco de dados exige o
acesso à tabela através de procedimentos armazenados.

NOTE
Seu computador pode mostrar diferentes nomes ou locais para alguns dos elementos de interface do usuário do Visual
Studio neste artigo. Você pode estar usando outra edição do Visual Studio ou outras configurações de ambiente. Para
obter mais informações, confira Personalizar o IDE.
Para atribuir procedimentos armazenados para substituir o comportamento padrão de uma classe de
entidade
1. Abra o arquivo LINQ to SQL no designer. (Clique duas vezes no arquivo .dbml em Gerenciador de
Soluções .)
2. Em Gerenciador de Ser vidores ou Gerenciador de Banco de Dados , expanda Procedimentos
Armazenados e localize os procedimentos armazenados a serem usados com os comandos Insert,
Update e/ou Delete da classe de entidade.
3. Arraste o procedimento armazenado para o Designer Relacional de Objetos .
O procedimento armazenado é adicionado ao painel de métodos como um método DataContext. Para
obter mais informações, consulte métodos DataContext (O/R Designer).
4. Selecione a classe de entidade para a qual você deseja usar o procedimento armazenado para executar
atualizações.
5. Na janela Propriedades , selecione o comando a ser substituído (Inser t , Update ou Delete ).
6. Clique nas reticências (...) ao lado das palavras Usar Runtime para abrir a caixa de diálogo Configurar
Compor tamento .
7. Selecione Personalizar .
8. Selecione o procedimento armazenado desejado na lista Personalizar .
9. Inspecione a lista de Argumentos de Método e de Propriedades de Classe para verificar se
Argumentos de Método é mapeado para Propriedades de Classe apropriado. Mapeie os
argumentos do método original ( Original_<ArgumentName> ) para as propriedades originais (
<PropertyName> (Original) ) para Update os Delete comandos e.

NOTE
Por padrão, os argumentos do método são mapeados para as propriedades de classe quando os nomes
coincidem. Se os nomes de propriedade forem modificados, não haverá mais correspondência entre a tabela e a
classe de entidade. Talvez seja necessário selecionar a propriedade de classe equivalente para mapeamento se o
designer não puder determinar o mapeamento correto.

10. Clique em OK ou em Aplicar .

NOTE
Você pode continuar a configurar o comportamento para cada combinação de classe e comportamento desde
que você clique em aplicar depois de fazer cada alteração. Se você alterar a classe ou o comportamento antes de
clicar em aplicar , uma caixa de diálogo de aviso será exibida e lhe fornecerá a oportunidade de aplicar as
alterações.

Para voltar a usar a lógica padrão em runtime para atualizações, clique nas reticências ao lado do comando
Inser t , Update ou Delete , na janela Propriedades , e selecione Usar runtime na caixa de diálogo
Configurar Compor tamento .

Confira também
ferramentas de LINQ to SQL no Visual Studio
Métodos DataContext
LINQ to SQL (.NET Framework)
Operações de inserção, atualização e exclusão (.NET Framework)
Como habilitar e desabilitar a pluralização
(Designer Relacional de Objetos)
20/11/2021 • 2 minutes to read

por padrão, quando você arrasta objetos de banco de dados que têm nomes que terminam em s ou s de
Gerenciador de Ser vidores ou Gerenciador de Banco de Dados nas ferramentas de LINQ to SQL no
Visual Studio, os nomes das classes de entidade geradas são alterados de plural para singular. Isso é feito a
representa mais precisamente o fato que a classe instanciado de entidade mapeia para um único registro de
dados. Por exemplo, a adição de uma Customers tabela ao o /R Designer resulta em uma classe de entidade
chamada Customer , pois a classe manterá os dados para apenas um único cliente.

NOTE
Pluralization está ativada por padrão somente na versão de língua inglesa do Visual Studio.

Para desativar o pluralization e sobre

1. No menu Ferramentas , clique em Opções .
2. Na caixa de diálogo Opções , expanda Ferramentas de Banco de Dados .

NOTE
Selecione Mostrar todas as configurações se o nó de Ferramentas de Banco de Dados não estiver visível.

3. Clique em Designer Relacional de Objetos .

4. Defina pluralização de nomes como habilitado = false para definir o o /R Designer para que ele
não altere os nomes de classe.
5. Defina pluralização de nomes como habilitado = true para aplicar as regras de pluralização aos
nomes de classe dos objetos adicionados ao o /R Designer .

Confira também
ferramentas de LINQ to SQL no Visual Studio
LINQ to SQL
Acessando dados no Visual Studio
Como: criar e configurar conjuntos de valores no
Visual Studio
20/11/2021 • 3 minutes to read

Um DataSet é um conjunto de objetos que armazenam dados de um Database na memória e dão suporte ao
controle de alterações para permitir operações de criação, leitura, atualização e exclusão (CRUD) nesses dados
sem a necessidade de sempre estar conectado ao banco de dado. Os conjuntos de dados foram projetados para
formulários simples em aplicativos de negócios de data. Para novos aplicativos, considere o uso de Entity
Framework para armazenar e modelar dados na memória. Para trabalhar com conjuntos de dados, você deve
ter um conhecimento básico dos conceitos de banco de dados.
você pode criar uma classe tipada DataSet em Visual Studio em tempo de design usando o assistente de
configuração de fonte de dados . Para obter informações sobre como criar conjuntos de dados
programaticamente, consulte criando um conjunto de dados (ADO.net).

Criar um novo conjunto de dados usando o assistente de

configuração de fonte de dados
1. abra seu projeto no Visual Studio e, em seguida, escolha Project > adicionar nova fonte de dados
para iniciar o assistente de configuração da fonte de dados .
2. Escolha o tipo de fonte de dados ao qual você estará se conectando.

3. Escolha os bancos de dados que serão a fonte de dado para o DataSet.

4. Escolha as tabelas (ou colunas individuais), procedimentos armazenados, funções e exibições do banco
de dados que você deseja que sejam representadas no DataSet.

5. Clique em Concluir .
O conjunto de um é exibido como um nó no Gerenciador de soluções .

6. Clique no nó do conjunto de um Gerenciador de soluções para abrir o conjunto de um DataSet.

Cada tabela no conjunto de resultados tem um TableAdapter objeto associado, que é representado na
parte inferior. O adaptador de tabela é usado para popular o conjunto de dados e, opcionalmente, para
enviar comandos para o Database.
7. As linhas de relação que conectam as tabelas representam relações de tabela, conforme definido no
banco de dados. Por padrão, as restrições Foreign-Key em um banco de dados são representadas
somente como uma relação, com as regras Update e Delete definidas como None. Normalmente, isso é o
que você deseja. No entanto, você pode clicar nas linhas para abrir a caixa de diálogo de relação , na
qual você pode alterar o comportamento de atualizações hierárquicas. Para obter mais informações,
consulte relações em conjuntos de dados e atualização hierárquica.

8. Clique em uma tabela, um adaptador de tabela ou um nome de coluna em uma tabela para ver suas
propriedades na janela Propriedades . Você pode modificar alguns dos valores aqui. Apenas lembre-se
de que você está modificando o conjunto de dados, não o banco de dados de origem.
9. Você pode adicionar novas tabelas ou adaptadores de tabela ao conjunto de recursos ou adicionar novas
consultas para adaptadores de tabela existentes ou especificar novas relações entre tabelas arrastando
esses itens da guia caixa de ferramentas . Essa guia aparece quando o Designer de conjunto de os
está em foco.

Em seguida, talvez você queira especificar como preencher o conjunto de dados com o dado. Para isso, você usa
o Assistente de configuração do TableAdapter . Para obter mais informações, consulte preencher conjuntos
de dados usando TableAdapters.

Adicionar uma tabela de banco de dados ou outro objeto a um

conjunto de dados existente
Este procedimento mostra como adicionar uma tabela do mesmo banco de dados que você usou para primeiro
criar o conjunto.
1. Clique no nó DataSet em Gerenciador de soluções para colocar o Designer de conjunto de
DataSet em foco.
2. clique na guia fontes de dados na margem esquerda de Visual Studio ou digite fontes de dados na
caixa de pesquisa.
3. Clique com o botão direito do mouse no nó do conjunto de dados e selecione Configure Data Source
com o assistente .
4. Use o assistente para especificar quais tabelas, procedimentos armazenados ou outros objetos de banco
de dados adicionais adicionar ao conjunto de dados.

Adicionar uma tabela de dados autônoma a um DataSet

1. Abra o conjunto de dados no Designer de Conjunto de Dados .
2. Arraste uma DataTable classe da guia DataSet da caixa de ferramentas para a Designer de conjunto
de dados .
3. Adicione colunas para definir a tabela de dados. Clique com o botão direito do mouse na tabela e escolha
Adicionar > coluna . Use a janela Propriedades para definir o tipo de dados da coluna e uma chave, se
necessário.
Tabelas autônomas precisam implementar a Fill lógica em tabelas autônomas para que você possa preenchê-
las com dados. Para obter informações sobre como preencher tabelas de dados autônomas, consulte Populando
um DataSet de um DataAdapter.

Confira também
Ferramentas de conjunto de dados no Visual Studio
Relacionamentos em conjuntos de dados
Atualização hierárquica
Preencher conjuntos de dados usando TableAdapters
Criar relações entre conjuntos de dados
20/11/2021 • 5 minutes to read

DataSets que contêm tabelas de dados relacionadas usam DataRelation objetos para representar uma relação
pai/filho entre as tabelas e para retornar registros relacionados uns dos outros. Adicionar tabelas relacionadas a
conjuntos de dados usando o Assistente de configuração de fonte de dados ou o Designer de conjunto
de dados , cria e configura o DataRelation objeto para você.
O DataRelation objeto executa duas funções:
Ele pode disponibilizar os registros relacionados a um registro com o qual você está trabalhando. Ele
fornecerá registros filho se você estiver em um registro pai ( GetChildRows ) e um registro pai se estiver
trabalhando com um registro filho ( GetParentRow ).
Ele pode impor restrições para a integridade referencial, como excluir registros filho relacionados quando
você exclui um registro pai.
É importante entender a diferença entre uma junção verdadeira e a função de um DataRelation objeto. Em uma
junção verdadeira, os registros são tirados das tabelas pai e filho e colocados em um único conjunto de
registros simples. Quando você usa um DataRelation objeto, nenhum novo conjunto de registros é criado. Em
vez disso, a DataRelation acompanha a relação entre as tabelas e mantém os registros pai e filho sincronizados.

Objetos e restrições de DataRelation

Um DataRelation objeto também é usado para criar e impor as seguintes restrições:
Uma restrição UNIQUE, que garante que uma coluna na tabela não contenha duplicatas.
Uma restrição FOREIGN-KEY, que pode ser usada para manter a integridade referencial entre uma tabela
pai e filho em um conjunto de um DataSet.
As restrições que você especificar em um DataRelation objeto são implementadas criando automaticamente
objetos apropriados ou definindo propriedades. Se você criar uma restrição FOREIGN-KEY usando o
DataRelation objeto, as instâncias da ForeignKeyConstraint classe serão adicionadas à DataRelation Propriedade
do objeto ChildKeyConstraint .
Uma restrição UNIQUE é implementada simplesmente definindo a Unique propriedade de uma coluna de dados
como true ou adicionando uma instância da UniqueConstraint classe à DataRelation Propriedade do objeto
ParentKeyConstraint . Para obter informações sobre como suspender restrições em um conjunto de dados,
consulte desativar restrições ao preencher um conjunto dedados.
Regras de integridade referencial
Como parte da restrição FOREIGN-KEY, você pode especificar regras de integridade referencial que são
aplicadas em três pontos:
Quando um registro pai é atualizado
Quando um registro pai é excluído
Quando uma alteração é aceita ou rejeitada
As regras que você pode fazer são especificadas na Rule enumeração e são listadas na tabela a seguir.
REGRA DE REST RIÇ Ã O F O REIGN - K EY AÇÃO

Cascade A alteração (Update ou Delete) feita no registro pai também

é feita em registros relacionados na tabela filho.

SetNull Os registros filho não são excluídos, mas a chave estrangeira

nos registros filho é definida como DBNull . Com essa
configuração, os registros filho podem ser deixados como
"órfãos", ou seja, não têm relação com os registros pai.
Obser vação: O uso dessa regra pode resultar em dados
inválidos na tabela filho.

SetDefault A chave estrangeira nos registros filho relacionados é

definida como seu valor padrão (conforme estabelecido pela
propriedade da coluna DefaultValue ).

None Nenhuma alteração é feita em registros filho relacionados.

Com essa configuração, os registros filho podem conter
referências a registros pai inválidos.

Para obter mais informações sobre atualizações em tabelas de DataSet, consulte salvar dados de volta no banco
de dados.
Relações somente de restrição
Ao criar um DataRelation objeto, você tem a opção de especificar que a relação seja usada somente para impor
restrições, ou seja, ela também não será usada para acessar registros relacionados. Você pode usar essa opção
para gerar um conjunto de registros que seja um pouco mais eficiente e que contenha menos métodos do que
um com a funcionalidade de registros relacionados. No entanto, você não poderá acessar os registros
relacionados. Por exemplo, uma relação somente de restrição impede que você exclua um registro pai que ainda
tem registros filho, e você não pode acessar os registros filho por meio do pai.

Criando manualmente uma relação de dados no Designer de

Conjunto de Dados
quando você cria tabelas de dados usando as ferramentas de design de dados no Visual Studio, as relações são
criadas automaticamente se as informações podem ser coletadas da origem dos seus dados. Se você adicionar
tabelas de dados manualmente a partir da guia DataSet da caixa de ferramentas , talvez seja necessário criar
a relação manualmente. Para obter informações sobre como criar DataRelation objetos programaticamente,
consulte adicionando DataRelations.
As relações entre tabelas de dados aparecem como linhas na Designer de conjunto de dados , com um glifo
de chave e infinito, que ilustra o aspecto de um para muitos da relação. Por padrão, o nome da relação não
aparece na superfície de design.

Para criar uma relação entre duas tabelas de dados

1. Abra o conjunto de dados no Designer de Conjunto de Dados . Para obter mais informações, consulte
Walkthrough: Criando um conjunto de dados no designer de conjunto de dados.
2. Arraste um objeto relation da caixa de ferramentas DataSet para a tabela de dados filho na relação.
A caixa de diálogo relação é aberta, preenchendo a caixa tabela filho com a tabela na qual você
arrastou o objeto de relação .
3. Selecione a tabela pai na caixa tabela pai . A tabela pai contém registros no lado "um" de uma relação
um-para-muitos.
4. Verifique se a tabela filho correta é exibida na caixa tabela filho . A tabela filho contém registros no lado
"muitos" de uma relação um-para-muitos.
5. Digite um nome para a relação na caixa nome ou deixe o nome padrão com base nas tabelas
selecionadas. Este é o nome do objeto real DataRelation no código.
6. Selecione as colunas que unem as tabelas nas listas colunas de chave e colunas de chave
estrangeira .
7. Selecione se deseja criar uma relação, uma restrição ou ambas.
8. Marque ou desmarque a caixa de relação aninhada . A seleção dessa opção define a Nested
propriedade como true e faz com que as linhas filhas da relação sejam aninhadas dentro da coluna pai
quando essas linhas são gravadas como dados XML ou sincronizadas com o XmlDataDocument . Para
obter mais informações, consulte aninhando DataRelations.
9. Defina as regras a serem impostas quando você estiver fazendo alterações em registros nessas tabelas.
Para obter mais informações, consulte Rule.
10. Clique em OK para criar a relação. Uma linha de relação aparece no designer entre as duas tabelas.
Para exibir um nome de relação no Designer de Conjunto de Dados
1. Abra o conjunto de dados no Designer de Conjunto de Dados . Para obter mais informações, consulte
Walkthrough: Criando um conjunto de dados no designer de conjunto de dados.
2. No menu dados , selecione o comando Mostrar rótulos de relação para exibir o nome da relação.
Limpe esse comando para ocultar o nome da relação.

Confira também
Criar e configurar conjuntos de dados no Visual Studio
Walkthrough: criar um conjunto de um DataSet
com o Designer de Conjunto de Dados
20/11/2021 • 3 minutes to read

Neste tutorial, você cria um conjunto de um DataSet usando o Designer de conjunto de dados . O artigo
orienta você pelo processo de criação de um novo projeto e da adição de um novo item de conjunto de um.
Você aprenderá a criar tabelas com base em tabelas em um banco de dados sem usar um assistente.

Pré-requisitos
este passo a passos usa SQL Server Express LocalDB e o banco de dados de exemplo Northwind.
1. se você não tiver SQL Server Express LocalDB, instale-o na página de download SQL Server Expressou
por meio do Instalador do Visual Studio . no Instalador do Visual Studio, SQL Server Express LocalDB
pode ser instalado como parte da carga de trabalho de armazenamento e processamento de dados
ou como um componente individual.
2. Instale o banco de dados de exemplo Northwind seguindo estas etapas:
a. no Visual Studio, abra a janela pesquisador de objetos do SQL Ser ver . (SQL Server
pesquisador de objetos é instalado como parte da carga de trabalho de armazenamento e
processamento de dados no Instalador do Visual Studio.) expanda o nó SQL Ser ver . clique
com o botão direito do mouse em sua instância do LocalDB e selecione nova consulta .
Uma janela do editor de consultas é aberta.
b. copie o script Northwind Transact-SQL para a área de transferência. esse script T-SQL cria o banco
de dados Northwind do zero e popula-o com eles.
c. cole o script T-SQL no editor de consultas e, em seguida, escolha o botão executar .
Após um curto período, a consulta conclui a execução e o banco de dados Northwind é criado.

Criar um novo projeto de aplicativo do Windows Forms

1. No Visual Studio, no menu Arquivo , selecione Novo > Projeto .
2. expanda o Visual C# ou Visual Basic no painel esquerdo e, em seguida, selecione Windows área de
trabalho .
3. no painel central, selecione o tipo de projeto Windows Forms aplicativo .
4. Nomeie o projeto DatasetDesignerWalkthrough e escolha OK .
Visual Studio adiciona o projeto para Gerenciador de Soluções e exibe um novo formulário no
designer.

Adicionar um novo conjunto de aplicativos ao aplicativo

1. No menu Projeto , selecione Adicionar novo item .
A caixa de diálogo Adicionar Novo Item aparecerá.
2. No painel esquerdo, selecione dados e, em seguida, selecione DataSet no painel central.
3. Nomeie o conjunto de DataSet e, em seguida, escolha Adicionar .
Visual Studio adiciona um arquivo chamado Nor thwindDataset. xsd ao projeto e o abre no Designer
de Conjunto de Dados .

Criar uma conexão de dados no Gerenciador de Servidores

1. No menu Exibir , clique em Gerenciador de ser vidores .
2. em Gerenciador de Ser vidores , clique no botão Conexão ao banco de dados .
3. Crie uma conexão com o banco de dados de exemplo Northwind.

Criar as tabelas no conjunto de

Esta seção explica como adicionar tabelas ao conjunto de os.
Para criar a tabela Customers
1. Expanda a conexão de dados que você criou em Gerenciador de ser vidores e, em seguida, expanda o
nó tabelas .
2. Arraste a tabela Customers de Gerenciador de Ser vidores para a Designer de conjunto de
dados .
Uma tabela de dados Customers e CustomersTableAdapter são adicionadas ao DataSet.
Para criar a tabela Orders
Arraste a tabela Orders de Gerenciador de Ser vidores para a Designer de conjunto de dados .
Uma tabela de dados Orders , OrdersTableAdapter e relação de dados entre as tabelas Customers e
Orders são adicionadas ao DataSet.
Para criar a tabela OrderDetails
Arraste a tabela detalhes do pedido de Gerenciador de Ser vidores para a Designer de conjunto
de dados .
Uma tabela de dados detalhes do pedido , OrderDetailsTableAdapter , e uma relação de dados entre
as tabelas pedidos e OrderDetails são adicionadas ao DataSet.

Próximas etapas
Salve o conjunto de um.
Selecione os itens na janela fontes de dados e arraste-os para um formulário. para obter mais
informações, consulte associar controles de Windows Forms a dados em Visual Studio.
Adicione mais consultas aos TableAdapters.
Adicione a lógica de validação para os ColumnChanging RowChanging eventos ou das tabelas de dados
no DataSet. Para obter mais informações, consulte Validate data in DataSets.

Confira também
Criar e configurar conjuntos de dados no Visual Studio
Associar controles do Windows Forms a dados no Visual Studio
Associar controles a dados no Visual Studio
Validar os dados
Walkthrough: criar uma DataTable no Designer de
Conjunto de Dados
20/11/2021 • 2 minutes to read

Este tutorial explica como criar um DataTable (sem um TableAdapter) usando o Designer de conjunto de
dados . Para obter informações sobre como criar tabelas de dados que incluem TableAdapters, consulte criar e
configurar TableAdapters.

Criar um novo Aplicativo do Windows Forms

1. No Visual Studio, no menu Arquivo , selecione Novo > Projeto .
2. expanda o Visual C# ou Visual Basic no painel esquerdo e, em seguida, selecione Windows área de
trabalho .
3. no painel central, selecione o tipo de projeto Windows Forms aplicativo .
4. Nomeie o projeto DataTableWalkthrough e escolha OK .
O projeto DataTableWalkthrough é criado e adicionado ao Gerenciador de soluções .

Adicionar um novo conjunto de aplicativos ao aplicativo

1. No menu Projeto , selecione Adicionar novo item .
A caixa de diálogo Adicionar Novo Item aparecerá.
2. No painel esquerdo, selecione dados e, em seguida, selecione DataSet no painel central.
3. Escolha Adicionar .
Visual Studio adiciona um arquivo chamado DataSet1. xsd ao projeto e o abre no Designer de
Conjunto de Dados .

Adicionar uma nova DataTable ao DataSet

1. Arraste uma DataTable da guia DataSet da caixa de ferramentas para a Designer de conjunto de
dados .
Uma tabela chamada dataTable1 é adicionada ao DataSet.
2. Clique na barra de título de dataTable1 e renomeie-a Music .

Adicionar colunas à DataTable

1. Clique com o botão direito do mouse na tabela música . Aponte para Adicionar e clique em coluna .
2. Nomeie a coluna SongID .
3. Na janela Propriedades , defina a DataType propriedade como System.Int16 .
4. Repita esse processo e adicione as seguintes colunas:
SongTitle : System.String
Artist : System.String
Genre : System.String

Definir a chave primária para a tabela

Todas as tabelas de dados devem ter uma chave primária. Uma chave primária identifica exclusivamente um
registro específico em uma tabela de dados.
Para definir a chave primária, clique com o botão direito do mouse na coluna SongID e clique em definir
chave primária . Um ícone de chave é exibido ao lado da coluna SongID .

Salvar o projeto
Para salvar o projeto DataTableWalkthrough , no menu arquivo , selecione salvar tudo .

Confira também
Criar e configurar conjuntos de dados no Visual Studio
Associar controles a dados no Visual Studio
Validando dados
Criar e configurar TableAdapters
20/11/2021 • 6 minutes to read

TableAdapters fornecem comunicação entre seu aplicativo e um banco de dados. Eles se conectam ao banco de
dados, executem consultas ou procedimentos armazenados e retornam uma nova tabela de dados ou
preenchem uma existente DataTable com os dados retornados. TableAdapters também pode enviar dados
atualizados de seu aplicativo de volta para o banco de dados.
TableAdapters são criados para você quando você executa uma das seguintes ações:
Arraste objetos de banco de Gerenciador de Ser vidores para o Designer de Conjunto de Dados .
Execute o Assistente de Configuração da Fonte de Dados e selecione o tipo de fonte de dados Banco de
Dados ou Ser viço Web.

Você também pode criar um novo TableAdapter e configurá-lo com uma fonte de dados arrastando um
TableAdapter da Caixa de Ferramentas para uma região vazia na superfície Designer de Conjunto de
Dados dados.
Para ver uma introdução ao TableAdapters, confira Preencher conjuntos de dados usando TableAdapters.

Usar o Assistente de Configuração de TableAdapter

Execute o Assistente de Configuração de TableAdapter para criar ou editar TableAdapters e suas
DataTables associadas. Você pode configurar um TableAdapter existente clicando com o botão direito do mouse
nele no Designer de Conjunto de Dados .
Se você arrastar um novo TableAdapter da Caixa de Ferramentas quando o Designer de Conjunto de Dados
estiver em foco, o assistente será iniciado e solicitará que você especifique a qual fonte de dados o TableAdapter
deve se conectar. Na próxima página, o assistente pergunta que tipo de comandos ele deve usar para se
comunicar com o banco de dados, seja SQL instruções ou procedimentos armazenados. (Você não verá isso se
estiver configurando um TableAdapter que já está associado a uma fonte de dados.)
Você tem a opção de criar um novo procedimento armazenado no banco de dados subjacente se tiver as
permissões corretas para o banco de dados. Se você não tiver essas permissões, essa não será uma
opção.
Você também pode optar por executar procedimentos armazenados existentes para os comandos
SELECT, INSERT, UPDATE e DELETE do TableAdapter. O procedimento armazenado atribuído ao
comando Update, por exemplo, é executado quando o TableAdapter.Update() método é chamado.
Mapear parâmetros desde o procedimento armazenado selecionado até as colunas correspondentes na tabela
de dados. Por exemplo, se o procedimento armazenado aceitar um parâmetro chamado que ele passa para a
coluna na tabela, de definir a Coluna de @CompanyName CompanyName Origem do parâmetro como @CompanyName
CompanyName .

NOTE
O procedimento armazenado atribuído ao comando SELECT é executado chamando o método do TableAdapter que você
nomeia na próxima etapa do assistente. O método padrão é , portanto, o código que normalmente é Fill usado para
executar o procedimento SELECT é TableAdapter.Fill(tableName) . Se você alterar o nome padrão de , substitua pelo
nome atribuído e substitua "TableAdapter" pelo nome real do Fill Fill TableAdapter (por exemplo,
CustomersTableAdapter ).

Selecionar a opção Criar métodos para enviar atualizações diretamente para o banco de dados é
equivalente a definir a propriedade como GenerateDBDirectMethods true. A opção fica não disponível quando
a instrução SQL original não fornecer informações suficientes ou a consulta não for uma consulta atualizável.
Essa situação pode ocorrer, por exemplo, em consultas JOIN e consultas que retornam um único valor
(escalar).
As Opções Avançadas no assistente permitem que você:
Gere instruções INSERT, UPDATE e DELETE com base na instrução SELECT definida na página Gerar SQL
instruções
Usar simultaneidade otimista
Especifique se a tabela de dados deve ser atualizada depois que as instruções INSERT e UPDATE são
executados

Configurar o método Fill de um TableAdapter

Às vezes, talvez você queira alterar o esquema da tabela tableAdapter. Para fazer isso, modifique o método
primário do Fill TableAdapter. TableAdapters são criados com um método Fill primário que define o
esquema da tabela de dados associada. O método primário é baseado na consulta ou no procedimento
armazenado inserido Fill quando você configurou originalmente o TableAdapter. É o primeiro método (mais
alto) na tabela de dados no Designer de Conjuntos de Dados.

Todas as alterações feitas no método principal do TableAdapter são refletidas no Fill esquema da tabela de
dados associada. Por exemplo, remover uma coluna da consulta no método principal também remove a coluna
Fill da tabela de dados associada. Além disso, remover a coluna do método principal remove a coluna de
quaisquer consultas Fill adicionais para esse TableAdapter.
Você pode usar o Assistente de Configuração de Consulta TableAdapter para criar e editar consultas adicionais
para o TableAdapter. Essas consultas adicionais devem estar em conformidade com o esquema de tabela, a
menos que retornem um valor escalar. Cada consulta adicional tem um nome que você especificar.
O exemplo a seguir mostra como chamar uma consulta adicional chamada FillByCity :
CustomersTableAdapter.FillByCity(NorthwindDataSet.Customers, "Seattle")

Para iniciar o Assistente de Configuração de Consulta TableAdapter com uma nova consulta
1. Abra o conjunto de dados no Designer de Conjunto de Dados .
2. Se você estiver criando uma nova consulta, arraste um objeto Consulta da guia DataSet da Caixa de
Ferramentas para um ou selecione Adicionar Consulta no menu de atalho DataTable do TableAdapter.
Você também pode arrastar um objeto Consulta para uma área vazia do Designer de Conjunto de
Dados , que cria um TableAdapter sem um DataTable associado. Essas consultas só podem retornar
valores únicos (escalares) ou executar comandos UPDATE, INSERT ou DELETE no banco de dados.
3. Na tela Escolher Sua Conexão de Dados, selecione ou crie a conexão que a consulta usará.

NOTE
Essa tela só aparece quando o designer não pode determinar a conexão apropriada a ser usada ou quando
nenhuma conexão está disponível.
4. Na tela Escolher um Tipo de Comando, selecione entre os seguintes métodos de busca de dados do
banco de dados:
Usar SQL instruções permite que você digite uma instrução SQL para selecionar os dados do
banco de dados.
Criar um novo procedimento armazenado permite que o assistente crie um novo
procedimento armazenado (no banco de dados) com base na instrução SELECT especificada.
Usar procedimentos armazenados existentes permite que você execute um procedimento
armazenado existente ao executar a consulta.
Para iniciar o assistente de Configuração de Consulta TableAdapter em uma consulta existente
Se você estiver editando uma consulta TableAdapter existente, clique com o botão direito do mouse na
consulta e escolha Configurar no menu de atalho.

NOTE
Clicar com o botão direito do mouse na consulta principal de um TableAdapter reconfigura o TableAdapter e
DataTable o esquema. No entanto, clicar com o botão direito do mouse em uma consulta adicional em um
TableAdapter configura apenas a consulta selecionada. O Assistente de Configuração de TableAdapter
reconfigura a definição tableAdapter, enquanto o Assistente de Configuração de Consulta tableAdapter
reconfigura apenas a consulta selecionada.

Para adicionar uma consulta global a um TableAdapter

As consultas globais SQL consultas que retornam um único valor (escalar) ou nenhum valor.
Normalmente, as funções globais executam operações de banco de dados, como inserções, atualizações e
exclusões. Eles também agregam informações, como uma contagem de clientes em uma tabela ou o total
de encargos para todos os itens em uma ordem específica.
Adicione consultas globais arrastando um objeto Consulta da guia DataSet da Caixa de Ferramentas
para uma área vazia do Designer de Conjunto de Dados .
Forneça uma consulta que executa a tarefa desejada, por exemplo,
SELECT COUNT(*) AS CustomerCount FROM Customers .

NOTE
Arrastar um objeto Consulta diretamente para o Designer de Conjunto de Dados cria um método que
retorna apenas um valor escalar (único). Embora a consulta ou o procedimento armazenado selecionado possa
retornar mais de um único valor, o método criado pelo assistente retorna apenas um único valor. Por exemplo, a
consulta pode retornar a primeira coluna da primeira linha dos dados retornados.

Confira também
Preencher conjuntos de dados usando TableAdapters
Criar consultas TableAdapter parametrizadas
20/11/2021 • 2 minutes to read

Uma consulta parametrizada retorna dados que atendem às condições de uma cláusula WHERE dentro da
consulta. Por exemplo, você pode parametrizar uma lista de clientes para exibir apenas clientes em uma
determinada cidade, adicionando WHERE City = @City ao final da instrução SQL que retorna uma lista de
clientes.
Você cria consultas de TableAdapter com parâmetros no Designer de conjunto de dados . você também pode
criá-los em um aplicativo Windows com o comando parametrizar fonte de dados no menu dados . O
comando parametrizar fonte de dados cria controles no formulário onde você pode inserir os valores de
parâmetro e executar a consulta.

NOTE
Ao construir uma consulta parametrizada, use a notação de parâmetro específica para o banco de dados com o qual você
está codificando. Por exemplo, acesso e fontes dados OleDb usam o ponto de interrogação '?' para denotar parâmetros,
portanto, a cláusula WHERE seria algo como: WHERE City = ? .

Criar uma consulta TableAdapter parametrizada

Para criar uma consulta parametrizada no Designer de Conjunto de Dados
Crie um novo TableAdapter, adicionando uma cláusula WHERE com os parâmetros desejados à instrução
SQL. Para obter mais informações, consulte criar e configurar TableAdapters.
-ou-
Acrescente uma consulta a um TableAdapter existente, adicionando uma cláusula WHERE com os
parâmetros desejados à instrução SQL.
Para criar uma consulta parametrizada durante a criação de um formulário com associação de dados
1. Selecione um controle no seu formulário que já esteja associado a um conjunto de dados. para obter
mais informações, consulte associar controles de Windows Forms a dados em Visual Studio.
2. No menu dados , selecione Adicionar consulta .
3. Preencha a caixa de diálogo Pesquisar Construtor de Critérios , adicionando uma cláusula WHERE
com os parâmetros desejados à instrução SQL.
Adicionar uma consulta a um formulário associado a dados existente
1. Abra o formulário no Designer de Formulários do Windows .
2. No menu dados , selecione Adicionar marcas inteligentes de consulta ou de dados.

NOTE
Se Adicionar Consulta não estiver disponível no menu Dados , selecione um controle no formulário que exibe a
fonte de dados no qual deseja adicionar a parametrização. Por exemplo, se o formulário exibir dados em um
controle DataGridView, selecione-o. Se o formulário exibir dados em controles individuais, selecione qualquer
controle associado a dados.
3. Na área selecionar tabela de fonte de dados , selecione a tabela à qual você deseja adicionar a
parametrização.
4. Digite um nome na caixa Nome da nova consulta ao criar uma nova consulta.
-ou-
Selecione uma consulta na caixa Nome da consulta existente .
5. Na caixa de texto consulta , digite uma consulta que aceite parâmetros.
6. Selecione OK .
Um controle para inserir o parâmetro e um botão Carregar são adicionados ao formulário em um
controle ToolStrip.
Consultar valores nulos
Os parâmetros do TableAdapter podem ser atribuídos a valores nulos quando você deseja consultar registros
que não têm valor atual. Por exemplo, considere a seguinte consulta que tem um ShippedDate parâmetro em
sua WHERE cláusula:

SELECT CustomerID, OrderDate, ShippedDate

FROM Orders
WHERE (ShippedDate = @ShippedDate) OR (ShippedDate IS NULL)

Se essa fosse uma consulta em um TableAdapter, você poderia consultar todos os pedidos que não foram
enviados com o seguinte código:

ordersTableAdapter.FillByShippedDate(northwindDataSet.Orders, null);

OrdersTableAdapter.FillByShippedDate(NorthwindDataSet.Orders, Nothing)

Para habilitar uma consulta para aceitar valores nulos:

1. Na Designer de conjunto de dados , selecione a consulta do TableAdapter que precisa aceitar valores
de parâmetro nulos.
2. Na janela Propriedades , selecione parâmetros e clique no botão de reticências (...) para abrir o Editor
de coleção de parâmetros .
3. Selecione o parâmetro que permite valores nulos e defina a propriedade AllowDBNull como true .

Confira também
Preencher conjuntos de dados usando TableAdapters
Acessar o banco de dados diretamente com um
TableAdapter
20/11/2021 • 2 minutes to read

Além dos InsertCommand UpdateCommand DeleteCommand TableAdapters, e, são criados com métodos que podem
ser executados diretamente no banco de dados. Você pode chamar esses métodos ( TableAdapter.Insert ,
TableAdapter.Update e TableAdapter.Delete ) para manipular dados diretamente no banco de dado.

Se você não quiser criar esses métodos diretos, defina a propriedade do TableAdapter GenerateDbDirectMethods
como false na janela Propriedades . Se qualquer consulta for adicionada a um TableAdapter além da
consulta principal do TableAdapter, elas serão consultas autônomas que não geram esses DbDirect métodos.

Enviar comandos diretamente para um banco de dados

Chame o DbDirect método TableAdapter que executa a tarefa que você está tentando realizar.
Para inserir novos registros diretamente em um banco de dados
Chame o método do TableAdapter Insert , passando os valores para cada coluna como parâmetros. O
procedimento a seguir usa a Region tabela no banco de dados Northwind como um exemplo.

NOTE
Se você não tiver uma instância disponível, crie uma instância do TableAdapter que você deseja usar.

Dim regionTableAdapter As New NorthwindDataSetTableAdapters.RegionTableAdapter

regionTableAdapter.Insert(5, "NorthWestern")

NorthwindDataSetTableAdapters.RegionTableAdapter regionTableAdapter =
new NorthwindDataSetTableAdapters.RegionTableAdapter();

regionTableAdapter.Insert(5, "NorthWestern");

Para atualizar registros diretamente em um banco de dados

Chame o método do TableAdapter Update , passando os valores novos e originais para cada coluna
como parâmetros.

NOTE
Se você não tiver uma instância disponível, crie uma instância do TableAdapter que você deseja usar.

Dim regionTableAdapter As New NorthwindDataSetTableAdapters.RegionTableAdapter

regionTableAdapter.Update(1, "East", 1, "Eastern")

NorthwindDataSetTableAdapters.RegionTableAdapter regionTableAdapter =
new NorthwindDataSetTableAdapters.RegionTableAdapter();

regionTableAdapter.Update(1, "East", 1, "Eastern");

Para excluir registros diretamente de um banco de dados

Chame o método do TableAdapter Delete , passando os valores de cada coluna como parâmetros do
Delete método. O procedimento a seguir usa a Region tabela no banco de dados Northwind como um
exemplo.

NOTE
Se você não tiver uma instância disponível, crie uma instância do TableAdapter que você deseja usar.

Dim regionTableAdapter As New NorthwindDataSetTableAdapters.RegionTableAdapter

regionTableAdapter.Delete(5, "NorthWestern")

NorthwindDataSetTableAdapters.RegionTableAdapter regionTableAdapter =
new NorthwindDataSetTableAdapters.RegionTableAdapter();

regionTableAdapter.Delete(5, "NorthWestern");

Confira também
Preencher conjuntos de dados usando TableAdapters
Desabilitar restrições ao preencher um conjunto de
dados
20/11/2021 • 2 minutes to read

Se um conjunto de um dataset contiver restrições (como restrições Foreign-Key), eles poderão gerar erros
relacionados à ordem das operações executadas no conjunto de um. Por exemplo, carregar registros filho antes
de carregar registros pai relacionados pode violar uma restrição e causar um erro. Assim que você carregar um
registro filho, a restrição verificará o registro pai relacionado e gerará um erro.
Se não houver nenhum mecanismo para permitir a suspensão de restrição temporária, um erro será gerado
toda vez que você tentar carregar um registro na tabela filho. Outra maneira de suspender todas as restrições
em um conjunto de um DataSet é com as BeginEdit EndEdit Propriedades e.

NOTE
Eventos de validação (por exemplo, ColumnChanging e RowChanging ) não serão gerados quando as restrições forem
desativadas.

Para suspender restrições de atualização programaticamente

O exemplo a seguir mostra como desativar temporariamente a verificação de restrição em um conjunto
de uma:

dataSet1.EnforceConstraints = false;
// Perform some operations on the dataset
dataSet1.EnforceConstraints = true;

DataSet1.EnforceConstraints = False
' Perform some operations on the dataset
DataSet1.EnforceConstraints = True

Para suspender restrições de atualização usando o Designer de

Conjunto de Dados
1. Abra o conjunto de dados no Designer de Conjunto de Dados . Para obter mais informações, consulte
Walkthrough: Criando um conjunto de dados no designer de conjunto de dados.
2. Na janela Propriedades , defina a EnforceConstraints propriedade como false .

Confira também
Preencher conjuntos de dados usando TableAdapters
Relacionamentos em conjuntos de dados
Estender a funcionalidade de um TableAdapter
20/11/2021 • 2 minutes to read

Você pode estender a funcionalidade de um TableAdapter adicionando código ao arquivo de classe parcial do
TableAdapter.
O código que define um TableAdapter é regenerado quando quaisquer alterações são feitas no TableAdapter no
Designer de Conjunto de Dados ou quando um assistente modifica a configuração de um TableAdapter. Para
impedir que seu código seja excluído durante a regeneração de um TableAdapter, adicione código ao arquivo de
classe parcial do TableAdapter.
Classes parciais permitem que o código para uma classe específica seja dividido entre vários arquivos físicos.
Para obter mais informações, consulte Parcial ou parcial (Tipo).

Localizar TableAdapters no código

Embora TableAdapters sejam projetados com o Designer de Conjunto de Dados , as classes TableAdapter
geradas não são classes aninhadas de DataSet . TableAdapters estão localizados em um namespace com base no
nome do conjuntos de dados associado do TableAdapter. Por exemplo, se seu aplicativo contiver um conjuntos
de dados chamado HRDataSet , os TableAdapters estarão localizados no HRDataSetTableAdapters namespace . (A
convenção de nomenlagem segue este padrão: DatasetName + TableAdapters ).
O exemplo a seguir supõe que um TableAdapter CustomersTableAdapter chamado está em um projeto com
NorthwindDataSet .

Para criar uma classe parcial para um TableAdapter

1. Adicione uma nova classe ao seu projeto indo para o menu Project e selecionando Adicionar Classe .
2. Nome da classe CustomersTableAdapterExtended .
3. Selecione Adicionar .
4. Substitua o código pelo namespace correto e pelo nome de classe parcial para seu projeto da seguinte
maneira:

namespace NorthwindDataSetTableAdapters
{
public partial class CustomersTableAdapter
{
// Add user code here. For example:
public override string ToString()
{
return "Overridden in the partial class.";
}
}
}
Namespace NorthwindDataSetTableAdapters

Partial Class CustomersTableAdapter

' Add user code here. For example:

Public Overrides Function ToString() As String
Return "Overridden in the partial class."
End Function
End Class
End Namespace

Confira também
Preencher conjuntos de dados usando TableAdapters
Ler dados XML em um conjunto de dados
20/11/2021 • 4 minutes to read

ADO.NET fornece métodos simples para trabalhar com dados XML. Neste passo a passo, você cria um aplicativo
Windows que carrega dados XML em um conjuntos de dados. O conjuntos de dados é exibido em um
DataGridView controle . Por fim, um esquema XML com base no conteúdo do arquivo XML é exibido em uma
caixa de texto.

Criar um novo projeto

Crie um novo projeto Windows Aplicativo de Formulários para C# ou Visual Basic. Nomeia o projeto
ReadingXML.

Gerar o arquivo XML a ser lido no conjuntos de dados

Como este passo a passo se concentra na leitura de dados XML em um conjuntos de dados, o conteúdo de um
arquivo XML é fornecido.
1. No menu Projeto , selecione Adicionar novo item .
2. Selecione Arquivo XML , nomeia o arquivo authors.xml e, em seguida, selecione Adicionar .
O arquivo XML é carregado no designer e está pronto para edição.
3. Colar os seguintes dados XML no editor abaixo da declaração XML:
<Authors_Table>
<authors>
<au_id>172-32-1176</au_id>
<au_lname>White</au_lname>
<au_fname>Johnson</au_fname>
<phone>408 496-7223</phone>
<address>10932 Bigge Rd.</address>
<city>Menlo Park</city>
<state>CA</state>
<zip>94025</zip>
<contract>true</contract>
</authors>
<authors>
<au_id>213-46-8915</au_id>
<au_lname>Green</au_lname>
<au_fname>Margie</au_fname>
<phone>415 986-7020</phone>
<address>309 63rd St. #411</address>
<city>Oakland</city>
<state>CA</state>
<zip>94618</zip>
<contract>true</contract>
</authors>
<authors>
<au_id>238-95-7766</au_id>
<au_lname>Carson</au_lname>
<au_fname>Cheryl</au_fname>
<phone>415 548-7723</phone>
<address>589 Darwin Ln.</address>
<city>Berkeley</city>
<state>CA</state>
<zip>94705</zip>
<contract>true</contract>
</authors>
<authors>
<au_id>267-41-2394</au_id>
<au_lname>Hunter</au_lname>
<au_fname>Anne</au_fname>
<phone>408 286-2428</phone>
<address>22 Cleveland Av. #14</address>
<city>San Jose</city>
<state>CA</state>
<zip>95128</zip>
<contract>true</contract>
</authors>
<authors>
<au_id>274-80-9391</au_id>
<au_lname>Straight</au_lname>
<au_fname>Dean</au_fname>
<phone>415 834-2919</phone>
<address>5420 College Av.</address>
<city>Oakland</city>
<state>CA</state>
<zip>94609</zip>
<contract>true</contract>
</authors>
</Authors_Table>

4. No menu Arquivo, selecione Salvar authors.xml .

Criar a interface do usuário

A interface do usuário para este aplicativo consiste no seguinte:
Um DataGridView controle que exibe o conteúdo do arquivo XML como dados.
Um TextBox controle que exibe o esquema XML para o arquivo XML.
Dois Button controles.
Um botão lê o arquivo XML no conjuntos de dados e o exibe no DataGridView controle .
Um segundo botão extrai o esquema do conjuntos de dados e, por meio de um, o StringWriter
exibe no TextBox controle .
Para adicionar controles ao formulário
1. Abra Form1 na exibição de design.
2. Na Caixa de Ferramentas, arraste os seguintes controles para o formulário:
Um DataGridView controle
Um TextBox controle
Dois Button controles
3. Defina as seguintes propriedades:

C O N T RO L P RO P RIEDA DE C O N F IGURA Ç Ã O

TextBox1 Multilinha true

ScrollBars Ver tical

Button1 Nome ReadXmlButton

Text Read XML

Button2 Nome ShowSchemaButton

Text Show Schema

Criar o conjuntos de dados que recebe os dados XML

Nesta etapa, você criará um novo conjuntos de dados chamado authors . Para obter mais informações sobre
conjuntos de dados, consulte Ferramentas de conjuntos de dados no Visual Studio.
1. No Gerenciador de Soluções , selecione o arquivo de origem para Form1 e, em seguida, selecione o
botão Designer de Exibição na barra de Gerenciador de Soluções ferramentas.
2. Na Caixa de Ferramentas, guia Dados, arraste um DataSet para Form1.
3. Na caixa de diálogo Adicionar Conjuntos de Dados, selecione Conjuntos de dados sem tipo e, em
seguida, selecione OK.
DataSet1 é adicionado à bandeja de componentes.
4. Na janela Propriedades, de definido o Nome e DataSetName as propriedades para AuthorsDataSet .

Criar o manipulador de eventos para ler o arquivo XML no conjuntos

de dados
O botão Ler XML lê o arquivo XML no conjuntos de dados. Em seguida, ele define propriedades no
DataGridView controle que a vinculam ao conjunto de dados.
1. No Gerenciador de Soluções , selecione Form1 e, em seguida, selecione o botão Designer de
Exibição na barra de Gerenciador de Soluções ferramentas.
2. Selecione o botão Ler XML.
O Editor de Códigos é aberto no manipulador de ReadXmlButton_Click eventos.
3. Digite o seguinte código no manipulador ReadXmlButton_Click de eventos:

private void ReadXmlButton_Click(object sender, EventArgs e)

{
string filePath = "Complete path where you saved the XML file";

AuthorsDataSet.ReadXml(filePath);

dataGridView1.DataSource = AuthorsDataSet;
dataGridView1.DataMember = "authors";
}

Private Sub ReadXmlButton_Click() Handles ReadXmlButton.Click

Dim filePath As String = "Complete path where you saved the XML file"

AuthorsDataSet.ReadXml(filePath)

DataGridView1.DataSource = AuthorsDataSet
DataGridView1.DataMember = "authors"
End Sub

4. No código ReadXMLButton_Click do manipulador de eventos, altere filepath = a entrada para o caminho

correto.

Criar o manipulador de eventos para exibir o esquema na caixa de

texto
O botão Mostrar Esquema cria um objeto que é preenchido com o esquema e é exibido no controle
StringWriter TextBox .
1. No Gerenciador de Soluções , selecione Form1 e, em seguida, selecione o Designer de Exibição de
seleção.
2. Selecione o botão Mostrar Esquema.
O Editor de Códigos é aberto no manipulador de ShowSchemaButton_Click eventos.
3. Colar o código a seguir no manipulador ShowSchemaButton_Click de eventos.

private void ShowSchemaButton_Click(object sender, EventArgs e)

{
System.IO.StringWriter swXML = new System.IO.StringWriter();
AuthorsDataSet.WriteXmlSchema(swXML);
textBox1.Text = swXML.ToString();
}
Private Sub ShowSchemaButton_Click() Handles ShowSchemaButton.Click

Dim swXML As New System.IO.StringWriter()

AuthorsDataSet.WriteXmlSchema(swXML)
TextBox1.Text = swXML.ToString
End Sub

Testar o formulário
Agora, é possível testar o formulário para garantir que ele se comporta da forma esperada.
1. Selecione F5 para executar o aplicativo.
2. Selecione o botão Ler XML.
O DataGridView exibe o conteúdo do arquivo XML.
3. Selecione o botão Mostrar Esquema.
A caixa de texto exibe o esquema XML para o arquivo XML.

Próximas etapas
Este passo a passo ensina os conceitos básicos da leitura de um arquivo XML em um conjuntos de dados, bem
como a criação de um esquema com base no conteúdo do arquivo XML. Aqui estão algumas tarefas que você
pode realizar a seguir:
Edite os dados no conjuntos de dados e escreva-os novamente como XML. Para obter mais informações,
consulte WriteXml.
Edite os dados no conjuntos de dados e escreva-os em um banco de dados.

Confira também
Acessar dados no Visual Studio
Ferramentas XML no Visual Studio
Editar dados em conjuntos de dados
20/11/2021 • 5 minutes to read

Você edita dados em tabelas de dados da mesma forma que edita os dados em uma tabela em qualquer banco
de dado. O processo pode incluir inserção, atualização e exclusão de registros na tabela. Em um formulário
vinculado a dados, você pode especificar quais campos são editáveis pelo usuário. Nesses casos, a infraestrutura
de ligação de dados lida com todo o controle de alterações para que as alterações possam ser enviadas de volta
para o banco mais tarde. Se você fizer edições programaticamente nos dados e pretende enviar essas alterações
de volta ao banco de dado, deverá usar os objetos e métodos que fazem o controle de alterações para você.
Além de alterar os dados reais, você também pode consultar um DataTable para retornar linhas específicas de
dados. Por exemplo, você pode consultar linhas individuais, versões específicas de linhas (originais e propostas),
linhas que foram alteradas ou linhas com erros.

Para editar linhas em um conjunto de registros

Para editar uma linha existente em um DataTable , você precisa localizar o DataRow que deseja editar e, em
seguida, atribuir os valores atualizados às colunas desejadas.
Se você não souber o índice da linha que deseja editar, use o FindBy método para pesquisar pela chave
primária:

NorthwindDataSet.CustomersRow customersRow =
northwindDataSet1.Customers.FindByCustomerID("ALFKI");

customersRow.CompanyName = "Updated Company Name";

customersRow.City = "Seattle";;

Dim customersRow As NorthwindDataSet.CustomersRow

customersRow = NorthwindDataSet1.Customers.FindByCustomerID("ALFKI")

customersRow.CompanyName = "Updated Company Name"

customersRow.City = "Seattle"

Se você souber o índice de linha, poderá acessar e editar as linhas da seguinte maneira:

northwindDataSet1.Customers[4].CompanyName = "Updated Company Name";

northwindDataSet1.Customers[4].City = "Seattle";

NorthwindDataSet1.Customers(4).CompanyName = "Updated Company Name"

NorthwindDataSet1.Customers(4).City = "Seattle"

Para inserir novas linhas em um conjunto de registros

Os aplicativos que usam controles vinculados a dados normalmente adicionam novos registros por meio do
botão Adicionar novo em um controle BindingNavigator.
Para adicionar manualmente novos registros a um DataSet, crie uma nova linha de dados chamando o método
na DataTable. Em seguida, adicione a linha à DataRow coleção ( Rows ) do DataTable :
NorthwindDataSet.CustomersRow newCustomersRow =
northwindDataSet1.Customers.NewCustomersRow();

newCustomersRow.CustomerID = "ALFKI";
newCustomersRow.CompanyName = "Alfreds Futterkiste";

northwindDataSet1.Customers.Rows.Add(newCustomersRow);

Dim newCustomersRow As NorthwindDataSet.CustomersRow

newCustomersRow = NorthwindDataSet1.Customers.NewCustomersRow()

newCustomersRow.CustomerID = "ALFKI"
newCustomersRow.CompanyName = "Alfreds Futterkiste"

NorthwindDataSet1.Customers.Rows.Add(newCustomersRow)

Para manter as informações que o conjunto de dados precisa para enviar atualizações para a fonte, use o Delete
método para remover linhas em uma tabela de dados. Por exemplo, se seu aplicativo usa um TableAdapter (ou
DataAdapter ), o método do TableAdapter Update exclui linhas no banco de dados que têm um RowState de
Deleted .
Se seu aplicativo não precisar enviar atualizações de volta para uma fonte de dados, será possível remover os
registros acessando diretamente a coleção de linhas de dados ( Remove ).
Para excluir registros de uma tabela de dados
Chame o Delete método de a DataRow .
Esse método não remove fisicamente o registro. Em vez disso, ele marca o registro para exclusão.

NOTE
Se você obtiver a propriedade Count de um DataRowCollection , a contagem resultante incluirá os registros que
foram marcados para exclusão. Para obter uma contagem precisa de registros que não estão marcados para
exclusão, você pode executar um loop na coleção examinando a RowState propriedade de cada registro. (Os
registros marcados para exclusão têm um RowState de Deleted .) Como alternativa, você pode criar um modo de
exibição de dados de um DataSet que filtra com base no estado de linha e obter a propriedade Count a partir daí.

O exemplo a seguir mostra como chamar o Delete método para marcar a primeira linha na Customers tabela
como excluída:

northwindDataSet1.Customers.Rows[0].Delete();

NorthwindDataSet1.Customers.Rows(0).Delete()

Determinar se há linhas alteradas

Quando são feitas alterações nos registros em um conjunto de dados, as informações sobre essas alterações
são armazenadas até você confirmá-las. As alterações são confirmadas quando você chama o AcceptChanges
método de um conjunto de dados ou de uma tabela data, ou quando você chama o Update método de um
TableAdapter ou adaptador de dados.
As alterações são controladas de duas maneiras em cada linha de dados:
Cada linha de dados contém informações relacionadas ao seu RowState (por exemplo,,, Added Modified
Deleted ou Unchanged ).
Cada linha de dados alterada contém várias versões dessa linha ( DataRowVersion ), a versão original
(antes das alterações) e a versão atual (após as alterações). Durante o período em que uma alteração está
pendente (a hora em que você pode responder ao RowChanging evento), uma terceira versão — a versão
proposta — também está disponível.
O HasChanges método de um conjunto de um DataSet retorna true se foram feitas alterações no DataSet.
Depois de determinar que as linhas alteradas existem, você pode chamar o GetChanges método de um DataSet
ou DataTable retornar um conjunto de linhas alteradas.
Para determinar se foram feitas alterações em qualquer linha
Chame o HasChanges método de um conjunto de registros para verificar se há linhas alteradas.
O exemplo a seguir mostra como verificar o valor de retorno do HasChanges método para detectar se há linhas
alteradas em um conjunto de registros chamado NorthwindDataset1 :

if (northwindDataSet1.HasChanges())
{
// Changed rows were detected, add appropriate code.
}
else
{
// No changed rows were detected, add appropriate code.
}

If NorthwindDataSet1.HasChanges() Then

' Changed rows were detected, add appropriate code.

Else
' No changed rows were detected, add appropriate code.
End If

Determinar o tipo de alterações

Você também pode verificar para ver quais tipos de alterações foram feitas em um conjunto de um DataSet,
passando um valor da DataRowState enumeração para o HasChanges método.
Para determinar que tipo de alterações foram feitas em uma linha
Passe um DataRowState valor para o HasChanges método.
O exemplo a seguir mostra como verificar um conjunto de NorthwindDataset1 registros chamado para
determinar se alguma nova linha foi adicionada a ele:

if (northwindDataSet1.HasChanges(DataRowState.Added))
{
// New rows have been added to the dataset, add appropriate code.
}
else
{
// No new rows have been added to the dataset, add appropriate code.
}
If NorthwindDataSet1.HasChanges(DataRowState.Added) Then

' New rows have been added to the dataset, add appropriate code.
Else
' No new rows have been added to the dataset, add appropriate code.
End If

Para localizar linhas com erros

Ao trabalhar com colunas individuais e linhas de dados, você pode encontrar erros. Você pode verificar a
HasErrors propriedade para determinar se há erros em um DataSet , DataTable ou DataRow .

1. Verifique a HasErrors propriedade para ver se há erros no conjunto de os.

2. Se a HasErrors propriedade for true , itere pelas coleções de tabelas e, em seguida, as pelas linhas, para
localizar a linha com o erro.

private void FindErrors()

{
if (dataSet1.HasErrors)
{
foreach (DataTable table in dataSet1.Tables)
{
if (table.HasErrors)
{
foreach (DataRow row in table.Rows)
{
if (row.HasErrors)
{
// Process error here.
}
}
}
}
}
}

Private Sub FindErrors()

Dim table As Data.DataTable
Dim row As Data.DataRow

If DataSet1.HasErrors Then

For Each table In DataSet1.Tables

If table.HasErrors Then

For Each row In table.Rows

If row.HasErrors Then

' Process error here.

End If
Next
End If
Next
End If
End Sub

Confira também
Ferramentas de conjunto de dados no Visual Studio
Validar dados em conjuntos de dados
20/11/2021 • 11 minutes to read

A validação de dados é o processo de confirmar que os valores inseridos em objetos de dados estão em
conformidade com as restrições no esquema de um DataSet. O processo de validação também confirma que
esses valores estão seguindo as regras que foram estabelecidas para seu aplicativo. É uma boa prática validar os
dados antes de enviar atualizações para o banco de dados subjacente. Isso reduz erros, bem como o número
potencial de viagens de ida e volta entre um aplicativo e o banco de dados.
Você pode confirmar se os dados que estão sendo gravados em um DataSet são válidos por meio da criação de
verificações de validação no conjunto de dados em si. O DataSet pode verificar os dados independentemente de
como a atualização está sendo executada — seja diretamente por controles em um formulário, dentro de um
componente ou de alguma outra maneira. Como o conjunto de dados faz parte do seu aplicativo
(diferentemente do back-end do banco de dados), é um local lógico para criar a validação específica do
aplicativo.
O melhor local para adicionar validação ao seu aplicativo é no arquivo de classe parcial do conjunto de um. No
Visual Basic ou Visual C# , abra o Designer de conjunto de dados e clique duas vezes na coluna ou tabela
para a qual você deseja criar a validação. Essa ação cria automaticamente um ColumnChanging RowChanging
manipulador de eventos ou.

Validar os dados
A validação dentro de um conjunto de uma é feita das seguintes maneiras:
Criando sua própria validação específica do aplicativo que pode verificar valores em uma coluna de
dados individual durante as alterações. Para obter mais informações, consulte como: validar dados
durante alterações de coluna.
Criando sua própria validação específica do aplicativo que pode verificar os dados em valores enquanto
uma linha de dados inteira está sendo alterada. Para obter mais informações, consulte como: validar
dados durante alterações de linha.
Criando chaves, restrições exclusivas e assim por diante como parte da definição de esquema real do
conjunto de dados.
Definindo as propriedades do DataColumn objeto, como MaxLength , AllowDBNull e Unique .
Vários eventos são gerados pelo DataTable objeto quando uma alteração está ocorrendo em um registro:
Os ColumnChanging ColumnChanged eventos e são gerados durante e após cada alteração em uma coluna
individual. O ColumnChanging evento é útil quando você deseja validar as alterações em colunas específicas.
As informações sobre a alteração proposta são passadas como um argumento com o evento.
Os RowChanging RowChanged eventos e são gerados durante e após qualquer alteração em uma linha. O
RowChanging evento é mais geral. Isso indica que uma alteração está ocorrendo em algum lugar na linha,
mas você não sabe qual coluna foi alterada.
Por padrão, cada alteração em uma coluna, portanto, gera quatro eventos. O primeiro é o ColumnChanging e os
ColumnChanged eventos para a coluna específica que está sendo alterada. Em seguida, estão os RowChanging
RowChanged eventos e. Se várias alterações estiverem sendo feitas na linha, os eventos serão gerados para
cada alteração.
NOTE
O método da linha de dados BeginEdit desativa os RowChanging RowChanged eventos e após cada alteração de coluna
individual. Nesse caso, o evento não é gerado até que o EndEdit método seja chamado, quando os RowChanging eventos
e RowChanged são gerados apenas uma vez. Para obter mais informações, consulte desativar restrições ao preencher um
conjunto dedados.

O evento escolhido depende de quão granular você deseja que a validação seja. Se for importante que você
capture um erro imediatamente quando uma coluna for alterada, crie a validação usando o ColumnChanging
evento. Caso contrário, use o RowChanging evento, o que pode resultar na captura de vários erros ao mesmo
tempo. Além disso, se os dados forem estruturados para que o valor de uma coluna seja validado com base no
conteúdo de outra coluna, execute sua validação durante o RowChanging evento.
Quando os registros são atualizados, o DataTable objeto gera eventos que você pode responder à medida que
as alterações estão ocorrendo e depois que as alterações são feitas.
Se seu aplicativo usar um dataset tipado, você poderá criar manipuladores de eventos com rigidez de tipos. Isso
adiciona quatro eventos tipados adicionais para os quais você pode criar manipuladores:
dataTableNameRowChanging ,, dataTableNameRowChanged dataTableNameRowDeleting e dataTableNameRowDeleted .
Esses manipuladores de eventos tipados passam um argumento que inclui os nomes de coluna da tabela que
facilitam a gravação e a leitura do código.

Eventos de atualização de dados

EVEN TO DESC RIÇ Ã O

ColumnChanging O valor em uma coluna está sendo alterado. O evento passa

a linha e a coluna para você, juntamente com o novo valor
proposto.

ColumnChanged O valor em uma coluna foi alterado. O evento passa a linha

e a coluna para você, juntamente com o valor proposto.

RowChanging As alterações feitas em um DataRow objeto estão prestes a

ser confirmadas de volta no conjunto de informações. Se
você não tiver chamado o BeginEdit método, o
RowChanging evento será gerado para cada alteração em
uma coluna imediatamente após o ColumnChanging evento
ser gerado. Se você chamou BeginEdit antes de fazer
alterações, o RowChanging evento será gerado somente
quando você chamar o EndEdit método.

O evento passa a linha para você, junto com um valor que

indica que tipo de ação (alterar, inserir e assim por diante)
está sendo executado.

RowChanged Uma linha foi alterada. O evento passa a linha para você,
junto com um valor que indica que tipo de ação (alterar,
inserir e assim por diante) está sendo executado.

RowDeleting Uma linha está sendo excluída. O evento passa a linha para
você, junto com um valor que indica que tipo de ação
(Delete) está sendo executado.
EVEN TO DESC RIÇ Ã O

RowDeleted Uma linha foi excluída. O evento passa a linha para você,
junto com um valor que indica que tipo de ação (Delete) está
sendo executado.

Os ColumnChanging RowChanging eventos, e RowDeleting são gerados durante o processo de atualização.

Você pode usar esses eventos para validar dados ou executar outros tipos de processamento. Como a
atualização está em andamento durante esses eventos, você pode cancelá-la lançando uma exceção, o que
impede a conclusão da atualização.
Os ColumnChanged RowChanged eventos e RowDeleted são eventos de notificação que são gerados quando a
atualização é concluída com êxito. Esses eventos são úteis quando você deseja realizar uma ação adicional com
base em uma atualização bem-sucedida.

Validar dados durante alterações de coluna

NOTE
O Designer de conjunto de dados cria uma classe parcial na qual a lógica de validação pode ser adicionada a um
conjunto de uma. O conjunto de conjuntos gerado pelo designer não exclui nem altera nenhum código na classe parcial.

Você pode validar os dados quando o valor em uma coluna de dados é alterado respondendo ao
ColumnChanging evento. Quando gerado, esse evento passa um argumento de evento ( ProposedValue ) que
contém o valor que está sendo proposto para a coluna atual. Com base no conteúdo de e.ProposedValue , você
pode:
Aceite o valor proposto fazendo nada.
Rejeite o valor proposto definindo o erro de coluna ( SetColumnError ) de dentro do manipulador de
eventos de alteração de coluna.
Opcionalmente, use um ErrorProvider controle para exibir uma mensagem de erro para o usuário. Para
obter mais informações, confira Componente ErrorProvider.
A validação também pode ser executada durante o RowChanging evento.

Validar dados durante as alterações de linha

Você pode escrever código para verificar se cada coluna que você deseja validar contém dados que atendem aos
requisitos do seu aplicativo. Faça isso definindo a coluna para indicar que ela contém um erro se um valor
proposto for inaceitável. Os exemplos a seguir definem um erro de coluna quando a Quantity coluna é 0 ou
menor. Os manipuladores de eventos de alteração de linha devem se parecer com os exemplos a seguir.
Para validar dados quando uma linha é alterada (Visual Basic)
1. Abra o conjunto de dados no Designer de Conjunto de Dados . Para obter mais informações, consulte
Walkthrough: Criando um conjunto de dados no designer de conjunto de dados.
2. Clique duas vezes na barra de título da tabela que você deseja validar. Essa ação cria automaticamente o
RowChanging manipulador de eventos do DataTable no arquivo de classe parcial do conjunto de um.
TIP
Clique duas vezes à esquerda do nome da tabela para criar o manipulador de eventos de alteração de linha. Se
você clicar duas vezes no nome da tabela, poderá editá-lo.

Private Sub Order_DetailsDataTable_Order_DetailsRowChanging(

ByVal sender As System.Object,
ByVal e As Order_DetailsRowChangeEvent
) Handles Me.Order_DetailsRowChanging

If CType(e.Row.Quantity, Short) <= 0 Then

e.Row.SetColumnError("Quantity", "Quantity must be greater than 0")
Else
e.Row.SetColumnError("Quantity", "")
End If
End Sub

Para validar dados quando uma linha é alterada (C#)

1. Abra o conjunto de dados no Designer de Conjunto de Dados . Para obter mais informações, consulte
Walkthrough: Criando um conjunto de dados no designer de conjunto de dados.
2. Clique duas vezes na barra de título da tabela que você deseja validar. Essa ação cria um arquivo de classe
parcial para o DataTable .

NOTE
O Designer de conjunto de dados não cria automaticamente um manipulador de eventos para o
RowChanging evento. Você precisa criar um método para manipular o RowChanging evento e executar o código
para vincular o evento no método de inicialização da tabela.

3. Copie o código a seguir para a classe parcial:

public override void EndInit()

{
base.EndInit();
Order_DetailsRowChanging += TestRowChangeEvent;
}

public void TestRowChangeEvent(object sender, Order_DetailsRowChangeEvent e)

{
if ((short)e.Row.Quantity <= 0)
{
e.Row.SetColumnError("Quantity", "Quantity must be greater than 0");
}
else
{
e.Row.SetColumnError("Quantity", "");
}
}

Para recuperar linhas alteradas

Cada linha em uma tabela de dados tem uma RowState propriedade que controla o estado atual dessa linha
usando os valores na DataRowState enumeração. Você pode retornar linhas alteradas de um conjunto de dados
ou tabela de data chamando o GetChanges método de um DataSet ou DataTable . Você pode verificar se existem
alterações antes de chamar chamando GetChanges o HasChanges método de um DataSet.
NOTE
Depois de confirmar as alterações em um conjunto de dados ou em uma tabela Data (chamando o AcceptChanges
método), o GetChanges método não retorna nenhum dado. Se seu aplicativo precisar processar linhas alteradas, você
deverá processar as alterações antes de chamar o AcceptChanges método.

Chamar o GetChanges método de um DataSet ou uma tabela de dados retorna um novo DataSet ou tabela de
dados que contém somente os registros que foram alterados. Se você quiser obter registros específicos — por
exemplo, apenas novos registros ou somente registros modificados — você pode passar um valor da
DataRowState enumeração como um parâmetro para o GetChanges método.
Use a DataRowVersion enumeração para acessar as diferentes versões de uma linha (por exemplo, os valores
originais que estavam em uma linha antes de processá-la).
Para obter todos os registros alterados de um conjunto de uma
Chame o GetChanges método de um DataSet.
O exemplo a seguir cria um novo conjunto de changedRecords recursos chamado e o popula com todos
os registros alterados de outro DataSet chamado dataSet1 .

DataSet changedRecords = dataSet1.GetChanges();

Dim changedRecords As DataSet = DataSet1.GetChanges()

Para obter todos os registros alterados de uma tabela de dados

Chame o GetChanges método de uma DataTable.
O exemplo a seguir cria uma nova tabela de dados chamada changedRecordsTable e a preenche com
todos os registros alterados de outra tabela de dados chamada dataTable1 .

DataTable changedRecordsTable = dataTable1.GetChanges();

Dim changedRecordsTable As DataTable = dataTable1.GetChanges()

Para obter todos os registros que têm um estado de linha específico

Chame o GetChanges método de uma tabela de dados ou de um DataSet e passe um DataRowState valor
de enumeração como um argumento.
O exemplo a seguir mostra como criar um novo conjunto de addedRecords recursos chamado e
preenchê-lo somente com os registros que foram adicionados ao conjunto de um dataSet1 .

DataSet addedRecords = dataSet1.GetChanges(DataRowState.Added);

Dim addedRecords As DataSet = DataSet1.GetChanges(DataRowState.Added)

O exemplo a seguir mostra como retornar todos os registros que foram adicionados recentemente à
Customers tabela:
private NorthwindDataSet.CustomersDataTable GetNewRecords()
{
return (NorthwindDataSet.CustomersDataTable)
northwindDataSet1.Customers.GetChanges(DataRowState.Added);
}

Private Function GetNewRecords() As NorthwindDataSet.CustomersDataTable

Return CType(NorthwindDataSet1.Customers.GetChanges(Data.DataRowState.Added),
NorthwindDataSet.CustomersDataTable)
End Function

Acessar a versão original de uma DataRow

Quando são feitas alterações nas linhas de dados, o conjunto de registros retém as versões original ( Original ) e
New ( Current ) da linha. Por exemplo, antes de chamar o AcceptChanges método, seu aplicativo pode acessar as
diferentes versões de um registro (conforme definido na DataRowVersion Enumeração) e processar as
alterações de acordo.

NOTE
Versões diferentes de uma linha existem somente após serem editadas e antes da chamada do AcceptChanges método.
Depois que o AcceptChanges método for chamado, as versões atuais e originais serão as mesmas.

Passar o DataRowVersion valor junto com o índice de coluna (ou nome de coluna como uma cadeia de
caracteres) retorna o valor da versão de linha específica dessa coluna. A coluna alterada é identificada durante
ColumnChanging os ColumnChanged eventos e. Esse é um bom momento para inspecionar as diferentes
versões de linha para fins de validação. No entanto, se você suspendeu temporariamente as restrições, esses
eventos não serão gerados e será necessário identificar de forma programática quais colunas foram alteradas.
Você pode fazer isso Iterando pela Columns coleção e comparando os DataRowVersion valores diferentes.
Para obter a versão original de um registro
Acesse o valor de uma coluna passando o DataRowVersion da linha que você deseja retornar.
O exemplo a seguir mostra como usar um DataRowVersion valor para obter o valor original de um
CompanyName campo em um DataRow :

string originalCompanyName;
originalCompanyName = northwindDataSet1.Customers[0]
["CompanyName", DataRowVersion.Original].ToString();

Dim originalCompanyName = NorthwindDataSet1.Customers(0)(

"CompanyName", DataRowVersion.Original).ToString()

Acessar a versão atual de uma DataRow

Para obter a versão atual de um registro
Acesse o valor de uma coluna e, em seguida, adicione um parâmetro ao índice que indica qual versão de
uma linha você deseja retornar.
O exemplo a seguir mostra como usar um DataRowVersion valor para obter o valor atual de um
CompanyName campo em um DataRow :

string currentCompanyName;
currentCompanyName = northwindDataSet1.Customers[0]
["CompanyName", DataRowVersion.Current].ToString();

Dim currentCompanyName = NorthwindDataSet1.Customers(0)(

"CompanyName", DataRowVersion.Current).ToString()

Confira também
Ferramentas de conjunto de dados no Visual Studio
como: validar dados no controle Windows Forms DataGridView
como exibir ícones de erro para validação de formulário com o componente Windows Forms ErrorProvider
Salvar dados novamente no banco de dados
20/11/2021 • 19 minutes to read

O conjuntos de dados é uma cópia de dados na memória. Se você modificar esses dados, será uma boa prática
salvar essas alterações de volta no banco de dados. Você faz isso de uma das três maneiras:
Chamando um dos métodos Update de um TableAdapter
Chamando um dos DBDirect métodos do TableAdapter
Chamando o método no TableAdapterManager que Visual Studio gera para você quando o conjuntos de
dados contém tabelas relacionadas a outras tabelas no conjuntos UpdateAll de dados
Quando você vincula tabelas de conjuntos de dados a controles Windows formulário ou XAML, a arquitetura de
associação de dados faz todo o trabalho para você.
Se você estiver familiarizado com TableAdapters, poderá ir diretamente para um destes tópicos:

TÓ P IC O DESC RIÇ Ã O

Inserir novos registros em um banco de dados Como executar atualizações e inserções usando objetos
TableAdapters ou Command

Atualizar dados usando um TableAdapter Como executar atualizações com TableAdapters

Atualização hierárquica Como executar atualizações de um conjuntos de dados com

duas ou mais tabelas relacionadas

Tratar uma exceção de simultaneidade Como tratar exceções quando dois usuários tentam alterar
os mesmos dados em um banco de dados ao mesmo tempo

Como salvar dados usando uma transação Como salvar dados em uma transação usando o sistema.
Namespace de transações e um objeto TransactionScope

Salvando dados em uma transação Passo a passo que cria um aplicativo Windows Forms para
demonstrar como salvar dados em um banco de dados
dentro de uma transação

Salvar dados em um banco de dados (várias tabelas) Como editar registros e salvar alterações em várias tabelas
de volta no banco de dados

Salvar dados de um objeto em um banco de dados Como passar dados de um objeto que não está em um
conjuntos de dados para um banco de dados usando um
método TableAdapter DbDirect

Salvar os dados com os métodos TableAdapter DBDirect Como usar o TableAdapter para enviar SQL diretamente ao
banco de dados

Salvar um conjunto de dados como XML Como salvar um conjuntos de dados em um documento
XML

Atualizações em duas fases

Atualizar uma fonte de dados é um processo de duas etapas. A primeira etapa é atualizar o conjuntos de dados
com novos registros, registros alterados ou registros excluídos. Se o aplicativo nunca enviar essas alterações de
volta para a fonte de dados, você terminará a atualização.
Se você enviar as alterações de volta para o banco de dados, uma segunda etapa será necessária. Se você não
estiver usando controles vinculados a dados, será necessário chamar manualmente o método do mesmo
TableAdapter (ou adaptador de dados) usado para popular o conjuntos Update de dados. No entanto, você
também pode usar adaptadores diferentes, por exemplo, para mover dados de uma fonte de dados para outra
ou para atualizar várias fontes de dados. Se você não estiver usando associação de dados e estiver salvando
alterações para tabelas relacionadas, será preciso inciar manualmente uma variável da classe gerada
automaticamente e, em seguida, chamar TableAdapterManager seu UpdateAll método.

Um conjunto de dados contém coleções de tabelas, que contêm uma coleção de linhas. Se você pretende
atualizar uma fonte de dados subjacente posteriormente, deverá usar os métodos na propriedade ao
DataTable.DataRowCollection adicionar ou remover linhas. Esses métodos executam o controle de alterações
necessário para atualizar a fonte de dados. Se você chamar a coleção na propriedade Linhas, a exclusão não será
RemoveAt comunicada de volta ao banco de dados.

Mesclar conjuntos de dados

Você pode atualizar o conteúdo de um conjuntos de dados mesclando-o com outro. Isso envolve copiar o
conteúdo de um conjuntos de dados de origem para o conjuntos de dados de chamada (conhecido como o
conjuntos de dados de destino). Quando você mescla conjuntos de dados, novos registros no conjuntos de
dados de origem são adicionados ao conjuntos de dados de destino. Além disso, colunas extras no conjuntos de
dados de origem são adicionadas ao conjuntos de dados de destino. Mesclar conjuntos de dados é útil quando
você tem um conjuntos de dados local e recebe um segundo conjuntos de dados de outro aplicativo. Também é
útil quando você recebe um segundo conjuntos de dados de um componente, como um serviço Web XML, ou
quando você precisa integrar dados de vários conjuntos de dados.
Ao mesclar conjuntos de dados, você pode passar um argumento booliana ( ) que informa ao método se as
modificações existentes devem ser reter no preserveChanges conjuntos de dados de Merge destino. Como os
conjuntos de dados mantêm várias versões de registros, é importante ter em mente que mais de uma versão
dos registros está sendo mesclada. A tabela a seguir mostra como um registro em dois conjuntos de dados é
mesclado:
DATA RO W VERSIO N C O N JUN TO DE DA DO S DE DEST IN O C O N JUN TO DE DA DO S DE O RIGEM

Original James Wilson James C. Wilson

Current Jim Wilson James C. Wilson

Chamar o Merge método na tabela anterior com resulta nos seguintes

preserveChanges=false targetDataset.Merge(sourceDataset) dados:

DATA RO W VERSIO N C O N JUN TO DE DA DO S DE DEST IN O C O N JUN TO DE DA DO S DE O RIGEM

Original James C. Wilson James C. Wilson

Current James C. Wilson James C. Wilson

Chamar o Merge método com resulta nos seguintes

preserveChanges = true targetDataset.Merge(sourceDataset, true) dados:

DATA RO W VERSIO N C O N JUN TO DE DA DO S DE DEST IN O C O N JUN TO DE DA DO S DE O RIGEM

Original James C. Wilson James C. Wilson

Current Jim Wilson James C. Wilson

Cau t i on

No cenário, se o método for chamado em um registro no conjuntos de dados de destino, ele será reverenciado
para os dados originais do conjuntos de dados preserveChanges = true RejectChanges de origem. Isso significa
que, se você tentar atualizar a fonte de dados original com o conjuntos de dados de destino, talvez ela não
consiga encontrar a linha original a ser atualizada. Você pode impedir uma violação de competência
preenchendo outro conjuntos de dados com os registros atualizados da fonte de dados e, em seguida,
executando uma mesclagem para evitar uma violação de competência. (Uma violação de competência ocorre
quando outro usuário modifica um registro na fonte de dados depois que o conjuntos de dados é preenchido.)

Atualizar restrições
Para fazer alterações em uma linha de dados existente, adicione ou atualize dados nas colunas individuais. Se o
conjuntos de dados contiver restrições (como chaves estrangeiras ou restrições não anuladas), é possível que o
registro possa estar temporariamente em um estado de erro conforme você o atualiza. Ou seja, ele pode estar
em um estado de erro depois que você terminar de atualizar uma coluna, mas antes de chegar à próxima.
Para evitar violações prematuras de restrição, você pode suspender temporariamente as restrições de
atualização. Isso serve a duas finalidades:
Ele impede que um erro seja lançado depois que você terminar de atualizar uma coluna, mas ainda não
começou a atualizar outra.
Ele impede que determinados eventos de atualização sejam gerados (eventos que geralmente são usados
para validação).

NOTE
No Windows Forms, a arquitetura de associação de dados que é criada no datagrid suspende a verificação de restrição até
que o foco saia de uma linha e você não precisa chamar explicitamente os métodos BeginEdit EndEdit , ou CancelEdit .
As restrições são desabilitadas automaticamente quando o Merge método é invocado em um conjunto de uma.
Quando a mesclagem for concluída, se houver alguma restrição no conjunto de um que não possa ser
habilitado, um ConstraintException será gerado. Nessa situação, a EnforceConstraints propriedade é definida
como false, e todas as violações de restrição devem ser resolvidas antes de redefinir a EnforceConstraints
propriedade para true .
Depois de concluir uma atualização, você pode reabilitar a verificação de restrição, que também habilita
novamente os eventos de atualização e os gera.
Para obter mais informações sobre como suspender eventos, consulte desativar restrições ao preencher um
conjunto dedados.

Erros de atualização do conjunto de atualizações

Quando você atualiza um registro em um conjunto de registros, há a possibilidade de um erro. Por exemplo,
você pode, inadvertidamente, gravar dados do tipo errado em uma coluna ou dados muito longos ou dados que
tenham algum outro problema de integridade. Ou, você pode ter verificações de validação específicas do
aplicativo que podem gerar erros personalizados durante qualquer estágio de um evento de atualização. Para
obter mais informações, consulte Validate data in DataSets.

Manter informações sobre alterações

As informações sobre as alterações em um conjunto de dados são mantidas de duas maneiras: sinalizando
linhas que indicam que foram alteradas ( RowState ) e mantendo várias cópias de um registro ( DataRowVersion
). Usando essas informações, os processos podem determinar o que foi alterado no conjunto de dados e podem
enviar as atualizações apropriadas para a fonte.
Propriedade RowState
A RowState propriedade de um DataRow objeto é um valor que fornece informações sobre o status de uma
linha de dados específica.
A tabela a seguir detalha os possíveis valores da DataRowState enumeração:

VA LO R DE DATA RO W STAT E DESC RIÇ Ã O

Added A linha foi adicionada como um item a um

DataRowCollection . (Uma linha nesse estado não tem uma
versão original correspondente, pois ela não existia quando
o último AcceptChanges método foi chamado).

Deleted A linha foi excluída usando o Delete de um DataRow objeto.

Detached A linha foi criada, mas não faz parte de nenhum

DataRowCollection. Um DataRow objeto está nesse estado
imediatamente após ele ter sido criado, antes de ser
adicionado a uma coleção e depois de ser removido de uma
coleção.

Modified Um valor de coluna na linha foi alterado de alguma forma.

Unchanged A linha não foi alterada desde a última chamada a

AcceptChanges.

Enumeração DataRowVersion
Os conjuntos de valores mantêm várias versões de registros. Os DataRowVersion campos são usados ao
recuperar o valor encontrado em um DataRow usando a Item[] propriedade ou o GetChildRows método do
DataRow objeto.
A tabela a seguir detalha os possíveis valores da DataRowVersion enumeração:

VA LO R DE DATA RO W VERSIO N DESC RIÇ Ã O

Current A versão atual de um registro contém todas as modificações

que foram executadas no registro desde a última vez que o
AcceptChanges foi chamado. Se a linha tiver sido excluída,
não haverá nenhuma versão atual.

Default O valor padrão de um registro, conforme definido pelo

esquema ou pela fonte de dados do conjunto.

Original A versão original de um registro é uma cópia do registro

como foi a última vez que as alterações foram confirmadas
no conjunto de registros. Em termos práticos, normalmente
essa é a versão de um registro como lido de uma fonte de
dados.

Proposed A versão proposta de um registro que está disponível

temporariamente enquanto você está no meio de uma
atualização — ou seja, entre a hora em que você chamou o
BeginEdit método e o EndEdit método. Normalmente, você
acessa a versão proposta de um registro em um
manipulador para um evento, como RowChanging . Invocar
o CancelEdit método reverte as alterações e exclui a versão
proposta da linha de dados.

As versões original e atual são úteis quando as informações de atualização são transmitidas para uma fonte de
dados. Normalmente, quando uma atualização é enviada para a fonte de dados, as novas informações do banco
de dado estão na versão atual de um registro. As informações da versão original são usadas para localizar o
registro a ser atualizado.
Por exemplo, em um caso em que a chave primária de um registro é alterada, você precisa de uma maneira de
localizar o registro correto na fonte de dados para atualizar as alterações. Se nenhuma versão original existir, o
registro provavelmente será acrescentado à fonte de dados, resultando não apenas em um registro adicional
indesejado, mas em um registro que não é preciso e desatualizado. As duas versões também são usadas no
controle de simultaneidade. Você pode comparar a versão original com um registro na fonte de dados para
determinar se o registro foi alterado desde que ele foi carregado no conjunto.
A versão proposta é útil quando você precisa executar a validação antes de realmente confirmar as alterações
no conjunto de os.
Mesmo que os registros tenham mudado, nem sempre há versões originais ou atuais dessa linha. Quando você
insere uma nova linha na tabela, não há nenhuma versão original, apenas uma versão atual. Da mesma forma,
se você excluir uma linha chamando o método da tabela Delete , haverá uma versão original, mas nenhuma
versão atual.
Você pode testar para ver se existe uma versão específica de um registro consultando o método de uma linha de
dados HasVersion . Você pode acessar qualquer uma das versões de um registro, passando um DataRowVersion
valor de enumeração como um argumento opcional ao solicitar o valor de uma coluna.

Obter registros alterados

É uma prática comum não atualizar todos os registros em um conjunto de um. por exemplo, um usuário pode
estar trabalhando com um controle de Windows Forms DataGridView que exibe vários registros. No entanto, o
usuário pode atualizar apenas alguns registros, excluir um e inserir um novo. DataSets e tabelas de dados
fornecem um método ( GetChanges ) para retornar apenas as linhas que foram modificadas.
Você pode criar subconjuntos de registros alterados usando o GetChanges método de uma tabela de dados (
GetChanges ) ou do conjunto ( GetChanges ). Se você chamar o método para a tabela de dados, ele retornará
uma cópia da tabela com apenas os registros alterados. Da mesma forma, se você chamar o método no
conjunto de registros, obterá um novo conjunto de novos com os registros alterados.
GetChanges por si só, retorna todos os registros alterados. Por outro lado, ao passar o desejado DataRowState
como um parâmetro para o GetChanges método, você pode especificar qual subconjunto de registros alterados
deseja: registros recém-adicionados, registros que são marcados para exclusão, registros desanexados ou
registros modificados.
Obter um subconjunto de registros alterados é útil quando você deseja enviar registros para outro componente
para processamento. Em vez de enviar o conjunto de registros inteiro, você pode reduzir a sobrecarga de
comunicação com o outro componente obtendo apenas os registros de que o componente precisa.

Confirmar alterações no conjunto de

Conforme as alterações são feitas no conjunto de registros, a RowState propriedade das linhas alteradas é
definida. As versões original e atual dos registros são estabelecidas, mantidas e disponibilizadas para você pela
RowVersion propriedade. Os metadados armazenados nas propriedades dessas linhas alteradas são necessários
para enviar as atualizações corretas para a fonte de dados.
Se as alterações refletirem o estado atual da fonte de dados, você não precisará mais manter essas informações.
Normalmente, há duas ocasiões em que o conjunto de e sua fonte estão em sincronia:
Imediatamente após você ter carregado as informações no conjunto de dados, como quando você lê o
dado da origem.
Depois de enviar as alterações do conjunto de dados para a origem (mas não antes, porque você perderia
as informações de alteração necessárias para enviar alterações ao banco de dado).
Você pode confirmar as alterações pendentes para o conjunto de acordo chamando o AcceptChanges método.
Normalmente, AcceptChanges é chamado nos seguintes horários:
Depois de carregar o conjunto de um. Se você carregar um conjunto de um dataset chamando o método
de um TableAdapter Fill , o adaptador automaticamente confirmará as alterações para você. No
entanto, se você carregar um conjunto de um DataSet mesclando outro conjunto de um para ele,
precisará confirmar as alterações manualmente.

NOTE
Você pode impedir que o adaptador confirme automaticamente as alterações ao chamar o Fill método
definindo a AcceptChangesDuringFill Propriedade do adaptador como false . Se for definido como false ,
o RowState de cada linha inserida durante o preenchimento será definido como Added .

Depois de enviar alterações de conjunto de um para outro processo, como um serviço Web XML.
Cau t i on

Confirmar a alteração dessa forma apaga qualquer informação de alteração. Não confirme as alterações
até concluir a execução de operações que exigem que seu aplicativo saiba quais alterações foram feitas
no conjunto de aplicativos.
Esse método realiza o seguinte:
Grava a Current versão de um registro em sua Original versão e substitui a versão original.
Remove qualquer linha para a qual a RowState propriedade está definida Deleted .
Define a RowState propriedade de um registro como Unchanged .
O AcceptChanges método está disponível em três níveis. Você pode chamá-lo em um DataRow objeto para
confirmar as alterações apenas dessa linha. Você também pode chamá-lo em um DataTable objeto para
confirmar todas as linhas de uma tabela. Por fim, você pode chamá-lo no DataSet objeto para confirmar todas
as alterações pendentes em todos os registros de todas as tabelas do conjunto de recursos.
A tabela a seguir descreve quais alterações são confirmadas com base em qual objeto o método é chamado:

M ÉTO DO RESULTA DO

System.Data.DataRow.AcceptChanges As alterações são confirmadas somente na linha específica.

System.Data.DataTable.AcceptChanges As alterações são confirmadas em todas as linhas na tabela

específica.

System.Data.DataSet.AcceptChanges As alterações são confirmadas em todas as linhas em todas

as tabelas do conjunto de registros.

NOTE
Se você carregar um conjunto de um dataset chamando o método de um TableAdapter Fill , não precisará aceitar as
alterações explicitamente. Por padrão, o Fill método chama o AcceptChanges método depois de concluir o
preenchimento da tabela de dados.

Um método relacionado, RejectChanges , desfaz o efeito das alterações copiando a Original versão de volta para
a Current versão dos registros. Ele também define o RowState de cada registro de volta para Unchanged .

Validação de dados
Para verificar se os dados em seu aplicativo atendem aos requisitos dos processos para os quais ele foi passado,
muitas vezes você precisa adicionar a validação. Isso pode envolver a verificação de que a entrada de um
usuário em um formulário está correta, Validando os dados que são enviados ao seu aplicativo por outro
aplicativo ou até mesmo verificando se as informações calculadas em seu componente se enquadram nas
restrições da fonte de dados e dos requisitos do aplicativo.
Você pode validar os dados de várias maneiras:
Na camada de negócios, adicionando código ao seu aplicativo para validar dados. O conjunto de espaço
de os é um lugar que você pode fazer. O conjunto de recursos fornece algumas das vantagens da
validação de back-end, como a capacidade de validar alterações, pois os valores de coluna e de linha
estão sendo alterados. Para obter mais informações, consulte Validate data in DataSets.
Na camada de apresentação, adicionando validação a formulários. para obter mais informações, consulte
validação de entrada do usuário em Windows Forms.
No back-end de dados, enviando dados para a fonte de dados — por exemplo, o banco de dado — e
permitindo que ele aceite ou rejeite os dados. Se você estiver trabalhando com um banco de dados que
tenha recursos sofisticados para validação de dado e fornecimento de informações de erro, isso pode ser
uma abordagem prática porque você pode validar os dados independentemente de onde eles vêm. No
entanto, essa abordagem pode não acomodar requisitos de validação específicos do aplicativo. Além
disso, ter a fonte de dados validar dados pode resultar em várias viagens de ida e volta para a fonte de
dados, dependendo de como seu aplicativo facilita a resolução de erros de validação gerados pelo back-
end.

IMPORTANT
Ao usar comandos de dados com uma CommandType propriedade definida como Text , verifique cuidadosamente
as informações enviadas de um cliente antes de passá-las para o banco de dados. Usuários maliciosos podem
tentar enviar (injetar) instruções SQL modificadas ou adicionais para obter acesso não autorizado ou para danificar
o banco de dados. Antes de transferir a entrada do usuário para um banco de dados, sempre verifique se as
informações são válidas. É uma prática recomendada sempre usar consultas parametrizadas ou procedimentos
armazenados quando possível.

Transmitir atualizações para a fonte de dados

Depois que as alterações tiverem sido feitas em um conjunto de dados, você poderá transmitir as alterações
para uma fonte. Normalmente, você faz isso chamando o Update método de um TableAdapter (ou adaptador de
dados). O método percorre cada registro em uma tabela de dados, determina qual tipo de atualização é
necessário (Update, INSERT ou Delete), se houver, e executa o comando apropriado.
Como uma ilustração de como as atualizações são feitas, suponha que seu aplicativo use um conjunto de dados
que contenha uma única tabela. O aplicativo busca duas linhas do banco de dados. Após a recuperação, a tabela
de dados na memória tem esta aparência:

(RowState) CustomerID Name Status

(Unchanged) c200 Robert Lyon Good
(Unchanged) c400 Nancy Buchanan Pending

Seu aplicativo altera o status de Nancy Buchanan para "preferencial". Como resultado dessa alteração, o valor da
RowState propriedade para essa linha muda de Unchanged para Modified . O valor da RowState propriedade
para a primeira linha permanece Unchanged . A tabela de dados agora tem esta aparência:

(RowState) CustomerID Name Status

(Unchanged) c200 Robert Lyon Good
(Modified) c400 Nancy Buchanan Preferred

Agora, seu aplicativo chama o Update método para transmitir o conjunto de dados para o Database. O método
inspeciona cada linha por vez. para a primeira linha, o método transmite nenhuma instrução SQL para o banco
de dados, pois essa linha não foi alterada desde que foi obtida originalmente do banco de dados.
No entanto, para a segunda linha, o Update método invoca automaticamente o comando de dados correto e o
transmite para o banco de dado. a sintaxe específica da instrução SQL depende do dialeto de SQL com suporte
no armazenamento de dados subjacente. mas, as seguintes características gerais da declaração de SQL
transmitida são importantes:
a instrução de SQL transmitida é uma instrução UPDATE. O adaptador sabe usar uma instrução UPDATE
porque o valor da RowState propriedade é Modified .
a instrução de SQL transmitida inclui uma cláusula where que indica que o destino da instrução UPDATE
é a linha em que CustomerID = 'c400' . Essa parte da instrução SELECT distingue a linha de destino de
todas as outras porque a CustomerID é a chave primária da tabela de destino. As informações da cláusula
WHERE são derivadas da versão original do registro ( DataRowVersion.Original ), caso os valores
necessários para identificar a linha tenham sido alterados.
a instrução de SQL transmitida inclui a cláusula SET, para definir os novos valores das colunas
modificadas.
NOTE
se a propriedade do TableAdapter UpdateCommand tiver sido definida como o nome de um procedimento
armazenado, o adaptador não construirá uma instrução SQL. Em vez disso, ele invoca o procedimento
armazenado com os parâmetros apropriados passados.

Passar parâmetros
Normalmente, você usa parâmetros para passar os valores para os registros que serão atualizados no banco de
dados. Quando o método do TableAdapter Update executa uma instrução UPDATE, ele precisa preencher os
valores de parâmetro. Ele obtém esses valores da Parameters coleção para o comando de dados apropriado —
nesse caso, o UpdateCommand objeto no TableAdapter.
se você usou as ferramentas de Visual Studio para gerar um adaptador de dados, o UpdateCommand objeto
contém uma coleção de parâmetros que correspondem a cada espaço reservado de parâmetro na instrução.
A System.Data.SqlClient.SqlParameter.SourceColumn propriedade de cada parâmetro aponta para uma coluna
na tabela de dados. Por exemplo, a SourceColumn propriedade para os au_id Original_au_id parâmetros e é
definida como qualquer coluna na tabela de dados que contenha a ID do autor. Quando o método do adaptador
Update é executado, ele lê a coluna ID do autor do registro que está sendo atualizado e preenche os valores na
instrução.
Em uma instrução UPDATE, você precisa especificar os novos valores (aqueles que serão gravados no registro),
bem como os valores antigos (para que o registro possa ser localizado no banco de dados). Há, portanto, dois
parâmetros para cada valor: um para a cláusula SET e outro para a cláusula WHERE. Ambos os parâmetros lêem
dados do registro que está sendo atualizado, mas eles obtêm versões diferentes do valor da coluna com base na
Propriedade do parâmetro SourceVersion . O parâmetro da cláusula SET Obtém a versão atual e o parâmetro da
cláusula WHERE Obtém a versão original.

NOTE
Você também pode definir valores na Parameters coleção por conta própria no código, que normalmente faria em um
manipulador de eventos para o evento do adaptador de dados RowChanging .

Confira também
Ferramentas de conjunto de dados no Visual Studio
Criar e configurar TableAdapters
Atualizar dados usando um TableAdapter
Associar controles a dados no Visual Studio
Validar os dados
Como: Adicionar, modificar e excluir entidades (WCF Data Services)
Inserir novos registros em um banco de dados
20/11/2021 • 3 minutes to read

Para inserir novos registros em um banco de dados, você pode usar o TableAdapter.Update método ou um dos
métodos DBDirect do TableAdapter (especificamente o TableAdapter.Insert método). Para obter mais
informações, consulte TableAdapter.
Se seu aplicativo não usar TableAdapters, você poderá usar objetos de comando (por exemplo, SqlCommand )
para inserir novos registros em seu banco de dados.
Se o seu aplicativo usa conjuntos de dados para armazenar, use o TableAdapter.Update método. O Update
método envia todas as alterações (atualizações, inserções e exclusões) para o banco de dados.
Se seu aplicativo usar objetos para armazenar dados, ou se você quiser um controle mais preciso sobre a
criação de novos registros no banco de dado, use o TableAdapter.Insert método.
Se o TableAdapter não tiver um Insert método, significa que o TableAdapter está configurado para usar
procedimentos armazenados ou sua GenerateDBDirectMethods propriedade é definida como false . Tente
definir a propriedade do TableAdapter GenerateDBDirectMethods para true de dentro do Designer de
conjunto de dados e salve o conjunto de os. Isso irá regenerar o TableAdapter. Se o TableAdapter ainda não
tiver um Insert método, a tabela provavelmente não fornecerá informações de esquema suficientes para
distinguir entre linhas individuais (por exemplo, pode não haver nenhuma chave primária definida na tabela).

Inserir novos registros usando TableAdapters

Os TableAdapters fornecem maneiras diferentes de inserir novos registros em um banco de dados, dependendo
dos requisitos do seu aplicativo.
Se o seu aplicativo usa conjuntos de dados para armazenar, você pode simplesmente adicionar novos registros
ao desejado DataTable no DataSet e, em seguida, chamar o TableAdapter.Update método. O
TableAdapter.Update método envia quaisquer alterações no DataTable banco de dados (incluindo registros
modificados e excluídos).
Para inserir novos registros em um banco de dados usando o método TableAdapter. Update
1. Adicione novos registros ao desejado DataTable criando um novo DataRow e adicionando-o à Rows
coleção.
2. Depois que as novas linhas forem adicionadas ao DataTable , chame o TableAdapter.Update método. Você
pode controlar a quantidade de dados a serem atualizados passando um inteiro DataSet , um DataTable ,
uma matriz de DataRow s ou um único DataRow .
O código a seguir mostra como adicionar um novo registro a um DataTable e, em seguida, chamar o
TableAdapter.Update método para salvar a nova linha no banco de dados. (Este exemplo usa a Region
tabela no banco de dados Northwind.)
' Create a new row.
Dim newRegionRow As NorthwindDataSet.RegionRow
newRegionRow = Me.NorthwindDataSet._Region.NewRegionRow()
newRegionRow.RegionID = 5
newRegionRow.RegionDescription = "NorthWestern"

' Add the row to the Region table

Me.NorthwindDataSet._Region.Rows.Add(newRegionRow)

' Save the new row to the database

Me.RegionTableAdapter.Update(Me.NorthwindDataSet._Region)

// Create a new row.

NorthwindDataSet.RegionRow newRegionRow;
newRegionRow = northwindDataSet.Region.NewRegionRow();
newRegionRow.RegionID = 5;
newRegionRow.RegionDescription = "NorthWestern";

// Add the row to the Region table

this.northwindDataSet.Region.Rows.Add(newRegionRow);

// Save the new row to the database

this.regionTableAdapter.Update(this.northwindDataSet.Region);

Para inserir novos registros em um banco de dados usando o método TableAdapter. Insert
Se seu aplicativo usa objetos para armazenar dados, você pode usar o TableAdapter.Insert método para criar
novas linhas diretamente no banco de dado. O Insert método aceita os valores individuais para cada coluna
como parâmetros. Chamar o método insere um novo registro no banco de dados com os valores de parâmetro
passados.
Chame o método do TableAdapter Insert , passando os valores para cada coluna como parâmetros.

O procedimento a seguir demonstra como usar o TableAdapter.Insert método para inserir linhas. Este exemplo
insere dados na Region tabela no banco de dado Northwind.

NOTE
Se você não tiver uma instância disponível, crie uma instância do TableAdapter que você deseja usar.

Dim regionTableAdapter As New NorthwindDataSetTableAdapters.RegionTableAdapter

regionTableAdapter.Insert(5, "NorthWestern")

NorthwindDataSetTableAdapters.RegionTableAdapter regionTableAdapter =
new NorthwindDataSetTableAdapters.RegionTableAdapter();

regionTableAdapter.Insert(5, "NorthWestern");

Inserir novos registros usando objetos de comando

Você pode inserir novos registros diretamente em um banco de dados usando objetos de comando.
Para inserir novos registros em um banco de dados usando objetos de comando
Crie um novo objeto de comando e, em seguida, defina suas Connection CommandType Propriedades, e
CommandText .

O exemplo a seguir demonstra a inserção de registros em um banco de dados usando o objeto Command. Ele
insere dados na Region tabela no banco de dado Northwind.

Dim sqlConnection1 As New System.Data.SqlClient.SqlConnection("YOUR CONNECTION STRING")

Dim cmd As New System.Data.SqlClient.SqlCommand

cmd.CommandType = System.Data.CommandType.Text
cmd.CommandText = "INSERT Region (RegionID, RegionDescription) VALUES (5, 'NorthWestern')"
cmd.Connection = sqlConnection1

sqlConnection1.Open()
cmd.ExecuteNonQuery()
sqlConnection1.Close()

System.Data.SqlClient.SqlConnection sqlConnection1 =
new System.Data.SqlClient.SqlConnection("YOUR CONNECTION STRING");

System.Data.SqlClient.SqlCommand cmd = new System.Data.SqlClient.SqlCommand();

cmd.CommandType = System.Data.CommandType.Text;
cmd.CommandText = "INSERT Region (RegionID, RegionDescription) VALUES (5, 'NorthWestern')";
cmd.Connection = sqlConnection1;

sqlConnection1.Open();
cmd.ExecuteNonQuery();
sqlConnection1.Close();

Segurança do .NET
Você deve ter acesso ao banco de dados ao qual está tentando se conectar, bem como permissão para executar
inserções na tabela desejada.

Confira também
Salvar dados novamente no banco de dados
Atualizar dados usando um TableAdapter
20/11/2021 • 2 minutes to read

Depois que os dados em seu conjuntos de dados foram modificados e validados, você pode enviar os dados
atualizados de volta para um banco de dados chamando o método de Update um TableAdapter. O método
atualiza uma única tabela de dados e executa o comando correto (INSERT, UPDATE ou DELETE) com base no de
cada Update linha de dados na RowState tabela. Quando um conjuntos de dados tem tabelas relacionadas,
Visual Studio gera uma classe TableAdapterManager que você usa para fazer as atualizações. A classe
TableAdapterManager garante que as atualizações sejam feitas na ordem correta com base nas restrições de
chave estrangeira definidas no banco de dados. Quando você usa controles associados a dados, a arquitetura de
databinding cria uma variável de membro da classe TableAdapterManager chamada tableAdapterManager.

NOTE
Ao tentar atualizar uma fonte de dados com o conteúdo de um conjuntos de dados, você pode obter erros. Para evitar
erros, recomendamos que você coloque o código que chama o método do Update adaptador dentro de um try /
catch bloco.

O procedimento exato para atualizar uma fonte de dados pode variar dependendo das necessidades de
negócios, mas inclui as seguintes etapas:
1. Chame o método do Update adaptador em um try / catch bloco.
2. Se uma exceção for capturada, localize a linha de dados que causou o erro.
3. Reconcilia o problema na linha de dados (programaticamente, se possível, ou apresentando a linha
inválida ao usuário para modificação) e tente a atualização novamente ( HasErrors , GetErrors ).

Salvar dados em um banco de dados

Chame o Update método de um TableAdapter. Passe o nome da tabela de dados que contém os valores a serem
gravados no banco de dados.
Para atualizar um banco de dados usando um TableAdapter
Coloque o método TableAdapter Update em um try / catch bloco. O exemplo a seguir mostra como
atualizar o conteúdo da Customers tabela em de dentro de um bloco NorthwindDataSet try / catch .

try
{
this.Validate();
this.customersBindingSource.EndEdit();
this.customersTableAdapter.Update(this.northwindDataSet.Customers);
MessageBox.Show("Update successful");
}
catch (System.Exception ex)
{
MessageBox.Show("Update failed");
}
Try
Me.Validate()
Me.CustomersBindingSource.EndEdit()
Me.CustomersTableAdapter.Update(Me.NorthwindDataSet.Customers)
MsgBox("Update successful")

Catch ex As Exception
MsgBox("Update failed")
End Try

Confira também
Salvar dados novamente no banco de dados
Atualização hierárquica
20/11/2021 • 8 minutes to read

A atualização hierárquica refere-se ao processo de salvar dados atualizados (de um DataSet com duas ou mais
tabelas relacionadas) de volta a um banco de dado, mantendo regras de integridade referencial. A integridade
referencial refere-se às regras de consistência fornecidas pelas restrições em um banco de dados que controlam
o comportamento de inserção, atualização e exclusão de registros relacionados. Por exemplo, é a integridade
referencial que impõe a criação de um registro de cliente antes de permitir que os pedidos sejam criados para
esse cliente. Para obter mais informações sobre relações em conjuntos de dados, consulte relações em
conjuntos dedados.
O recurso de atualização hierárquica usa um TableAdapterManager para gerenciar os TableAdapter s em um
dataset tipado. o TableAdapterManager componente é uma classe gerada Visual Studio, não um tipo .net. quando
você arrasta uma tabela da janela fontes de dados para um formulário Windows ou uma página do WPF,
Visual Studio adiciona uma variável do tipo tableadaptermanager ao formulário ou à página e você a vê no
designer na bandeja de componentes. Para obter informações detalhadas sobre a TableAdapterManager classe,
consulte a seção de referência do TableAdapterManager de TableAdapters.
Por padrão, um conjunto de testes trata tabelas relacionadas como "somente relações", o que significa que ela
não impõe restrições de chave estrangeira. Você pode modificar essa configuração em tempo de design usando
o Designer de conjunto de dados . Selecione a linha de relação entre duas tabelas para abrir a caixa de
diálogo relação . As alterações feitas aqui determinarão como o se TableAdapterManager comporta ao enviar as
alterações nas tabelas relacionadas de volta para o banco de dados.

Habilitar atualização hierárquica em um conjunto de um DataSet

Por padrão, a atualização hierárquica está habilitada para todos os novos conjuntos de valores que são
adicionados ou criados em um projeto. Ativar ou desativar a atualização hierárquica definindo a propriedade
Hierarchical Update de um dataset tipado no DataSet como true ou false :

Criar uma nova relação entre tabelas

Para criar uma nova relação entre duas tabelas, na Designer de Conjunto de Dados, selecione a barra de título
de cada tabela, clique com o botão direito do mouse e selecione Adicionar relação .
Entender as restrições de chave estrangeira, as atualizações em
cascata e as exclusões
É importante entender como as restrições de chave estrangeira e o comportamento em cascata no banco de
dados são criados no código do dataset gerado.
Por padrão, as tabelas de dados em um DataSet são geradas com relações ( DataRelation ) que correspondem às
relações no banco de dados. No entanto, a relação no DataSet não é gerada como uma restrição FOREIGN-KEY.
O DataRelation é configurado como somente relação sem UpdateRule ou DeleteRule em vigor.
Por padrão, as atualizações em cascata e as exclusões em cascata são desativadas mesmo que a relação de
banco de dados esteja definida com atualizações em cascata e/ou exclusões em cascata ativadas. Por exemplo,
criar um novo cliente e um novo pedido e, em seguida, tentar salvar os dados pode causar um conflito com as
restrições Foreign-Key que são definidas no Database. Para obter mais informações, consulte desativar
restrições ao preencher um conjunto dedados.

Definir a ordem para executar atualizações

Definir a ordem para executar atualizações define a ordem das inserções, atualizações e exclusões individuais
que são necessárias para salvar todos os dados modificados em todas as tabelas de um DataSet. Quando a
atualização hierárquica está habilitada, as inserções são executadas primeiro, depois as atualizações e, em
seguida, as exclusões. O TableAdapterManager fornece uma UpdateOrder propriedade que pode ser definida
para executar atualizações primeiro, depois insere e, em seguida, exclui.

NOTE
É importante entender que a ordem de atualização é tudo inclusiva. Ou seja, quando as atualizações são executadas,
inserções e exclusões são executadas para todas as tabelas no conjunto de conjuntos.

Para definir a UpdateOrder propriedade, depois de arrastar itens da janela fontes de dados para um formulário,
selecione o TableAdapterManager na bandeja de componentes e, em seguida, defina a UpdateOrder Propriedade
na janela Propriedades .

Criar uma cópia de backup de um conjunto de um DataSet antes de

executar uma atualização hierárquica
Quando você salva dados (chamando o TableAdapterManager.UpdateAll() método), as TableAdapterManager
tentativas de atualizar os dados para cada tabela em uma única transação. Se qualquer parte da atualização de
qualquer tabela falhar, toda a transação será revertida. Na maioria das situações, a reversão retorna o aplicativo
ao seu estado original.
No entanto, às vezes, talvez você queira restaurar o conjunto de os conjuntos de backup. Um exemplo disso
pode ocorrer quando você estiver usando valores de incremento automático. Por exemplo, se uma operação de
salvamento não for bem-sucedida, os valores de incremento automático não serão redefinidos no conjunto de e
o conjunto de um continuará criando valores de incremento automático. Isso deixa uma lacuna na numeração
que pode não ser aceitável em seu aplicativo. Em situações em que esse é um problema, o TableAdapterManager
fornece uma BackupDataSetBeforeUpdate propriedade que substitui o conjunto de um existente por uma cópia
de backup se a transação falhar.

NOTE
A cópia de backup só está na memória enquanto o TableAdapterManager.UpdateAll método está em execução.
Portanto, não há nenhum acesso programático a esse conjunto de backups porque ele substitui o conjunto de um
original ou sai do escopo assim que o TableAdapterManager.UpdateAll método termina de ser executado.

Modificar o código de salvamento gerado para executar a atualização

hierárquica
Salve as alterações das tabelas relacionadas de dados no conjunto de dados para o banco de dados chamando o
método TableAdapterManager.UpdateAll e passando no nome do conjunto de dados que contém as tabelas
relacionadas. Por exemplo, execute o método TableAdapterManager.UpdateAll(NorthwindDataset) para enviar
atualizações de todas as tabelas no NorthwindDataset para o banco de dados back-end.
Depois de soltar os itens da janela Fontes de Dados , o código é automaticamente adicionado ao evento
Form_Load para preencher cada tabela (os métodos TableAdapter.Fill ). O código também é adicionado ao
evento de clique do botão Salvar do BindingNavigator para salvar os dados do conjunto de dados de volta ao
banco de dados (o método TableAdapterManager.UpdateAll ).
O código salvar gerado também contém uma linha de código que chama o método
CustomersBindingSource.EndEdit . Mais especificamente, ele chama o EndEdit método do primeiro BindingSource
que é adicionado ao formulário. Em outras palavras, esse código só é gerado para a primeira tabela que é
arrastada da janela fontes de dados para o formulário. A chamada EndEdit confirma as alterações que estão
em processo em qualquer controle de associação de dados sendo editado no momento. Portanto, se um
controle associado a dados ainda estiver em foco e você clicar no botão Salvar , todas as edições pendentes
nesse controle serão confirmadas antes da gravação real (o método TableAdapterManager.UpdateAll ).

NOTE
O Designer de conjunto de dados apenas adiciona o BindingSource.EndEdit código para a primeira tabela que é
descartada no formulário. Portanto, é necessário adicionar uma linha de código para chamar o método
BindingSource.EndEdit para cada tabela relacionada no formulário. Para este passo a passo, isso significa que você
precisa adicionar uma chamada ao método OrdersBindingSource.EndEdit .

Para atualizar o código para confirmar as alterações às tabelas relacionadas antes de salvar
1. Clique duas vezes no botão Salvar no BindingNavigator para abrir Form1 no Editor de Códigos.
2. Adicione uma linha de código para chamar o método OrdersBindingSource.EndEdit após a linha que
chama o método CustomersBindingSource.EndEdit . O código no evento de clique do botão Salvar deve
ser semelhante ao seguinte:
Me.Validate()
Me.CustomersBindingSource.EndEdit()
Me.OrdersBindingSource.EndEdit()
Me.TableAdapterManager.UpdateAll(Me.NorthwindDataSet)

this.Validate();
this.customersBindingSource.EndEdit();
this.ordersBindingSource.EndEdit();
this.tableAdapterManager.UpdateAll(this.northwindDataSet);

Além de confirmar as alterações em uma tabela filho relacionada antes de salvar dados em um banco de dados,
você também pode confirmar registros pais recém-criados antes de adicionar novos registros filhos a um
conjunto de dados. Em outras palavras, talvez seja necessário adicionar o novo registro pai ( Customer ) ao
conjunto de registros antes que as restrições de chave estrangeira permitam que novos registros filho ( Orders
) sejam adicionados ao conjunto de recursos. Para realizar isso, você pode usar o evento filho
BindingSource.AddingNew .

NOTE
Se você precisa confirmar novos registros pai depende do tipo de controle usado para associar à fonte de dados. Neste
tutorial, você usa controles individuais para associar à tabela pai. Isso requer o código adicional para confirmar o novo
registro pai. Se os registros pai foram exibidos em um controle de associação complexo como o DataGridView , essa
EndEdit chamada adicional para o registro pai não seria necessária. Isso porque a funcionalidade subjacente de associação
de dados do controle processa a confirmação dos novos registros.

Para adicionar código para confirmar registros pais no conjunto de dados antes de adicionar novos registros
filhos
1. Crie um manipulador de eventos para o evento OrdersBindingSource.AddingNew .
Abra o Form1 no modo de exibição de design, selecione OrdersBindingSource na bandeja de
componentes, selecione eventos na janela Propriedades e clique duas vezes no evento
AddingNew .
2. Adicione uma linha de código ao manipulador de eventos que chama o CustomersBindingSource.EndEdit
método. O código no manipulador de eventos OrdersBindingSource_AddingNew deve ser semelhante ao
seguinte:

Me.CustomersBindingSource.EndEdit()

this.customersBindingSource.EndEdit();

Referência do TableAdaptermanager
Por padrão, uma TableAdapterManager classe é gerada quando você cria um conjunto de um DataSet que
contém tabelas relacionadas. Para impedir que a classe seja gerada, altere o valor da Hierarchical Update
Propriedade do conjunto de valores para false. quando você arrasta uma tabela que tem uma relação na
superfície de design de um formulário de Windows ou página do WPF, Visual Studio declara uma variável de
membro da classe. Se você não usar DataBinding, será necessário declarar manualmente a variável.
A TableAdapterManager classe não é um tipo .net. Portanto, você não pode procurar na documentação. Ele é
criado no momento do design como parte do processo de criação do conjunto de um.
A seguir estão os métodos e as propriedades usados com frequência da TableAdapterManager classe:

M EM B RO DESC RIÇ Ã O

Método UpdateAll Salva todos os dados de todas as tabelas de dados.

Propriedade BackUpDataSetBeforeUpdate Determina se deve ser criada uma cópia de backup do

conjunto de um antes da execução do
TableAdapterManager.UpdateAll método. Boolean.

TableName TableAdapter Propriedade Representa um TableAdapter. O gerado

TableAdapterManager contém uma propriedade para cada
uma TableAdapter gerencia. Por exemplo, um conjunto de
um DataSet com uma tabela Customers e Orders é gerado
com um TableAdapterManager que contém
CustomersTableAdapter e OrdersTableAdapter
Propriedades.

Propriedade UpdateOrder Controla a ordem dos comandos individuais INSERT, Update

e Delete. Defina isso para um dos valores na
TableAdapterManager.UpdateOrderOption enumeração.

Por padrão, o UpdateOrder é definido como

Inser tUpdateDelete . Isso significa que inserções,
atualizações e, em seguida, exclusões são executadas para
todas as tabelas no DataSet.

Confira também
Salvar dados novamente no banco de dados
Tratar uma exceção de simultaneidade
20/11/2021 • 9 minutes to read

As exceções de concurrency ( ) são ativas quando dois usuários tentam alterar os mesmos dados em um banco
de dados System.Data.DBConcurrencyException ao mesmo tempo. Neste passo a passo, você cria um aplicativo
Windows que ilustra como capturar um , localizar a linha que causou o erro e aprender uma estratégia de como
lidar DBConcurrencyException com ele.
Este passo a passo leva você pelo seguinte processo:
1. Para criar um novo projeto de Aplicativo do Windows Forms .
2. Crie um novo conjuntos de dados com base na tabela Clientes da Northwind.
3. Crie um formulário com um DataGridView para exibir os dados.
4. Preencha um conjuntos de dados com os dados da tabela Clientes no banco de dados Northwind.
5. Use o recurso Mostrar Dados da Tabela Gerenciador de Ser vidores para acessar os dados da tabela
Customers e alterar um registro.
6. Altere o mesmo registro para um valor diferente, atualize o conjuntos de dados e tente gravar as
alterações no banco de dados, o que resulta em um erro de simult ser gerado.
7. Capturar o erro e exibir as diferentes versões do registro, permitindo que o usuário determine se deve
continuar e atualizar o banco de dados ou cancelar a atualização.

Pré-requisitos
Este passo a passo usa SQL Server Express LocalDB e o banco de dados de exemplo Northwind.
1. Se você não tiver um SQL Server Express LocalDB, instale-o na página de download SQL Server Express
oupor meio do Instalador do Visual Studio . No Instalador do Visual Studio , você pode instalar o
SQL Server Express LocalDB como parte da carga de trabalho armazenamento e processamento de
dados ou como um componente individual.
2. Instale o banco de dados de exemplo Northwind seguindo estas etapas:
a. No Visual Studio, abra a SQL Ser ver Pesquisador de Objetos janela. (SQL Server Pesquisador
de Objetos é instalado como parte da carga de trabalho armazenamento e processamento de
dados no Instalador do Visual Studio.) Expanda o SQL Ser ver nó. Clique com o botão direito do
mouse na LocalDB e selecione Nova Consulta .
Uma janela do editor de consultas é aberta.
b. Copie o script Northwind Transact-SQL para a área de transferência. Esse script T-SQL cria o banco
de dados Northwind do zero e o popula com dados.
c. Colar o script T-SQL no editor de consultas e, em seguida, escolha o botão Executar.
Após um curto período, a consulta termina a execução e o banco de dados Northwind é criado.

Criar um novo projeto

Comece criando um novo aplicativo Windows Forms:
1. No Visual Studio, no menu Arquivo , selecione Novo > Projeto .
2. Expanda Visual C# ou Visual Basic no painel esquerdo e selecione Windows Desktop.
3. No painel central, selecione o tipo de projeto Windows Aplicativo de Formulários.
4. Nomeia o projeto ConcurrencyWalkthrough e escolha OK.
O projeto ConcurrencyWalkthrough é criado e adicionado Gerenciador de Soluções e um novo
formulário é aberto no designer.

Criar o conjuntos de dados Northwind

Em seguida, crie um conjuntos de dados chamado Nor thwindDataSet:
1. No menu Dados, escolha Adicionar Nova Fonte de Dados .
O Assistente de Configuração de Fonte de Dados é aberto.
2. Na tela Escolher um Tipo de Fonte de Dados, selecione Banco de Dados .

3. Selecione uma conexão com o banco de dados de exemplo Northwind na lista de conexões disponíveis.
Se a conexão não estiver disponível na lista de conexões, selecione Nova Conexão .

NOTE
Se você estiver se conectando a um arquivo de banco de dados local, selecione Não quando for perguntado se
você gostaria de adicionar o arquivo ao seu projeto.

4. Na tela Salvar cadeia de conexão no arquivo de configuração do aplicativo, selecione Próximo.

5. Expanda o nó Tabelas e selecione a tabela Clientes. O nome padrão do conjuntos de dados deve ser
Nor thwindDataSet.
6. Selecione Concluir para adicionar o conjuntos de dados ao projeto.

Criar um controle DataGridView com limite de dados

Nesta seção, você criará um arrastando o item Clientes da janela Fontes de Dados
System.Windows.Forms.DataGridView para o formulário Windows dados.
1. Para abrir a janela Fontes de Dados, no menu Dados, escolha Mostrar Fontes de Dados .
2. Na janela Fontes de Dados, expanda o nó Nor thwindDataSet e selecione a tabela Clientes.
3. Selecione a seta para baixo no nó da tabela e, em seguida, selecione DataGridView na lista lista listada.
4. Arraste a tabela para uma área vazia do formulário.
Um DataGridView controle chamado CustomersDataGridView e um BindingNavigator
CustomersBindingNavigator nomeado são adicionados ao formulário que está vinculado ao
BindingSource . Isso é, por sua vez, vinculado à tabela Customers no NorthwindDataSet.

Testar o formulário
Agora você pode testar o formulário para garantir que ele se comporte conforme o esperado até este ponto:
1. Selecione F5 para executar o aplicativo.
O formulário é exibido DataGridView com um controle que é preenchido com os dados da tabela
Clientes.
2. No menu Depurar , selecione Interromper Depuração .

Tratar erros de concurrency

A maneira como você lida com erros depende das regras de negócios específicas que regem seu aplicativo. Para
este passo a passo, usamos a estratégia a seguir como um exemplo de como lidar com o erro de simult mesmo.
O aplicativo apresenta ao usuário três versões do registro:
O registro atual no banco de dados
O registro original que é carregado no conjuntos de dados
As alterações propostas no conjuntos de dados
O usuário pode substituir o banco de dados pela versão proposta ou cancelar a atualização e atualizar o
conjuntos de dados com os novos valores do banco de dados.
Para habilitar a manipulação de erros de competência
1. Crie um manipulador de erros personalizado.
2. Exibir opções para o usuário.
3. Processe a resposta do usuário.
4. Reenda a atualização ou redefinir os dados no conjuntos de dados.
Adicionar código para lidar com a exceção de competência
Quando você tenta executar uma atualização e uma exceção é assaida, geralmente você deseja fazer algo com
as informações fornecidas pela exceção elevada. Nesta seção, você adicionará o código que tenta atualizar o
banco de dados. Você também lida com DBConcurrencyException qualquer que possa ser gerado, bem como
quaisquer outras exceções.

NOTE
Os CreateMessage métodos e são ProcessDialogResults adicionados posteriormente no passo a passo.

1. Adicione o seguinte código abaixo do Form1_Load método :

private void UpdateDatabase()
{
try
{
this.customersTableAdapter.Update(this.northwindDataSet.Customers);
MessageBox.Show("Update successful");
}
catch (DBConcurrencyException dbcx)
{
DialogResult response = MessageBox.Show(CreateMessage((NorthwindDataSet.CustomersRow)
(dbcx.Row)), "Concurrency Exception", MessageBoxButtons.YesNo);

ProcessDialogResult(response);
}
catch (Exception ex)
{
MessageBox.Show("An error was thrown while attempting to update the database.");
}
}

Private Sub UpdateDatabase()

Try
Me.CustomersTableAdapter.Update(Me.NorthwindDataSet.Customers)
MsgBox("Update successful")

Catch dbcx As Data.DBConcurrencyException

Dim response As Windows.Forms.DialogResult

response = MessageBox.Show(CreateMessage(CType(dbcx.Row, NorthwindDataSet.CustomersRow)),

"Concurrency Exception", MessageBoxButtons.YesNo)

ProcessDialogResult(response)

Catch ex As Exception
MsgBox("An error was thrown while attempting to update the database.")
End Try
End Sub

2. Substitua o CustomersBindingNavigatorSaveItem_Click método para chamar o método para que ele se

pareça com o UpdateDatabase seguinte:

private void customersBindingNavigatorSaveItem_Click(object sender, EventArgs e)

{
UpdateDatabase();
}

Private Sub CustomersBindingNavigatorSaveItem_Click(ByVal sender As System.Object, ByVal e As

System.EventArgs) Handles CustomersBindingNavigatorSaveItem.Click
UpdateDatabase()
End Sub

Exibir opções para o usuário

O código que você acabou de escrever chama CreateMessage o procedimento para exibir informações de erro
para o usuário. Para este passo a passo, use uma caixa de mensagem para exibir as diferentes versões do
registro para o usuário. Isso permite que o usuário escolha se deve substituir o registro com as alterações ou
cancelar a edição. Depois que o usuário seleciona uma opção (clica em um botão) na caixa de mensagem, a
resposta é passada para o ProcessDialogResult método .
Crie a mensagem adicionando o código a seguir ao Editor de Códigos . Insira este código abaixo do
UpdateDatabase método :

private string CreateMessage(NorthwindDataSet.CustomersRow cr)

{
return
"Database: " + GetRowData(GetCurrentRowInDB(cr), DataRowVersion.Default) + "\n" +
"Original: " + GetRowData(cr, DataRowVersion.Original) + "\n" +
"Proposed: " + GetRowData(cr, DataRowVersion.Current) + "\n" +
"Do you still want to update the database with the proposed value?";
}

//--------------------------------------------------------------------------
// This method loads a temporary table with current records from the database
// and returns the current values from the row that caused the exception.
//--------------------------------------------------------------------------
private NorthwindDataSet.CustomersDataTable tempCustomersDataTable =
new NorthwindDataSet.CustomersDataTable();

private NorthwindDataSet.CustomersRow GetCurrentRowInDB(NorthwindDataSet.CustomersRow RowWithError)

{
this.customersTableAdapter.Fill(tempCustomersDataTable);

NorthwindDataSet.CustomersRow currentRowInDb =
tempCustomersDataTable.FindByCustomerID(RowWithError.CustomerID);

return currentRowInDb;
}

//--------------------------------------------------------------------------
// This method takes a CustomersRow and RowVersion
// and returns a string of column values to display to the user.
//--------------------------------------------------------------------------
private string GetRowData(NorthwindDataSet.CustomersRow custRow, DataRowVersion RowVersion)
{
string rowData = "";

for (int i = 0; i < custRow.ItemArray.Length ; i++ )

{
rowData = rowData + custRow[i, RowVersion].ToString() + " ";
}
return rowData;
}
Private Function CreateMessage(ByVal cr As NorthwindDataSet.CustomersRow) As String
Return "Database: " & GetRowData(GetCurrentRowInDB(cr),
Data.DataRowVersion.Default) & vbCrLf &
"Original: " & GetRowData(cr, Data.DataRowVersion.Original) & vbCrLf &
"Proposed: " & GetRowData(cr, Data.DataRowVersion.Current) & vbCrLf &
"Do you still want to update the database with the proposed value?"
End Function

'--------------------------------------------------------------------------
' This method loads a temporary table with current records from the database
' and returns the current values from the row that caused the exception.
'--------------------------------------------------------------------------
Private TempCustomersDataTable As New NorthwindDataSet.CustomersDataTable

Private Function GetCurrentRowInDB(

ByVal RowWithError As NorthwindDataSet.CustomersRow
) As NorthwindDataSet.CustomersRow

Me.CustomersTableAdapter.Fill(TempCustomersDataTable)

Dim currentRowInDb As NorthwindDataSet.CustomersRow =

TempCustomersDataTable.FindByCustomerID(RowWithError.CustomerID)

Return currentRowInDb
End Function

'--------------------------------------------------------------------------
' This method takes a CustomersRow and RowVersion
' and returns a string of column values to display to the user.
'--------------------------------------------------------------------------
Private Function GetRowData(ByVal custRow As NorthwindDataSet.CustomersRow,
ByVal RowVersion As Data.DataRowVersion) As String

Dim rowData As String = ""

For i As Integer = 0 To custRow.ItemArray.Length - 1

rowData &= custRow.Item(i, RowVersion).ToString() & " "
Next

Return rowData
End Function

Processar a resposta do usuário

Você também precisa de código para processar a resposta do usuário para a caixa de mensagem. As opções são
substituir o registro atual no banco de dados pela alteração proposta ou abandonar as alterações locais e
atualizar a tabela de dados com o registro que está atualmente no banco de dados. Se o usuário escolher Sim , o
método será chamado com o Merge argumento preserveChanges definido como true. Isso faz com que a
tentativa de atualização seja bem-sucedida, porque a versão original do registro agora corresponde ao registro
no banco de dados.
Adicione o seguinte código abaixo do código que foi adicionado na seção anterior:
// This method takes the DialogResult selected by the user and updates the database
// with the new values or cancels the update and resets the Customers table
// (in the dataset) with the values currently in the database.

private void ProcessDialogResult(DialogResult response)

{
switch (response)
{
case DialogResult.Yes:
northwindDataSet.Merge(tempCustomersDataTable, true, MissingSchemaAction.Ignore);
UpdateDatabase();
break;

case DialogResult.No:
northwindDataSet.Merge(tempCustomersDataTable);
MessageBox.Show("Update cancelled");
break;
}
}

' This method takes the DialogResult selected by the user and updates the database
' with the new values or cancels the update and resets the Customers table
' (in the dataset) with the values currently in the database.

Private Sub ProcessDialogResult(ByVal response As Windows.Forms.DialogResult)

Select Case response

Case Windows.Forms.DialogResult.Yes
NorthwindDataSet.Customers.Merge(TempCustomersDataTable, True)
UpdateDatabase()

Case Windows.Forms.DialogResult.No
NorthwindDataSet.Customers.Merge(TempCustomersDataTable)
MsgBox("Update cancelled")
End Select
End Sub

Testar o comportamento do formulário

Agora, é possível testar o formulário para garantir que ele se comporta da forma esperada. Para simular uma
violação de simult contrário, altere os dados no banco de dados depois de preencher o NorthwindDataSet.
1. Selecione F5 para executar o aplicativo.
2. Depois que o formulário for exibido, deixe-o em execução e alternar para o Visual Studio IDE.
3. No menu Exibir , escolha Gerenciador de Ser vidores .
4. No Gerenciador de Ser vidores , expanda a conexão que seu aplicativo está usando e expanda o nó
Tabelas.
5. Clique com o botão direito do mouse na tabela Clientes e selecione Mostrar Dados da Tabela .
6. No primeiro registro (ALFKI ), altere ContactName para Maria Anders2 .

NOTE
Navegue até uma linha diferente para fazer commit da alteração.

7. Alternar para o formulário em execução do ConcurrencyWalkthrough.

8. No primeiro registro no formulário (ALFKI ), altere ContactName para Maria Anders1 .
9. Selecione o botão Salvar .
O erro de simultrreidade é gerado e a caixa de mensagem é exibida.
Selecionar Não cancela a atualização e atualiza o conjuntos de dados com os valores que estão
atualmente no banco de dados. Selecionar Sim grava o valor proposto no banco de dados.

Confira também
Salvar dados novamente no banco de dados
Como salvar dados usando uma transação
20/11/2021 • 2 minutes to read

Você salva dados em uma transação usando o System.Transactions namespace . Use o TransactionScope objeto
para participar de uma transação gerenciada automaticamente para você.
Os projetos não são criados com uma referência ao assembly System.Transactions, portanto, você precisa
adicionar manualmente uma referência a projetos que usam transações.
A maneira mais fácil de implementar uma transação é insinuar um TransactionScope objeto em uma using
instrução . (Para obter mais informações, consulte Usando a instruçãoe Usando a instrução.) O código que é
executado dentro using da instrução participa da transação.
Para fazer commit da transação, chame Complete o método como a última instrução no bloco using.
Para reverter a transação, lança uma exceção antes de chamar o Complete método .

Para adicionar uma referência ao System.Transactions.dll

1. No menu Projeto , selecione Adicionar Referência .
2. Na guia .NET ( SQL Server para SQL Server projetos), selecione System.Transactions e, em seguida,
selecione OK .
Uma referência a System.Transactions.dll é adicionada ao projeto.

Para salvar dados em uma transação

Adicione código para salvar dados dentro da instrução using que contém a transação. O código a seguir
mostra como criar e insinuar um TransactionScope objeto em uma instrução using:

Using updateTransaction As New Transactions.TransactionScope

' Add code to save your data here.

' Throw an exception to roll back the transaction.

' Call the Complete method to commit the transaction

updateTransaction.Complete()
End Using

using (System.Transactions.TransactionScope updateTransaction =

new System.Transactions.TransactionScope())
{
// Add code to save your data here.
// Throw an exception to roll back the transaction.

// Call the Complete method to commit the transaction

updateTransaction.Complete();
}

Confira também
Salvar dados novamente no banco de dados
Passo a passo: salvar dados em uma transação
Passo a passo: salvar dados em uma transação
20/11/2021 • 6 minutes to read

Este passo a passo demonstra como salvar dados em uma transação usando o System.Transactions namespace .
Neste passo a passo, você criará um aplicativo Windows Forms. Você usará o Assistente de Configuração da
Fonte de Dados para criar um conjuntos de dados para duas tabelas no banco de dados de exemplo Northwind.
Você adicionará controles de associação de dados a um formulário Windows e modificará o código para o botão
Salvar do BindingNavigator para atualizar o banco de dados dentro de um TransactionScope.

Pré-requisitos
Este passo a passo usa SQL Server Express LocalDB e o banco de dados de exemplo Northwind.
1. Se você não tiver um SQL Server Express LocalDB, instale-o na página de download do SQL Server
Expressou por meio do Instalador do Visual Studio . No Instalador do Visual Studio, SQL Server
Express LocalDB pode ser instalado como parte da carga de trabalho de desenvolvimento da área de
trabalho do .NET ou como um componente individual.
2. Instale o banco de dados de exemplo Northwind seguindo estas etapas:
a. No Visual Studio, abra a SQL Ser ver Pesquisador de Objetos janela. (SQL Server Pesquisador
de Objetos é instalado como parte da carga de trabalho armazenamento e processamento de
dados no Instalador do Visual Studio.) Expanda o SQL Ser ver nó. Clique com o botão direito do
mouse na LocalDB instância e selecione Nova Consulta .
Uma janela do editor de consultas é aberta.
b. Copie o script Northwind Transact-SQL para a área de transferência. Esse script T-SQL cria o banco
de dados Northwind do zero e o popula com dados.
c. Colar o script T-SQL no editor de consultas e, em seguida, escolha o botão Executar.
Após um curto período, a consulta termina a execução e o banco de dados Northwind é criado.

Criar um aplicativo do Windows Forms

A primeira etapa é criar um aplicativo Windows Forms.
1. No Visual Studio, no menu Arquivo , selecione Novo > Projeto .
2. Expanda Visual C# ou Visual Basic no painel esquerdo e selecione Windows Desktop.
3. No painel central, selecione o tipo de projeto Windows Aplicativo de Formulários.
4. Nomeia o projeto SavingDataInATransactionWalkthrough e escolha OK.
O projeto SavingDataInATransactionWalkthrough é criado e adicionado ao Gerenciador de
Soluções .

Criar uma fonte de dados de banco de dados

Esta etapa usa o Assistente de Configuração de Fonte de Dados para criar uma fonte de dados com base nas
tabelas e no banco de dados de exemplo Customers Orders Northwind.
1. Para abrir a janela Fontes de Dados, no menu Dados, selecione Mostrar Fontes de Dados .
2. Na janela Fontes de Dados, selecione Adicionar Nova Fonte de Dados para iniciar o Assistente de
Configuração da Fonte de Dados .
3. Na tela Escolher um Tipo de Fonte de Dados, selecione Banco de Dados e, em seguida, selecione
Próximo.
4. Na tela Escolher sua Conexão de Dados, faça o seguinte:
Se uma conexão de dados com o banco de dados de exemplo Northwind estiver disponível na
lista suspensa, selecione-o.
-ou-
Selecione Nova Conexão para inicializar a caixa de diálogo Adicionar/Modificar Conexão e
criar uma conexão com o banco de dados Northwind.
5. Se o banco de dados exigir uma senha, selecione a opção para incluir dados confidenciais e, em seguida,
selecione Próximo .
6. Na tela Salvar cadeia de conexão no arquivo configuração de aplicativo, selecione Próximo .
7. Na tela Escolher seus Objetos de Banco de Dados, expanda o nó Tabelas.
8. Selecione as Customers Orders tabelas e e, em seguida, selecione Concluir .
O Nor thwindDataSet é adicionado ao projeto e as tabelas Customers e Orders aparecem na janela
Fontes de Dados .

Adicionar controles ao formulário

Você pode criar os controles vinculados a dados arrastando itens da janela Fontes de Dados para o formulário.
1. Na janela Fontes de Dados, expanda o nó Clientes.
2. Arraste o nó principal Clientes da janela Fontes de Dados para Form1 .
Um controle DataGridView e uma faixa de ferramentas (BindingNavigator) para navegação em registros
são exibidos no formulário. Um NorthwindDataSet CustomersTableAdapter , , e aparecem na bandeja do
BindingSource BindingNavigator componente.
3. Arraste o nó Orders relacionado (não o nó Orders principal, mas o nó de tabela filho relacionado abaixo
da coluna Fax) para o formulário abaixo de CustomersDataGridView .
Um DataGridView aparece no formulário. Um OrdersTableAdapter e aparecem na bandeja do
BindingSource componente.

Adicionar uma referência ao assembly System.Transactions

As transações usam o namespace System.Transactions. Uma referência do projeto ao assembly
system.transactions não é adicionada por padrão, portanto, você precisa adicioná-la manualmente.
Para adicionar uma referência ao arquivo DLL System.Transactions
1. No menu Projeto , selecione Adicionar Referência .
2. Selecione System.Transactions (na guia .NET) e, em seguida, selecione OK.
Uma referência a System.Transactions é adicionada ao projeto.

Modificar o código no botão SaveItem de BindingNavigator

Para a primeira tabela lançada no formulário, o código é adicionado por padrão ao evento click do botão
Salvar no BindingNavigator . É necessário adicionar manualmente o código para atualizar quaisquer tabelas
adicionais. Para este passo a passo, nós refactoramos o código de salvar existente do manipulador de eventos
de clique do botão Salvar. Também criamos mais alguns métodos para fornecer funcionalidades de atualização
específicas com base em se a linha precisa ser adicionada ou excluída.
Para modificar o código salvar gerado automaticamente
1. Selecione o botão Salvar no CustomersBindingNavigator (o botão com o ícone de disquete).
2. Substitua o método CustomersBindingNavigatorSaveItem_Click pelo seguinte código:

Private Sub CustomersBindingNavigatorSaveItem_Click() Handles CustomersBindingNavigatorSaveItem.Click

UpdateData()
End Sub

Private Sub UpdateData()

Me.Validate()
Me.CustomersBindingSource.EndEdit()
Me.OrdersBindingSource.EndEdit()

Using updateTransaction As New Transactions.TransactionScope

DeleteOrders()
DeleteCustomers()
AddNewCustomers()
AddNewOrders()

updateTransaction.Complete()
NorthwindDataSet.AcceptChanges()
End Using
End Sub

private void customersBindingNavigatorSaveItem_Click(object sender, EventArgs e)

{
UpdateData();
}

private void UpdateData()

{
this.Validate();
this.customersBindingSource.EndEdit();
this.ordersBindingSource.EndEdit();

using (System.Transactions.TransactionScope updateTransaction =

new System.Transactions.TransactionScope())
{
DeleteOrders();
DeleteCustomers();
AddNewCustomers();
AddNewOrders();

updateTransaction.Complete();
northwindDataSet.AcceptChanges();
}
}

A ordem para reconciliar as alterações aos dados relacionados é a seguinte:

Excluir registros filho. (Nesse caso, exclua registros da Orders tabela.)
Excluir registros pai. (Nesse caso, exclua registros da Customers tabela.)
Inserir registros pai. (Nesse caso, insira registros na Customers tabela.)
Inserir registros filho. (Nesse caso, insira registros na Orders tabela.)
Para excluir pedidos existentes
Adicione o seguinte método DeleteOrders a Form1 :

Private Sub DeleteOrders()

Dim deletedOrders As NorthwindDataSet.OrdersDataTable

deletedOrders = CType(NorthwindDataSet.Orders.GetChanges(Data.DataRowState.Deleted),
NorthwindDataSet.OrdersDataTable)

If Not IsNothing(deletedOrders) Then

Try
OrdersTableAdapter.Update(deletedOrders)

Catch ex As Exception
MessageBox.Show("DeleteOrders Failed")
End Try
End If
End Sub

private void DeleteOrders()

{
NorthwindDataSet.OrdersDataTable deletedOrders;
deletedOrders = (NorthwindDataSet.OrdersDataTable)
northwindDataSet.Orders.GetChanges(DataRowState.Deleted);

if (deletedOrders != null)
{
try
{
ordersTableAdapter.Update(deletedOrders);
}
catch (System.Exception ex)
{
MessageBox.Show("DeleteOrders Failed");
}
}
}

Para excluir clientes existentes

Adicione o seguinte método DeleteCustomers a Form1 :

Private Sub DeleteCustomers()

Dim deletedCustomers As NorthwindDataSet.CustomersDataTable

deletedCustomers = CType(NorthwindDataSet.Customers.GetChanges(Data.DataRowState.Deleted),
NorthwindDataSet.CustomersDataTable)

If Not IsNothing(deletedCustomers) Then

Try
CustomersTableAdapter.Update(deletedCustomers)

Catch ex As Exception
MessageBox.Show("DeleteCustomers Failed" & vbCrLf & ex.Message)
End Try
End If
End Sub
private void DeleteCustomers()
{
NorthwindDataSet.CustomersDataTable deletedCustomers;
deletedCustomers = (NorthwindDataSet.CustomersDataTable)
northwindDataSet.Customers.GetChanges(DataRowState.Deleted);

if (deletedCustomers != null)
{
try
{
customersTableAdapter.Update(deletedCustomers);
}
catch (System.Exception ex)
{
MessageBox.Show("DeleteCustomers Failed");
}
}
}

Para adicionar novos clientes

Adicione o seguinte método AddNewCustomers a Form1 :

Private Sub AddNewCustomers()

Dim newCustomers As NorthwindDataSet.CustomersDataTable

newCustomers = CType(NorthwindDataSet.Customers.GetChanges(Data.DataRowState.Added),
NorthwindDataSet.CustomersDataTable)

If Not IsNothing(newCustomers) Then

Try
CustomersTableAdapter.Update(newCustomers)

Catch ex As Exception
MessageBox.Show("AddNewCustomers Failed" & vbCrLf & ex.Message)
End Try
End If
End Sub

private void AddNewCustomers()

{
NorthwindDataSet.CustomersDataTable newCustomers;
newCustomers = (NorthwindDataSet.CustomersDataTable)
northwindDataSet.Customers.GetChanges(DataRowState.Added);

if (newCustomers != null)
{
try
{
customersTableAdapter.Update(newCustomers);
}
catch (System.Exception ex)
{
MessageBox.Show("AddNewCustomers Failed");
}
}
}

Para adicionar novos pedidos

Adicione o seguinte método AddNewOrders a Form1 :
Private Sub AddNewOrders()

Dim newOrders As NorthwindDataSet.OrdersDataTable

newOrders = CType(NorthwindDataSet.Orders.GetChanges(Data.DataRowState.Added),
NorthwindDataSet.OrdersDataTable)

If Not IsNothing(newOrders) Then

Try
OrdersTableAdapter.Update(newOrders)

Catch ex As Exception
MessageBox.Show("AddNewOrders Failed" & vbCrLf & ex.Message)
End Try
End If
End Sub

private void AddNewOrders()

{
NorthwindDataSet.OrdersDataTable newOrders;
newOrders = (NorthwindDataSet.OrdersDataTable)
northwindDataSet.Orders.GetChanges(DataRowState.Added);

if (newOrders != null)
{
try
{
ordersTableAdapter.Update(newOrders);
}
catch (System.Exception ex)
{
MessageBox.Show("AddNewOrders Failed");
}
}
}

Executar o aplicativo
Pressione F5 para executar o aplicativo.

Confira também
Como salvar dados usando uma transação
Salvar dados novamente no banco de dados
Salvar dados em um banco de dados (várias
tabelas)
20/11/2021 • 7 minutes to read

Um dos cenários mais comuns no desenvolvimento de aplicativos é exibir dados de um formulário em um

aplicativo do Windows, editar e enviá-los atualizados de volta para o banco de dados. Essa explicação passo a
passo cria um formulário que exibe dados de duas tabelas relacionadas e mostra como editar registros e salvar
alterações no banco de dados. Este exemplo usa as tabelas Customers e Orders do banco de dados de exemplo
Northwind.
Você pode salvar os dados em seu aplicativo de volta no banco de dados chamando o método Update de um
TableAdapter. Quando você arrasta tabelas da janela Fontes de Dados para um formulário, o código necessário
para salvar dados é adicionado automaticamente. Todas as tabelas adicionais que são adicionadas a um
formulário exigem a adição manual desse código. Essa explicação passo a passo mostra como adicionar código
para salvar atualizações de mais de uma tabela.
As tarefas ilustradas neste passo a passo incluem:
Criando e configurando uma fonte de dados em seu aplicativo com o Assistente de Configuração da
Fonte de Dados.
Definir os controles dos itens na janela Fontes de Dados. Para obter mais informações, consulte Definir o
controle a ser criado ao arrastar da janela Fontes de Dados.
Criando controles associados a dados arrastando itens da janela Fontes de Dados para o formulário.
Modificando alguns registros em cada tabela no conjuntos de dados.
Modificando o código para enviar os dados atualizados no conjunto de dados de volta ao banco de
dados.

Pré-requisitos
Este passo a passo usa SQL Server Express LocalDB e o banco de dados de exemplo Northwind.
1. Se você não tiver um SQL Server Express LocalDB, instale-o na página de download do SQL Server
Expressou por meio do Instalador do Visual Studio . No Instalador do Visual Studio , você pode
instalar o SQL Server Express LocalDB como parte da carga de trabalho armazenamento e
processamento de dados ou como um componente individual.
2. Instale o banco de dados de exemplo Northwind seguindo estas etapas:
a. No Visual Studio, abra a SQL Ser ver Pesquisador de Objetos janela. (SQL Server Pesquisador
de Objetos é instalado como parte da carga de trabalho armazenamento e processamento de
dados no Instalador do Visual Studio.) Expanda o SQL Ser ver nó. Clique com o botão direito do
mouse na LocalDB instância e selecione Nova Consulta .
Uma janela do editor de consultas é aberta.
b. Copie o script Northwind Transact-SQL para a área de transferência. Esse script T-SQL cria o banco
de dados Northwind do zero e o popula com dados.
c. Colar o script T-SQL no editor de consultas e, em seguida, escolha o botão Executar.
Após um curto período, a consulta termina a execução e o banco de dados Northwind é criado.

Criar o aplicativo Windows Forms

Crie um novo projeto Windows Aplicativo de Formulários para C# ou Visual Basic. Nomeie o projeto
UpdateMultipleTablesWalkthrough .

Criar a fonte de dados

Esta etapa cria uma fonte de dados com base em um banco de dados Northwind usando o Assistente de
Configuração de Fonte de Dados . É preciso ter acesso ao banco de dados de exemplo Northwind para criar
a conexão. Para obter informações sobre como configurar o banco de dados de exemplo Northwind, consulte
Como instalar bancos de dados de exemplo.
1. No menu Dados, selecione Mostrar Fontes de Dados .
A janela Fontes de Dados é aberta.
2. Na janela Fontes de Dados, selecione Adicionar Nova Fonte de Dados para iniciar o Assistente de
Configuração da Fonte de Dados .
3. Na tela Escolher um Tipo de Fonte de Dados, selecione Banco de Dados e, em seguida, selecione
Próximo.
4. Na tela Escolher sua Conexão de Dados, faça um dos seguintes:
Se uma conexão de dados com o banco de dados de exemplo Northwind estiver disponível na
lista suspensa, selecione-o.
-ou-
Selecione Nova Conexão para abrir a caixa de diálogo Adicionar/Modificar Conexão .
5. Se o banco de dados exigir uma senha, selecione a opção para incluir dados confidenciais e, em seguida,
selecione Próximo .
6. Na cadeia de conexão Salvar no arquivo configuração de aplicativo, selecione Próximo.
7. Na tela Escolher seus Objetos de Banco de Dados, expanda o nó Tabelas.
8. Selecione as tabelas Clientes e Pedidos e, em seguida, selecione Concluir .
O Nor thwindDataSet é adicionado ao projeto e as tabelas são exibidas na janela Fontes de Dados .

Definir os controles a serem criados

Para este passo a passo, os dados na tabela estão em um layout Detalhes em que os dados Customers são
exibidos em controles individuais. Os dados da Orders tabela estão em um layout de Grade exibido em um
DataGridView controle .
Definir o tipo de remoção dos itens na Janela Fontes de Dados
1. Na janela Fontes de Dados, expanda o nó Clientes.
2. No nó Clientes, selecione Detalhes na lista de controles para alterar o controle da tabela Clientes para
controles individuais. Para obter mais informações, consulte Definir o controle a ser criado ao arrastar da
janela Fontes de Dados.

Criar o formulário de limite de dados

Você pode criar os controles vinculados a dados arrastando itens da janela Fontes de Dados para o formulário.
1. Arraste o nó principal Clientes da janela Fontes de Dados para Form1 .
Os controles de associação de dados com rótulos descritivos são exibidos no formulário, juntamente com
uma faixa de ferramentas (BindingNavigator) para registros de navegação. Um NorthwindDataSet
CustomersTableAdapter , , e aparecem na bandeja do BindingSource BindingNavigator componente.

2. Arraste o nó Ordens relacionado da janela Fontes de Dados para Form1 .

NOTE
O nó Ordens relacionado está localizado abaixo da coluna Fax e é um nó filho do nó Clientes .

Um controle DataGridView e uma faixa de ferramentas (BindingNavigator) para navegação em registros

são exibidos no formulário. Um OrdersTableAdapter e aparecem na bandeja do BindingSource
componente.

Adicionar código para atualizar o banco de dados

É possível atualizar os bancos de dados chamando os métodos Update dos TableAdapters Clientes e Ordens .
Por padrão, um manipulador de eventos para o botão Salvar do é adicionado ao código do formulário para
enviar BindingNavigator atualizações ao banco de dados. Este procedimento modifica o código para enviar
atualizações na ordem correta. Isso elimina a possibilidade de aumentar erros de integridade referencial. O
código também implementa manipulação de erros com a quebra automática da chamada de atualização em um
bloco try-catch. Você pode mudar o código para atender às necessidades do seu aplicativo.

NOTE
Para maior clareza, este passo a passo não usa uma transação. No entanto, se você estiver atualizando duas ou mais
tabelas relacionadas, inclua toda a lógica de atualização em uma transação. Uma transação é um processo que garante
que todas as alterações relacionadas a um banco de dados sejam bem-sucedidas antes que as alterações sejam
comprometidas. Para obter mais informações, consulte Transações e simultrreidade.

Para adicionar lógica de atualização ao aplicativo

1. Selecione o botão Salvar no BindingNavigator . Isso abre o Editor de Códigos para o
bindingNavigatorSaveItem_Click manipulador de eventos.

2. Substitua o código no manipulador de eventos para chamar os métodos Update dos TableAdapters
relacionados. O código a seguir primeiro cria três tabelas de dados temporárias para armazenar as
informações de cada DataRowState (Deleted, Added e Modified). As atualizações são executados na
ordem correta. O código deve se parecer com o seguinte:
Me.Validate()
Me.OrdersBindingSource.EndEdit()
Me.CustomersBindingSource.EndEdit()

Dim deletedOrders As NorthwindDataSet.OrdersDataTable = CType(

NorthwindDataSet.Orders.GetChanges(Data.DataRowState.Deleted), NorthwindDataSet.OrdersDataTable)

Dim newOrders As NorthwindDataSet.OrdersDataTable = CType(

NorthwindDataSet.Orders.GetChanges(Data.DataRowState.Added), NorthwindDataSet.OrdersDataTable)

Dim modifiedOrders As NorthwindDataSet.OrdersDataTable = CType(

NorthwindDataSet.Orders.GetChanges(Data.DataRowState.Modified), NorthwindDataSet.OrdersDataTable)

Try
' Remove all deleted orders from the Orders table.
If Not deletedOrders Is Nothing Then
OrdersTableAdapter.Update(deletedOrders)
End If

' Update the Customers table.

CustomersTableAdapter.Update(NorthwindDataSet.Customers)

' Add new orders to the Orders table.

If Not newOrders Is Nothing Then
OrdersTableAdapter.Update(newOrders)
End If

' Update all modified Orders.

If Not modifiedOrders Is Nothing Then
OrdersTableAdapter.Update(modifiedOrders)
End If

NorthwindDataSet.AcceptChanges()

Catch ex As Exception
MsgBox("Update failed")

Finally
If Not deletedOrders Is Nothing Then
deletedOrders.Dispose()
End If

If Not newOrders Is Nothing Then

newOrders.Dispose()
End If

If Not modifiedOrders Is Nothing Then

modifiedOrders.Dispose()
End If
End Try
this.Validate();
this.ordersBindingSource.EndEdit();
this.customersBindingSource.EndEdit();

NorthwindDataSet.OrdersDataTable deletedOrders = (NorthwindDataSet.OrdersDataTable)

northwindDataSet.Orders.GetChanges(DataRowState.Deleted);

NorthwindDataSet.OrdersDataTable newOrders = (NorthwindDataSet.OrdersDataTable)

northwindDataSet.Orders.GetChanges(DataRowState.Added);

NorthwindDataSet.OrdersDataTable modifiedOrders = (NorthwindDataSet.OrdersDataTable)

northwindDataSet.Orders.GetChanges(DataRowState.Modified);

try
{
// Remove all deleted orders from the Orders table.
if (deletedOrders != null)
{
ordersTableAdapter.Update(deletedOrders);
}

// Update the Customers table.

customersTableAdapter.Update(northwindDataSet.Customers);

// Add new orders to the Orders table.

if (newOrders != null)
{
ordersTableAdapter.Update(newOrders);
}

// Update all modified Orders.

if (modifiedOrders != null)
{
ordersTableAdapter.Update(modifiedOrders);
}

northwindDataSet.AcceptChanges();
}

catch (System.Exception ex)

{
MessageBox.Show("Update failed");
}

finally
{
if (deletedOrders != null)
{
deletedOrders.Dispose();
}
if (newOrders != null)
{
newOrders.Dispose();
}
if (modifiedOrders != null)
{
modifiedOrders.Dispose();
}
}

Testar o aplicativo
1. Pressione F5 .
2. Faça algumas alterações nos dados de um ou mais registros em cada tabela.
3. Selecione o botão Salvar .
4. Confira os valores no banco de dados para verificar se as alterações foram salvas.

Confira também
Salvar dados novamente no banco de dados
Salvar dados de um objeto em um banco de dados
20/11/2021 • 3 minutes to read

Você pode salvar dados em objetos em um banco de dado passando os valores do seu objeto para um dos
métodos DBDirect do TableAdapter (por exemplo, TableAdapter.Insert ). Para obter mais informações, consulte
TableAdapter.
Para salvar dados de uma coleção de objetos, faça um loop através da coleção de objetos (por exemplo, um loop
for-Next) e envie os valores para cada objeto para o banco de dados usando um dos métodos do TableAdapter
DBDirect .

Por padrão, os DBDirect métodos são criados em um TableAdapter que pode ser executado diretamente no
banco de dados. Esses métodos podem ser chamados diretamente e não exigem DataSet ou DataTable objetos
para reconciliar as alterações a fim de enviar atualizações para um banco de dados.

NOTE
Quando você estiver configurando um TableAdapter, a consulta principal deverá fornecer informações suficientes para que
os DBDirect métodos sejam criados. Por exemplo, se um TableAdapter estiver configurado para consultar dados de uma
tabela que não tem uma coluna de chave primária definida, ele não gerará DBDirect métodos.

M ÉTO DO S DB DIREC T TA B L EA DA P T ER DESC RIÇ Ã O

TableAdapter.Insert Adiciona novos registros a um banco de dados e permite

que você passe valores de coluna individuais como
parâmetros de método.

TableAdapter.Update Atualiza os registros existentes em um banco de dados. O

Update método usa valores originais e novos de coluna
como parâmetros de método. Os valores originais são
usados para localizar o registro original e os novos valores
são usados para atualizar esse registro.

O TableAdapter.Update método também é usado para

reconciliar as alterações em um conjunto de dados de volta
para o Database por meio de uma DataSet DataTable
DataRow matriz de DataRow s como parâmetros de método.

TableAdapter.Delete Exclui os registros existentes do banco de dados com base

nos valores de coluna originais passados como parâmetros
de método.

Para salvar novos registros de um objeto em um banco de dados

Crie os registros passando os valores para o TableAdapter.Insert método.
O exemplo a seguir cria um novo registro de cliente na Customers tabela passando os valores no
currentCustomer objeto para o TableAdapter.Insert método.
private void AddNewCustomers(Customer currentCustomer)
{
customersTableAdapter.Insert(
currentCustomer.CustomerID,
currentCustomer.CompanyName,
currentCustomer.ContactName,
currentCustomer.ContactTitle,
currentCustomer.Address,
currentCustomer.City,
currentCustomer.Region,
currentCustomer.PostalCode,
currentCustomer.Country,
currentCustomer.Phone,
currentCustomer.Fax);
}

Private Sub AddNewCustomer(ByVal currentCustomer As Customer)

CustomersTableAdapter.Insert(
currentCustomer.CustomerID,
currentCustomer.CompanyName,
currentCustomer.ContactName,
currentCustomer.ContactTitle,
currentCustomer.Address,
currentCustomer.City,
currentCustomer.Region,
currentCustomer.PostalCode,
currentCustomer.Country,
currentCustomer.Phone,
currentCustomer.Fax)
End Sub

Para atualizar os registros existentes de um objeto para um banco de

dados
Modifique os registros chamando o TableAdapter.Update método, passando os novos valores para
atualizar o registro e passando os valores originais para localizar o registro.

NOTE
Seu objeto precisa manter os valores originais para passá-los para o Update método. Este exemplo usa
propriedades com um orig prefixo para armazenar os valores originais.

O exemplo a seguir atualiza um registro existente na Customers tabela passando os valores novos e
originais no Customer objeto para o TableAdapter.Update método.
private void UpdateCustomer(Customer cust)
{
customersTableAdapter.Update(
cust.CustomerID,
cust.CompanyName,
cust.ContactName,
cust.ContactTitle,
cust.Address,
cust.City,
cust.Region,
cust.PostalCode,
cust.Country,
cust.Phone,
cust.Fax,
cust.origCustomerID,
cust.origCompanyName,
cust.origContactName,
cust.origContactTitle,
cust.origAddress,
cust.origCity,
cust.origRegion,
cust.origPostalCode,
cust.origCountry,
cust.origPhone,
cust.origFax);
}

Private Sub UpdateCustomer(ByVal cust As Customer)

CustomersTableAdapter.Update(
cust.CustomerID,
cust.CompanyName,
cust.ContactName,
cust.ContactTitle,
cust.Address,
cust.City,
cust.Region,
cust.PostalCode,
cust.Country,
cust.Phone,
cust.Fax,
cust.origCustomerID,
cust.origCompanyName,
cust.origContactName,
cust.origContactTitle,
cust.origAddress,
cust.origCity,
cust.origRegion,
cust.origPostalCode,
cust.origCountry,
cust.origPhone,
cust.origFax)
End Sub

Para excluir registros existentes de um banco de dados

Exclua os registros chamando o TableAdapter.Delete método e passando os valores originais para
localizar o registro.
NOTE
Seu objeto precisa manter os valores originais para passá-los para o Delete método. Este exemplo usa
propriedades com um orig prefixo para armazenar os valores originais.

O exemplo a seguir exclui um registro da Customers tabela passando os valores originais no Customer
objeto para o TableAdapter.Delete método.

private void DeleteCustomer(Customer cust)

{
customersTableAdapter.Delete(
cust.origCustomerID,
cust.origCompanyName,
cust.origContactName,
cust.origContactTitle,
cust.origAddress,
cust.origCity,
cust.origRegion,
cust.origPostalCode,
cust.origCountry,
cust.origPhone,
cust.origFax);
}

Private Sub DeleteCustomer(ByVal cust As Customer)

CustomersTableAdapter.Delete(
cust.origCustomerID,
cust.origCompanyName,
cust.origContactName,
cust.origContactTitle,
cust.origAddress,
cust.origCity,
cust.origRegion,
cust.origPostalCode,
cust.origCountry,
cust.origPhone,
cust.origFax)
End Sub

Segurança do .NET
Você deve ter permissão para executar o selecionado INSERT , UPDATE ou DELETE na tabela no banco de dados.

Confira também
Salvar dados novamente no banco de dados
Salvar os dados com os métodos TableAdapter
DBDirect
20/11/2021 • 6 minutes to read

Este passo a passo fornece instruções detalhadas para executar instruções SQL diretamente em um banco de
dados usando os métodos DBDirect de um TableAdapter. Os métodos DBDirect de um TableAdapter fornecem
um bom nível de controle sobre as atualizações do seu banco de dados. Você pode usá-los para executar
instruções SQL específicas e procedimentos armazenados chamando os métodos , e individuais conforme
necessário para seu aplicativo (em vez do método sobrecarregado que executa as instruções UPDATE, INSERT e
DELETE em uma única Insert Update Delete Update chamada).
Durante este passo a passo, você aprenderá a:
Crie um novo aplicativo Windows Forms .
Crie e configure um conjunto de dados com o Assistente de Configuração da Fonte de Dados.
Selecionar o controle a ser criado no formulário ao arrastar itens da janela Fontes de Dados . Para obter
mais informações, consulte Definir o controle a ser criado ao arrastar da janela Fontes de Dados.
Cria controles de associação de dados arrastando itens da janela Fontes de Dados para um formulário.
Adicione métodos para acessar diretamente o banco de dados e executar inserções, atualizações e
exclusões.

Pré-requisitos
Este passo a passo usa SQL Server Express LocalDB e o banco de dados de exemplo Northwind.
1. Se você não tiver um SQL Server Express LocalDB, instale-o na página de download SQL Server Express
oupor meio do Instalador do Visual Studio . No Instalador do Visual Studio , você pode instalar o
SQL Server Express LocalDB como parte da carga de trabalho armazenamento e processamento de
dados ou como um componente individual.
2. Instale o banco de dados de exemplo Northwind seguindo estas etapas:
a. No Visual Studio, abra a SQL Ser ver Pesquisador de Objetos janela. (SQL Server Pesquisador
de Objetos é instalado como parte da carga de trabalho armazenamento e processamento de
dados no Instalador do Visual Studio.) Expanda o SQL Ser ver nó. Clique com o botão direito do
mouse na LocalDB e selecione Nova Consulta .
Uma janela do editor de consultas é aberta.
b. Copie o script Northwind Transact-SQL para a área de transferência. Esse script T-SQL cria o banco
de dados Northwind do zero e o popula com dados.
c. Colar o script T-SQL no editor de consultas e, em seguida, escolha o botão Executar.
Após um curto período, a consulta termina a execução e o banco de dados Northwind é criado.

Criar um aplicativo do Windows Forms

A primeira etapa é criar um aplicativo Windows Forms.
1. No Visual Studio, no menu Arquivo , selecione Novo > Projeto .
2. Expanda Visual C# ou Visual Basic no painel esquerdo e selecione Windows Desktop.
3. No painel central, selecione o tipo de projeto Windows Aplicativo de Formulários.
4. Nomeia o projeto TableAdapterDbDirectMethodsWalkthrough e escolha OK.
O projeto TableAdapterDbDirectMethodsWalkthrough é criado e adicionado ao Gerenciador de
Soluções .

Criar uma fonte de dados do banco de dados

Esta etapa usa o Assistente de Configuração de Fonte de Dados para criar uma fonte de dados com base
na tabela Region no banco de dados de exemplo Northwind. É preciso ter acesso ao banco de dados de
exemplo Northwind para criar a conexão. Para obter informações sobre como configurar o banco de dados de
exemplo Northwind, consulte Como instalar bancos de dados de exemplo.
Para criar a fonte de dados
1. No menu Dados, selecione Mostrar Fontes de Dados .
A janela Fontes de Dados é aberta.
2. Na janela Fontes de Dados, selecione Adicionar Nova Fonte de Dados para iniciar o Assistente de
Configuração da Fonte de Dados .
3. Na tela Escolher um Tipo de Fonte de Dados, selecione Banco de Dados e, em seguida, selecione
Próximo.
4. Na tela Escolher sua Conexão de Dados, faça um dos seguintes:
Se uma conexão de dados com o banco de dados de exemplo Northwind estiver disponível na
lista suspensa, selecione-o.
-ou-
Selecione Nova Conexão para inicializar a caixa de diálogo Adicionar/Modificar Conexão .
5. Se o banco de dados exigir uma senha, selecione a opção para incluir dados confidenciais e, em seguida,
selecione Próximo .
6. Na tela Salvar cadeia de conexão no arquivo configuração de aplicativo, selecione Próximo .
7. Na tela Escolher seus Objetos de Banco de Dados, expanda o nó Tabelas.
8. Selecione a Region tabela e, em seguida, selecione Concluir .
O Nor thwindDataSet é adicionado ao projeto e a tabela Region aparece na janela Fontes de Dados .

Adicionar controles ao formulário para exibir os dados

Crie controles de associação de dados arrastando itens da janela Fontes de Dados para seu formulário.
Para criar controles de limite de dados no formulário Windows, arraste o nó Região principal da janela Fontes
de Dados para o formulário.
Um controle DataGridView e uma faixa de ferramentas (BindingNavigator) para navegação em registros são
exibidos no formulário. Um NorthwindDataSet RegionTableAdapter , , e aparecem na bandeja do BindingSource
BindingNavigator componente.
Para adicionar botões que chamam os métodos individuais DbDirect de um TableAdapter
1. Arraste três controles Button da Caixa de Ferramentas para Form1 (abaixo de
RegionDataGridView ).
2. Defina as propriedades Nome e Texto a seguir em cada botão.

NOME T EXTO

InsertButton Inserção

UpdateButton Atualizar

DeleteButton Delete (excluir)

Para adicionar código para inserir novos registros no banco de dados

1. Selecione Inser tButton para criar um manipulador de eventos para o evento de clique e abra o
formulário no editor de códigos.
2. Substitua o manipulador de eventos InsertButton_Click pelo seguinte código:

Private Sub InsertButton_Click() Handles InsertButton.Click

Dim newRegionID As Integer = 5

Dim newRegionDescription As String = "NorthEastern"

Try
RegionTableAdapter1.Insert(newRegionID, newRegionDescription)

Catch ex As Exception
MessageBox.Show("Insert Failed")
End Try

RefreshDataset()
End Sub

Private Sub RefreshDataset()

Me.RegionTableAdapter1.Fill(Me.NorthwindDataSet1._Region)
End Sub

private void InsertButton_Click(object sender, EventArgs e)

{
Int32 newRegionID = 5;
String newRegionDescription = "NorthEastern";

try
{
regionTableAdapter1.Insert(newRegionID, newRegionDescription);
}
catch (Exception ex)
{
MessageBox.Show("Insert Failed");
}
RefreshDataset();
}

private void RefreshDataset()

{
this.regionTableAdapter1.Fill(this.northwindDataSet1.Region);
}
Para adicionar código para atualizar registros no banco de dados
1. Clique duas vezes em UpdateButton para criar um manipulador de eventos para o evento Click e abrir o
formulário no editor de códigos.
2. Substitua o manipulador de eventos UpdateButton_Click pelo seguinte código:

Private Sub UpdateButton_Click() Handles UpdateButton.Click

Dim newRegionID As Integer = 5

Try
RegionTableAdapter1.Update(newRegionID, "Updated Region Description", 5, "NorthEastern")

Catch ex As Exception
MessageBox.Show("Update Failed")
End Try

RefreshDataset()
End Sub

private void UpdateButton_Click(object sender, EventArgs e)

{
Int32 newRegionID = 5;

try
{
regionTableAdapter1.Update(newRegionID, "Updated Region Description", 5, "NorthEastern");
}
catch (Exception ex)
{
MessageBox.Show("Update Failed");
}
RefreshDataset();
}

Para adicionar código para excluir registros do banco de dados

1. Selecione DeleteButton para criar um manipulador de eventos para o evento de clique e abra o
formulário no editor de código.
2. Substitua o manipulador de eventos DeleteButton_Click pelo seguinte código:

Private Sub DeleteButton_Click() Handles DeleteButton.Click

Try
RegionTableAdapter1.Delete(5, "Updated Region Description")

Catch ex As Exception
MessageBox.Show("Delete Failed")
End Try

RefreshDataset()
End Sub
private void DeleteButton_Click(object sender, EventArgs e)
{
try
{
regionTableAdapter1.Delete(5, "Updated Region Description");
}
catch (Exception ex)
{
MessageBox.Show("Delete Failed");
}
RefreshDataset();
}

Executar o aplicativo
Selecione F5 para executar o aplicativo.
Selecione o botão Inserir e verifique se o novo registro aparece na grade.
Selecione o botão Atualizar e verifique se o registro está atualizado na grade.
Selecione o botão Excluir e verifique se o registro foi removido da grade.

Próximas etapas
Dependendo dos requisitos do aplicativo, há várias etapas que talvez você queira executar depois de criar um
formulário com limite de dados. Entre algumas das melhorias que você poderia fazer nessa explicação passo a
passo estão:
Adicionando funcionalidade de busca ao formulário.
Adicionar tabelas ao conjunto de dados, selecionando Configurar DataSet com Assistente na janela
Fontes de Dados . Você pode adicionar controles que exibem dados relacionados, arrastando os nós
relacionados para o formulário. Para obter mais informações, consulte Relações em conjuntos de dados.

Confira também
Salvar dados novamente no banco de dados
Salvar um conjunto de dados como XML
20/11/2021 • 2 minutes to read

Acesse os dados XML em um conjuntos de dados chamando os métodos XML disponíveis no conjuntos de
dados. Para salvar os dados no formato XML, você pode chamar o GetXml método ou o método de um
WriteXml DataSet .
Chamar o método retorna uma cadeia de caracteres que contém os dados de todas as tabelas de dados no
conjuntos de dados GetXml formatados como XML.
Chamar o WriteXml método envia os dados formatados em XML para um arquivo que você especificar.

Para salvar os dados em um conjuntos de dados como XML em uma

variável
O método GetXml retorna uma String. Declare uma variável do String tipo e atribua a ela os resultados
do GetXml método .

Dim xmlData As String = NorthwindDataSet.GetXml()

string xmlData = northwindDataSet.GetXml();

Para salvar os dados em um conjuntos de dados como XML em um

arquivo
O WriteXml método tem várias sobrecargas. Declare uma variável e atribua a ela um caminho válido para
salvar o arquivo. O código a seguir mostra como salvar os dados em um arquivo:

Dim filePath As String = "ENTER A VALID FILEPATH"

NorthwindDataSet.WriteXml(filePath)

string filePath = "ENTER A VALID FILEPATH";

northwindDataSet.WriteXml(filePath);

Confira também
Salvar dados novamente no banco de dados
Consultar conjuntos de dados
20/11/2021 • 5 minutes to read

Para pesquisar registros específicos em um conjunto de dados, use o método na DataTable, escreva sua própria
instrução foreach para fazer um loop na coleção Linhas da tabela ou use FindBy LINQ to DataSet.

Sensibilidade de caso do conjuntos de dados

Dentro de um conjuntos de dados, os nomes de tabela e coluna não são sensíveis a maiúsculas e minúsculas
por padrão, ou seja, uma tabela em um conjuntos de dados chamado "Clientes" também pode ser chamada de
"clientes". Isso corresponde às convenções de nomen entre vários bancos de dados, incluindo SQL Server. No
SQL Server, o comportamento padrão é que os nomes dos elementos de dados não podem ser diferenciados
apenas por caso.

NOTE
Ao contrário dos conjuntos de dados, os documentos XML são sensíveis a minúsculas, portanto, os nomes dos elementos
de dados definidos em esquemas são sensíveis a minúsculas. Por exemplo, o protocolo de esquema permite que o
esquema defina uma tabela chamada "Clientes" e uma tabela diferente chamada "clientes". Isso pode resultar em colisões
de nome quando um esquema que contém elementos que diferem apenas por caso é usado para gerar uma classe de
conjuntos de dados.

No entanto, a sensibilidade a casos pode ser um fator em como os dados são interpretados dentro do conjuntos
de dados. Por exemplo, se você filtrar dados em uma tabela de conjuntos de dados, os critérios de pesquisa
poderão retornar resultados diferentes dependendo se a comparação diferencia minúsculas. Você pode
controlar a sensibilidade de caso de filtragem, pesquisa e classificação definindo a propriedade do conjuntos de
CaseSensitive dados. Todas as tabelas no conjuntos de dados herdam o valor dessa propriedade por padrão.
(Você pode substituir essa propriedade para cada tabela individual definindo a propriedade da CaseSensitive
tabela.)

Localizar uma linha específica em uma tabela de dados

Para encontrar uma linha em um conjuntos de dados digitado com um valor de chave primária
Para localizar uma linha, chame o método fortemente digitado que usa a FindBy chave primária da
tabela.
No exemplo a seguir, CustomerID a coluna é a chave primária da Customers tabela. Isso significa que o
método FindBy gerado é FindByCustomerID . O exemplo mostra como atribuir um específico DataRow a
uma variável usando o método FindBy gerado.

NorthwindDataSet.CustomersRow customersRow =
northwindDataSet1.Customers.FindByCustomerID("ALFKI");

Dim customersRow As NorthwindDataSet.CustomersRow

customersRow = NorthwindDataSet1.Customers.FindByCustomerID("ALFKI")

Para encontrar uma linha em um conjuntos de dados sem tipo com um valor de chave primária
Chame o método de uma coleção, passando a Find chave primária como um DataRowCollection
parâmetro.
O exemplo a seguir mostra como declarar uma nova linha chamada e atribuir a ela foundRow o valor de
retorno do método Find . Se a chave primária for encontrada, o conteúdo do índice de coluna 1 será
exibido em uma caixa de mensagem.

string s = "primaryKeyValue";
DataRow foundRow = dataSet1.Tables["AnyTable"].Rows.Find(s);

if (foundRow != null)
{
MessageBox.Show(foundRow[0].ToString());
}
else
{
MessageBox.Show("A row with the primary key of " + s + " could not be found");
}

Dim s As String = "primaryKeyValue"

Dim foundRow As DataRow = DataSet1.Tables("AnyTable").Rows.Find(s)

If foundRow IsNot Nothing Then

MsgBox(foundRow(1).ToString())
Else
MsgBox("A row with the primary key of " & s & " could not be found")
End If

Encontrar linhas por valores de coluna

Para encontrar linhas com base nos valores em qualquer coluna
As tabelas de dados são criadas com o método , que retorna uma Select matriz de s com base na
expressão passada para o método DataRow Select . Para obter mais informações sobre como criar
expressões válidas, consulte a seção "Sintaxe de expressão" da página sobre a Expression propriedade .
O exemplo a seguir mostra como usar o Select método do para localizar linhas DataTable específicas.

DataRow[] foundRows;
foundRows = dataSet1.Tables["Customers"].Select("CompanyName Like 'A%'");

Dim foundRows() As Data.DataRow

foundRows = DataSet1.Tables("Customers").Select("CompanyName Like 'A%'")

Acessar registros relacionados

Quando as tabelas em um conjuntos de dados estão relacionadas, DataRelation um objeto pode disponibilizar
os registros relacionados em outra tabela. Por exemplo, um conjuntos de dados contendo Customers Orders
tabelas e pode ser disponibilizado.
Você pode usar um DataRelation objeto para localizar registros relacionados chamando o método de um na
tabela GetChildRows DataRow pai. Esse método retorna uma matriz de registros filho relacionados. Ou você
pode chamar o GetParentRow método de um na tabela DataRow filho. Esse método retorna um único DataRow
da tabela pai.
Esta página fornece exemplos usando conjuntos de dados digitados. Para obter informações sobre como
navegar em relações em conjuntos de dados sem tipo, consulte Navegando por DataRelations.
NOTE
Se você estiver trabalhando em um aplicativo Windows Forms e usando os recursos de associação de dados para exibir
dados, o formulário gerado pelo designer poderá fornecer funcionalidade suficiente para seu aplicativo. Para obter mais
informações, confira Associar controles a dados no Visual Studio. Especificamente, consulte Relações em conjuntos de
dados.

Os exemplos de código a seguir demonstram como navegar para cima e para baixo em conjuntos de dados
digitados. Os exemplos de código usam s digitados ( ) e os métodos DataRow NorthwindDataSet.OrdersRow
FindBy PrimaryKey ( ) gerados para localizar uma linha desejada e FindByCustomerID retornar os registros
relacionados. Os exemplos são compilados e executados corretamente somente se você tiver:
Uma instância de um conjuntos de dados chamado NorthwindDataSet com uma Customers tabela.
Uma Orders tabela.
Uma relação chamada FK_Orders_Customers relaciona as duas tabelas.
Além disso, ambas as tabelas precisam ser preenchidas com dados para que todos os registros sejam
retornados.
Para retornar os registros filho de um registro pai selecionado
Chame o GetChildRows método de uma linha de dados específica e retorne uma matriz de linhas da
Customers Orders tabela:

string custID = "ALFKI";

NorthwindDataSet.OrdersRow[] orders;

orders = (NorthwindDataSet.OrdersRow[])northwindDataSet.Customers.
FindByCustomerID(custID).GetChildRows("FK_Orders_Customers");

MessageBox.Show(orders.Length.ToString());

Dim customerID As String = "ALFKI"

Dim orders() As NorthwindDataSet.OrdersRow

orders = CType(NorthwindDataSet.Customers.FindByCustomerID(customerID).
GetChildRows("FK_Orders_Customers"), NorthwindDataSet.OrdersRow())

MessageBox.Show(orders.Length.ToString())

Para retornar o registro pai de um registro filho selecionado

Chame o GetParentRow método de uma linha de dados específica e retorne uma única linha da Orders
Customers tabela:

int orderID = 10707;

NorthwindDataSet.CustomersRow customer;

customer = (NorthwindDataSet.CustomersRow)northwindDataSet.Orders.
FindByOrderID(orderID).GetParentRow("FK_Orders_Customers");

MessageBox.Show(customer.CompanyName);
Dim orderID As Integer = 10707
Dim customer As NorthwindDataSet.CustomersRow

customer = CType(NorthwindDataSet.Orders.FindByOrderID(orderID).
GetParentRow("FK_Orders_Customers"), NorthwindDataSet.CustomersRow)

MessageBox.Show(customer.CompanyName)

Confira também
Ferramentas de conjunto de dados no Visual Studio
Adicionar validação a um conjunto de dados de n
camadas
20/11/2021 • 6 minutes to read

Adicionar validação a um conjunto de dados separado em uma solução de n camadas é basicamente o mesmo
que adicionar validação a um conjunto de dados de arquivo único (um conjunto de dados em um único projeto).
O local sugerido para executar a validação em dados é durante ColumnChanging os eventos RowChanging e/ou
de uma tabela de dados.
O conjuntos de dados fornece a funcionalidade para criar classes parciais às quais você pode adicionar código
de usuário a eventos de alteração de coluna e linha das tabelas de dados no conjuntos de dados. Para obter
mais informações sobre como adicionar código a um conjuntos de dados em uma solução de n
camadas,consulte Adicionar código a conjuntos de dados em aplicativos de n camadas e Adicionar código a
TableAdaptersem aplicativos de n camadas . Para obter mais informações sobre classes parciais, consulte Como
dividir uma classe em classes parciais (Designer de Classe) ou Métodos e classes parciais.

NOTE
Quando você separa conjuntos de dados de TableAdapters (definindo a propriedade DataSet Project), as classes de
conjuntos de dados parciais existentes no projeto não serão movidas automaticamente. As classes de conjuntos de dados
parciais existentes devem ser movidas manualmente para o projeto de conjuntos de dados.

NOTE
O Designer de Conjuntos de Dados não cria automaticamente manipuladores de eventos em C# para os
ColumnChanging eventos RowChanging e . Você precisa criar manualmente um manipulador de eventos e conectar o
manipulador de eventos ao evento subjacente. Os procedimentos a seguir descrevem como criar os manipuladores de
eventos necessários em Visual Basic e C#.

Validar alterações em colunas individuais

Valide valores em colunas individuais manipulando o ColumnChanging evento. O ColumnChanging evento é
gerado quando um valor em uma coluna é modificado. Crie um manipulador de eventos para o evento clicando
duas vezes na coluna ColumnChanging desejada no Designer de Conjunto de Dados .
Na primeira vez que você clica duas vezes em uma coluna, o designer gera um manipulador de eventos para o
ColumnChanging evento. Uma If...Then instrução também é criada que testa a coluna específica. Por
exemplo, o código a seguir é gerado quando você clica duas vezes na coluna RequiredDate na tabela
Northwind Orders:

Private Sub OrdersDataTable_ColumnChanging(ByVal sender As System.Object, ByVal e As

System.Data.DataColumnChangeEventArgs) Handles Me.ColumnChanging
If (e.Column.ColumnName = Me.RequiredDateColumn.ColumnName) Then
' Add validation code here.
End If
End Sub
NOTE
Em projetos C#, o Designer de Conjunto de Dados cria apenas classes parciais para o conjuntos de dados e tabelas
individuais no conjuntos de dados. O Designer de Conjunto de Dados cria automaticamente manipuladores de eventos
para os eventos e em C# como ColumnChanging RowChanging faz Visual Basic. Em projetos C#, você precisa construir
manualmente um método para manipular o evento e conectar o método ao evento subjacente. O procedimento a seguir
fornece as etapas para criar os manipuladores de eventos necessários em Visual Basic e C#.

Para adicionar validação durante alterações a valores de coluna individuais

1. Abra o conjuntos de dados clicando duas vezes no arquivo .xsd no Gerenciador de Soluções . Para
obter mais informações, consulte Passo a passo: criando um conjuntos de dados no Designer de
Conjunto de Dados.
2. Clique duas vezes na coluna que você deseja validar. Essa ação cria o ColumnChanging manipulador de
eventos.

NOTE
O Designer de Conjunto de Dados não cria automaticamente um manipulador de eventos para o evento C#. O
código necessário para manipular o evento em C# está incluído na próxima seção. SampleColumnChangingEvent
é criado e, em seguida, conectado ColumnChanging ao evento no método EndInit .

3. Adicione código para verificar se e.ProposedValue contém dados que atendam aos requisitos do seu
aplicativo. Se o valor proposto for inaceitável, depure a coluna para indicar que ele contém um erro.
O exemplo de código a seguir valida que a coluna Quantity contém um valor maior que 0. Se Quantity
for menor ou igual a 0, a coluna será definida como um erro. A Else cláusula limpará o erro se
Quantity for maior que 0. O código no manipulador de eventos de alteração de coluna deve ser
semelhante ao seguinte:

If (e.Column.ColumnName = Me.QuantityColumn.ColumnName) Then

If CType(e.ProposedValue, Short) <= 0 Then
e.Row.SetColumnError(e.Column, "Quantity must be greater than 0")
Else
e.Row.SetColumnError(e.Column, "")
End If
End If
// Add this code to the DataTable partial class.

public override void EndInit()

{
base.EndInit();
// Hook up the ColumnChanging event
// to call the SampleColumnChangingEvent method.
ColumnChanging += SampleColumnChangingEvent;
}

public void SampleColumnChangingEvent(object sender, System.Data.DataColumnChangeEventArgs e)

{
if (e.Column.ColumnName == QuantityColumn.ColumnName)
{
if ((short)e.ProposedValue <= 0)
{
e.Row.SetColumnError("Quantity", "Quantity must be greater than 0");
}
else
{
e.Row.SetColumnError("Quantity", "");
}
}
}

Validar alterações em linhas inteiras

Valide valores em linhas inteiras manipulando o RowChanging evento. O RowChanging evento é gerado
quando os valores em todas as colunas são confirmados. É necessário validar no evento quando o valor em
uma RowChanging coluna depende do valor em outra coluna. Por exemplo, considere OrderDate e
RequiredDate na tabela Orders em Northwind.
Quando os pedidos estão sendo inseridos, a validação garante que um pedido não seja inserido com um
RequiredDate que está em ou antes de OrderDate. Neste exemplo, os valores das colunas RequiredDate e
OrderDate precisam ser comparados, portanto, validar uma alteração de coluna individual não faz sentido.
Crie um manipulador de eventos para o evento clicando duas vezes no nome da tabela na barra de título da
tabela no RowChanging Designer de Conjunto de Dados .
Para adicionar validação durante alterações em linhas inteiras
1. Abra o conjuntos de dados clicando duas vezes no arquivo .xsd no Gerenciador de Soluções . Para
obter mais informações, consulte Passo a passo: criando um conjuntos de dados no Designer de
Conjunto de Dados.
2. Clique duas vezes na barra de título da tabela de dados no designer.
Uma classe parcial é criada com um RowChanging manipulador de eventos e é aberta no Editor de
Códigos.

NOTE
O Designer de Conjunto de Dados cria automaticamente um manipulador de eventos para o RowChanging
evento em projetos C#. Você precisa criar um método para manipular o evento e executar o código e, em seguida,
conectar o evento RowChanging no método de inicialização da tabela.

3. Adicione o código do usuário dentro da declaração de classe parcial.

4. O código a seguir mostra onde adicionar o código do usuário a ser validado durante o RowChanging
evento. O exemplo de C# também inclui código para conectar o método do manipulador de eventos ao
OrdersRowChanging evento.

Partial Class OrdersDataTable

Private Sub OrdersDataTable_OrdersRowChanging(ByVal sender As System.Object, ByVal e As
OrdersRowChangeEvent) Handles Me.OrdersRowChanging
' Add logic to validate columns here.
If e.Row.RequiredDate <= e.Row.OrderDate Then
' Set the RowError if validation fails.
e.Row.RowError = "Required Date cannot be on or before the OrderDate"
Else
' Clear the RowError when validation passes.
e.Row.RowError = ""
End If
End Sub
End Class

partial class OrdersDataTable

{
public override void EndInit()
{
base.EndInit();
// Hook up the event to the
// RowChangingEvent method.
OrdersRowChanging += RowChangingEvent;
}

public void RowChangingEvent(object sender, OrdersRowChangeEvent e)

{
// Perform the validation logic.
if (e.Row.RequiredDate <= e.Row.OrderDate)
{
// Set the row to an error when validation fails.
e.Row.RowError = "Required Date cannot be on or before the OrderDate";
}
else
{
// Clear the RowError if validation passes.
e.Row.RowError = "";
}
}
}

Confira também
Visão geral de aplicativos de dados de N camadas
Passo a passo: criando um aplicativo de dados de N camadas
Validar dados em conjuntos de dados
Adicionar código aos conjuntos de dados em
aplicativos de n camadas
20/11/2021 • 2 minutes to read

Você pode estender a funcionalidade de um conjunto de um DataSet criando um arquivo de classe parcial para
o conjunto de recursos e adicionando código a ele (em vez de adicionar código ao DataSetName. Arquivo
DataSet. Designer). As classes parciais permitem que o código de uma classe específica seja dividido entre
vários arquivos físicos. Para obter mais informações, consulte classes e métodos parciais ou parciais.
O código que define um conjunto de um DataSet é gerado toda vez que são feitas alterações na definição do
conjunto de código (no dataset tipado). Esse código também é gerado quando você faz alterações durante a
execução de qualquer assistente que modifica a configuração de um conjunto de uma. Para impedir que seu
código seja excluído durante a regeneração de um conjunto de um DataSet, adicione o código ao arquivo de
classe parcial do conjunto de um.
Por padrão, depois de separar o DataSet e o código do TableAdapter, o resultado é um arquivo de classe discreto
em cada projeto. O projeto original tem um arquivo chamado DataSetName. designer. vb (ou DataSetName.
designer. cs) que contém o código do TableAdapter. o projeto designado no conjunto de Project propriedade
tem um arquivo chamado datasetname. dataset. designer. vb (ou datasetname. dataset. designer. cs). Esse
arquivo contém o código do conjunto de conteúdo.

NOTE
quando você separa datasets e tableadapters (definindo o conjunto de Project propriedade de dataset), as classes
parciais de conjunto de linhas existentes no projeto não serão movidas automaticamente. As classes parciais de DataSet
existentes devem ser movidas manualmente para o projeto do conjunto de um.

NOTE
Quando o código de validação precisa ser adicionado, o dataset tipado fornece a funcionalidade de geração
ColumnChanging e RowChanging manipuladores de eventos. Para obter mais informações, consulte Adicionar validação a
um conjuntode dados de n camadas.

Para adicionar código a conjuntos de valores em aplicativos de n

camadas
1. Localize o projeto que contém o arquivo . xsd .
2. Selecione o arquivo . xsd para abrir o conjunto de um.
3. Clique com o botão direito do mouse na tabela de dados à qual você deseja adicionar o código (o nome
da tabela na barra de título) e, em seguida, selecione Exibir código .
Uma classe parcial é criada e aberta no editor de código.
4. Adicione o código dentro da declaração de classe parcial.
O exemplo a seguir mostra onde adicionar código ao CustomersDataTable no NorthwindDataSet:
Partial Public Class CustomersDataTable
' Add code here to add functionality
' to the CustomersDataTable.
End Class

partial class CustomersDataTable

{
// Add code here to add functionality
// to the CustomersDataTable.
}

Confira também
Visão geral de aplicativos de dados de N camadas
Adicionar código a TableAdapters em aplicativos de n camadas
Criar e configurar TableAdapters
Visão geral de atualização hierárquica
Ferramentas de DataSet no Visual Studio
Adicionar código a TableAdapters em aplicativos de
n camadas
20/11/2021 • 2 minutes to read

Você pode estender a funcionalidade de um TableAdapter criando um arquivo de classe parcial para o
TableAdapter e adicionando código a ele (em vez de adicionar código ao arquivo DataSetName. DataSet.
designer ). As classes parciais permitem que o código de uma classe específica seja dividido entre vários
arquivos físicos. Para obter mais informações, consulte parcial ou parcial (tipo).
O código que define um TableAdapter é gerado sempre que são feitas alterações no TableAdapter no conjunto
de data. Esse código também é gerado quando são feitas alterações durante a execução de qualquer assistente
que modifica a configuração do TableAdapter. Para impedir que seu código seja excluído durante a regeneração
de um TableAdapter, adicione o código ao arquivo de classe parcial do TableAdapter.
Por padrão, depois de separar o DataSet e o código do TableAdapter, o resultado é um arquivo de classe discreto
em cada projeto. O projeto original tem um arquivo chamado DataSetName. designer. vb (ou DataSetName.
designer. cs) que contém o código do TableAdapter. o projeto designado no conjunto de Project propriedade
tem um arquivo chamado datasetname. Dataset. designer. vb (ou datasetname. dataset. Designer. cs) que
contém o código do conjunto de conteúdo.

NOTE
Quando você separa os conjuntos de dados e os TableAdapters (configurando a propriedade Projeto de Conjunto de
Dados ), as classes dos conjuntos de dados parciais existentes no projeto não são movidas automaticamente. As classes
parciais de DataSet existentes devem ser movidas manualmente para o projeto DataSet.

NOTE
O conjunto de recursos fornece a funcionalidade de geração ColumnChanging e RowChanging manipuladores de eventos
quando a validação é necessária. Para obter mais informações, consulte Adicionar validação a um conjuntode dados de n
camadas.

Para adicionar código de usuário a um TableAdapter em um aplicativo

de n camadas
1. Localize o projeto que contém o arquivo . xsd .
2. Clique duas vezes no arquivo . xsd para abrir o Designer de conjunto de dados .
3. Clique com o botão direito do mouse no TableAdapter ao qual você deseja adicionar o código e selecione
Exibir código .
Uma classe parcial é criada e aberta no editor de código.
4. Adicione o código dentro da declaração de classe parcial.
5. O exemplo a seguir mostra onde adicionar código ao CustomersTableAdapter no NorthwindDataSet :

Partial Public Class CustomersTableAdapter

' Add code here to add functionality
' to the CustomersTableAdapter.
End Class

public partial class CustomersTableAdapter

{
// Add code here to add functionality
// to the CustomersTableAdapter.
}

Confira também
Visão geral de aplicativos de dados de N camadas
Adicionar código a conjuntos de dados em aplicativos de n camadas
Criar e configurar TableAdapters
Visão geral de atualização hierárquica
Conjuntos de dados e TableAdapters separados m
diferentes projetos
20/11/2021 • 2 minutes to read

Os conjuntos de dados digitados foram aprimorados para que as classes TableAdapters e de conjuntos de dados
possam ser geradas em projetos separados. Isso permite separar rapidamente as camadas de aplicativo e gerar
aplicativos de dados de n camadas.
O procedimento a seguir descreve o processo de usar o Designer de Conjunto de Dados para gerar código
de conjuntos de dados em um projeto separado do projeto que contém o código TableAdapter gerado.

Conjuntos de dados separados e TableAdapters

Quando você separa o código do conjuntos de dados do código TableAdapter, o projeto que contém o código do
conjuntos de dados deve estar localizado na solução atual. Se esse projeto não estiver localizado na solução
atual, ele não estará disponível na lista DataSet Project na janela Propriedades.

Para separar o conjuntos de dados em um projeto diferente

1. Abra uma solução que contém um conjuntos de dados (arquivo .xsd).

NOTE
Se a solução não contém o projeto no qual você deseja separar o código do seu conjuntos de dados, crie o
projeto ou adicione um projeto existente à solução.

2. Clique duas vezes em um arquivo de conjuntos de dados digitado (um arquivo .xsd) no Gerenciador de
Soluções para abrir o conjuntos de dados no Designer de Conjunto de Dados .
3. Selecione uma área vazia do Designer de Conjunto de Dados .
4. Na janela Propriedades, localize o nó DataSet Project.
5. Na lista DataSet Project, selecione o nome do projeto no qual você deseja gerar o código do conjuntos
de dados.
Depois de selecionar o projeto no qual deseja gerar o código do conjuntos de dados, a propriedade
Arquivo de Conjuntos de Dados é populada com um nome de arquivo padrão. Você pode alterar esse
nome, se necessário. Além disso, se você quiser gerar o código do conjunto de dados em um diretório
específico, poderá definir a propriedade Project Pasta como o nome de uma pasta.
NOTE
Quando você separa conjuntos de dados e TableAdapters (definindo a propriedade DataSet Project), as classes
de conjuntos de dados parciais existentes no projeto não serão movidas automaticamente. As classes de
conjuntos de dados parciais existentes devem ser movidas manualmente para o projeto de conjuntos de dados.

6. Salve o conjuntos de dados.

O código do conjuntos de dados é gerado no projeto selecionado na propriedade DataSet Project e o
código TableAdapter é gerado no projeto atual.
Por padrão, depois de separar o conjuntos de dados e o código TableAdapter, o resultado é um arquivo de classe
discreto em cada projeto. O projeto original tem um arquivo chamado DatasetName.Designer.vb (ou
DatasetName.Designer.cs) que contém o código TableAdapter. O projeto designado na propriedade Dataset
Project tem um arquivo chamado DatasetName.DataSet.Designer.vb (ou DatasetName.DataSet.Designer.cs) que
contém o código do conjuntos de dados.

NOTE
Para exibir o arquivo de classe gerado, selecione o grupo de dados ou o projeto TableAdapter. Em seguida, Gerenciador
de Soluções , selecione Mostrar Todos os Arquivos .

Confira também
Visão geral de aplicativos de dados de N camadas
Passo a passo: criando um aplicativo de dados de N camadas
Atualização hierárquica
Acessando dados em Visual Studio
ADO.NET
Associar controles a dados no Visual Studio
20/11/2021 • 3 minutes to read

É possível exibir dados para usuários do aplicativo associando-se dados a controles. Você pode criar esses
controles vinculados a dados arrastando itens da janela Fontes de Dados para uma superfície de design ou
controles em uma superfície Visual Studio.
Este tópico descreve as fontes de dados que você pode usar para criar controles vinculados a dados. Ele também
descreve algumas das tarefas gerais envolvidas na associação de dados. Para obter detalhes mais específicos
sobre como criar controles vinculados a dados, consulte Bind Windows Forms controls to data in Visual Studio
and Bind WPF controlsto data in Visual Studio .

Fontes de dados
No contexto da associação de dados, uma fonte de dados representa os dados na memória que podem ser
vinculados à interface do usuário. Em termos práticos, uma fonte de dados pode ser uma classe Entity
Framework, um conjunto de dados, um ponto de extremidade de serviço encapsulado em um objeto proxy .NET,
uma classe LINQ to SQL ou qualquer objeto ou coleção .NET. Algumas fontes de dados permitem que você crie
controles com limite de dados arrastando itens da janela Fontes de Dados, enquanto outras fontes de dados
não. A tabela a seguir mostra quais fontes de dados têm suporte.

SUP O RT E DO T IP O
" A RRA STA R E SO LTA R" N O SUP O RT E PA RA A RRA STA R SUP O RT E PA RA A RRA STA R
DESIGN ER W IN DO W S E SO LTA R N O W P F E SO LTA R N O DESIGN ER DO
F O N T E DE DA DO S F O RM S DESIGN ER SILVERL IGH T

Conjunto de dados Sim Sim Não

Modelo de Dados de Sim1 Sim Sim

Entidade

Classes do LINQ to SQL Não2 Não2 Não2

Serviços (incluindo WCF Sim Sim Sim

Data Services , serviços
WCF e serviços Web)

Objeto Sim Sim Sim

SharePoint Sim Sim Sim

1. Gere o modelo usando o assistente Modelo de Dados de Entidade e arraste esses objetos para o
designer.
2. LINQ to SQL classes não aparecem na janela Fontes de Dados. No entanto, você pode adicionar uma
nova fonte de dados de objeto baseada em classes LINQ to SQL e, em seguida, arrastar esses objetos
para o designer para criar controles vinculados a dados. Para obter mais informações, consulte Passo a
passo: criando LINQ to SQL classes (Designer O-R).

janela Fontes de Dados

As fontes de dados estão disponíveis para seu projeto como itens na janela Fontes de Dados. Essa janela fica
visível quando uma superfície de design de formulário é a janela ativa em seu projeto ou você pode abri-la
(quando um projeto está aberto) escolhendo Exibir Outras Fontes de Dados Windows > > . Você pode arrastar
itens dessa janela para criar controles que estão vinculados aos dados subjacentes e também pode configurar as
fontes de dados clicando com o botão direito do mouse.

Para cada tipo de dados que aparece na janela Fontes de Dados, um controle padrão é criado quando você
arrasta o item para o designer. Antes de arrastar um item da janela Fontes de Dados, você pode alterar o
controle criado. Para obter mais informações, consulte Definir o controle a ser criado ao arrastar da janela
Fontes de Dados.

Tarefas envolvidas na associação de controles a dados

A tabela a seguir lista algumas das tarefas mais comuns que você executa para vincular controles aos dados.

TA REFA M A IS IN F O RM A Ç Õ ES

Abra a janela Fontes de Dados. Abra uma superfície de design no editor e escolha Exibir
Fontes > de Dados .

Adicione uma fonte de dados ao seu projeto. Adicionar novas fontes de dados

De definir o controle criado quando você arrasta um item da Definir o controle a ser criado quando arrastado da janela
janela Fontes de Dados para o designer. Fontes de Dados

Modifique a lista de controles associados a itens na janela Adicionar controles personalizados à janela Fontes de Dados
Fontes de Dados.

Criar controles com limite de dados. Associar controles do Windows Forms a dados no Visual
Studio

Associar controles WPF a dados no Visual Studio

A vincular a um objeto ou coleção. Associar objetos no Visual Studio

Filtrar dados que aparecem na interface do usuário. Filtrar e classificar dados em um aplicativo do Windows
Forms

Personalizar legendas para controles. Personalizar como o Visual Studio cria legendas para
controles associados a dados
Confira também
Ferramentas de dados do Visual Studio para .NET
Windows Associação de dados de formulários
Definir o controle a ser criado quando arrastado da
janela Fontes de Dados
20/11/2021 • 3 minutes to read

Você pode criar controles vinculados a dados arrastando itens da janela Fontes de Dados para o designer WPF
ou o designer Windows Forms. Cada item na janela Fontes de Dados tem um controle padrão criado quando
você o arrasta para o designer. No entanto, você pode optar por criar um controle diferente.

Definir os controles a serem criados para tabelas de dados ou objetos

Antes de arrastar itens que representam tabelas de dados ou objetos da janela Fontes de Dados, você pode
optar por exibir todos os dados em um controle ou exibir cada coluna ou propriedade em um controle
separado.
Nesse contexto, o termo objeto refere-se a um objeto de negócios personalizado, uma entidade (em um Modelo
de Dados de Entidade) ou um objeto retornado por um serviço.
Para definir os controles a serem criados para tabelas de dados ou objetos
1. Certifique-se de que o designer do WPF ou o designer Windows Forms está aberto.
2. Na janela Fontes de Dados, selecione o item que representa a tabela de dados ou o objeto que você
deseja definir.

TIP
Se a janela Fontes de Dados não estiver aberta, você poderá abri-la selecionando Exibir > Windows > Fontes
de Dados .

3. Clique no menu suspenso do item e clique em um dos seguintes itens no menu:

Para exibir cada campo de dados em um controle separado, clique em Detalhes. Quando você
arrastar o item de dados para o designer, essa ação criará um controle de limite de dados diferente
para cada coluna ou propriedade da tabela de dados pai ou objeto, juntamente com rótulos para
cada controle.
Para exibir todos os dados em um único controle, selecione um controle diferente na lista, como
DataGrid ou List em um aplicativo WPF ou DataGridView em um aplicativo Windows Forms.
A lista de controles disponíveis depende de qual designer você tem aberto, qual versão do .NET seu
projeto tem como destino e se você adicionou controles personalizados que suportam associação de
dados à Caixa de Ferramentas . Se o controle que você deseja criar não estiver na lista de controles
disponíveis, você poderá adicionar o controle à lista. Para obter mais informações, consulte Adicionar
controles personalizados à janela Fontes de Dados.
Para saber como criar um controle personalizado do Windows Forms que pode ser adicionado à lista de
controles para tabelas de dados ou objetos na janela Fontes de Dados, consulte Criar um controle de
usuário do Windows Forms que dá suporte à associação de dados complexa.

Definir os controles a serem criados para colunas de dados ou

propriedades
Antes de arrastar um item que representa uma coluna ou uma propriedade de um objeto da janela Fontes de
Dados para o designer, você pode definir o controle a ser criado.
Para definir os controles a serem criados para colunas ou propriedades
1. Certifique-se de que o designer do WPF ou o designer Windows Forms está aberto.
2. Na janela Fontes de Dados, expanda a tabela ou objeto desejado para exibir suas colunas ou
propriedades.
3. Selecione cada coluna ou propriedade para a qual você deseja definir o controle a ser criado.
4. Clique no menu suspenso da coluna ou propriedade e selecione o controle que você deseja criar quando
o item for arrastado para o designer.
A lista de controles disponíveis depende de qual designer você tem aberto, qual versão do .NET seu
projeto tem como destino e quais controles personalizados que suportam associação de dados que você
adicionou à Caixa de Ferramentas . Se o controle que você deseja criar estiver na lista de controles
disponíveis, você poderá adicionar o controle à lista. Para obter mais informações, consulte Adicionar
controles personalizados à janela Fontes de Dados.
Para saber como criar um controle personalizado que pode ser adicionado à lista de controles para
colunas de dados ou propriedades na janela Fontes de Dados, consulte Criar um controle de usuário do
Windows Forms que dá suporte à associação de dados simples.
Se você não quiser criar um controle para a coluna ou propriedade, selecione Nenhum no menu
suspenso. Isso será útil se você quiser arrastar a tabela ou o objeto pai para o designer, mas não deseja
incluir a coluna ou a propriedade específica.

Confira também
Associar controles a dados no Visual Studio
Adicionar controles personalizados à janela Fontes
de Dados
20/11/2021 • 4 minutes to read

Quando você arrasta um item da janela fontes de dados para uma superfície de design para criar um controle
vinculado a dados, você pode selecionar o tipo de controle que você criar. Cada item na janela tem uma lista
suspensa que exibe os controles dos quais você pode escolher. O conjunto de controles associados a cada item é
determinado pelo tipo de dados do item. Se o controle que você deseja criar não aparecer na lista, você poderá
seguir as instruções neste tópico para adicionar o controle à lista.
Para obter mais informações sobre como selecionar controles vinculados a dados para criar itens na janela
fontes de dados, consulte definir o controle a ser criado ao arrastar da janela fontes de dados.

Personalizar a lista de controles vinculáveis

Para adicionar ou remover controles da lista de controles disponíveis para itens na janela fontes de dados que
têm um tipo de dados específico, execute as etapas a seguir.
Para selecionar os controles a serem listados para um tipo de dados
1. verifique se o Designer do WPF ou o Designer de Formulários do Windows está aberto.
2. Na janela fontes de dados , clique em um item que faz parte de uma fonte de dados que você
adicionou à janela e, em seguida, clique no menu suspenso do item.

TIP
se a janela fontes de dados não estiver aberta, abra-a selecionando exibir > outras > fontes de dados
Windows.

3. No menu suspenso, clique em Personalizar . Uma das seguintes caixas de diálogo é aberta:
se o Designer de Formulários do Windows estiver aberto, a página personalização da
interface do usuário de dados da caixa de diálogo opções será aberta. Para obter mais
informações, consulte caixa de diálogo opções de personalização de interface do usuário de dados.
Se o designer do WPF estiver aberto, a caixa de diálogo Personalizar vinculação de controle
será aberta.
4. Na caixa de diálogo, selecione um tipo de dados na lista suspensa tipo de dados .
Para personalizar a lista de controles de uma tabela ou objeto, selecione [lista] .
Para personalizar a lista de controles de uma coluna de uma tabela ou de uma propriedade de um
objeto, selecione o tipo de dados da coluna ou propriedade no armazenamento de dados
subjacente.
Para personalizar a lista de controles para exibir objetos de dados que têm formas definidas pelo
usuário, selecione [outros] . Por exemplo, selecione [outros] se seu aplicativo tiver um controle
personalizado que exibe dados de mais de uma propriedade de um objeto específico.
5. Na caixa controles associados , selecione cada controle que você deseja disponibilizar para o tipo de
dados selecionado ou desmarque a seleção de todos os controles que deseja remover da lista.
NOTE
Se o controle que você deseja selecionar não aparecer na caixa controles associados , você deverá adicionar o
controle à lista. Para obter mais informações, consulte Adicionar controles associados.

6. Clique em OK .
7. Na janela fontes de dados , clique em um item do tipo de dados ao qual você acabou de associar um
ou mais controles e, em seguida, clique no menu suspenso do item.
Os controles selecionados na caixa controles associados agora aparecem no menu suspenso do item.

Adicionar controles associados

Se você quiser associar um controle a um tipo de dados, mas o controle não aparecer na caixa controles
associados , você deverá adicionar o controle à lista. O controle deve estar localizado na solução atual ou em
um assembly referenciado. Ele também deve estar disponível na caixa de ferramentas e ter um atributo que
especifica o comportamento de vinculação de dados do controle.
Para adicionar controles à lista de controles associados:
1. Adicione o controle desejado à caixa de ferramentas clicando com o botão direito do mouse na caixa
de ferramentas e selecionando escolher itens .
O controle deve ter um dos seguintes atributos:

AT RIB UTO DESC RIÇ Ã O

DefaultBindingPropertyAttribute Implemente esse atributo em controles simples que

exibem uma única coluna (ou Propriedade) de dados,
como um TextBox .

ComplexBindingPropertiesAttribute Implemente esse atributo em controles que exibem listas

(ou tabelas) de dados, como um DataGridView .

LookupBindingPropertiesAttribute Implemente esse atributo em controles que exibem listas

(ou tabelas) de dados, mas também precisam apresentar
uma única coluna ou propriedade, como um ComboBox .

2. para Windows Forms, na caixa de diálogo opções , abra a página personalização da interface do
usuário de dados . Ou, para o WPF, abra a caixa de diálogo Personalizar Associação de controle .
Para obter mais informações, consulte Personalizar a lista de controles vinculáveis para um tipo de dados.
3. Na caixa controles associados , o controle que você acabou de adicionar à Toolbox agora deve
aparecer.

NOTE
Somente os controles localizados na solução atual ou em um assembly referenciado podem ser adicionados à lista
de controles associados. (Os controles também devem implementar um dos atributos de vinculação de dados na
tabela anterior.) Para associar dados a um controle personalizado que não está disponível na janela fontes de
dados, arraste o controle da caixa de ferramentas para a superfície de design e, em seguida, arraste o item para
associar da janela fontes de dados para o controle.

Confira também
Associar controles a dados no Visual Studio
Caixa de diálogo opções de personalização da interface do usuário de dados
Associar controles WPF a dados no Visual Studio
20/11/2021 • 6 minutes to read

É possível exibir dados para usuários do aplicativo associando-se dados a controles WPF. Para criar esses
controles vinculados a dados, você pode arrastar itens da janela Fontes de Dados para o WPF Designer no
Visual Studio. Este tópico descreve algumas das tarefas, ferramentas e classes mais comuns que é possível usar
para criar aplicativos WPF de associação de dados.
Para obter informações gerais sobre como criar controles vinculados a dados no Visual Studio, consulte Bind
controls to data in Visual Studio. Para obter mais informações sobre WPF associação de dados, consulte Visão
geral da associação de dados.

Tarefas envolvidas na associação de controles WPF a dados

A tabela a seguir lista as tarefas que podem ser realizadas arrastando-se itens da janela Fontes de Dados para
o WPF Designer.

TA REFA M A IS IN F O RM A Ç Õ ES

Crie novos controles de associação de dados. Associar controles do WPF a um conjunto de dados

Associe controles existentes a dados.

Crie controles que exibam dados relacionados em uma Exibir dados relacionados em aplicativos WPF
relação pai-filho: quando o usuário seleciona um registro de
dados pai em um controle, outro controle exibe dados filho
relacionados ao registro selecionado.

Crie uma tabela de pesquisa que exiba informações de uma Criar tabelas de pesquisa em aplicativos do WPF
tabela com base no valor de um campo de chave estrangeira
em outra tabela.

Associe um controle a uma imagem em um banco de dados. Associar controles a imagens de um banco de dados

Reproduções automáticas válidas

É possível arrastar itens na janela Fontes de Dados apenas para reproduções automáticas válidas no WPF
Designer. Existem dois tipos principais de destinos depósitos válidos: contêineres e controles. Um contêiner é
um elemento de interface do usuário que normalmente contém controles. Por exemplo, uma grade é um
contêiner, assim como uma janela.

XAML e código gerados

Quando você arrasta um item da janela Fontes de Dados para o , o Visual Studio gera que define um novo
controle de limite de dados (ou vincula um controle existente à fonte de WPF Designer XAML dados). Para
algumas fontes de dados, Visual Studio também gera código no arquivo code-behind que preenche a fonte de
dados com dados.
A tabela a seguir lista o código e Visual Studio gerado para cada tipo de fonte de XAML dados na janela Fontes
de Dados.
GERA R XA M L Q UE A SSO C IA UM GERA R C Ó DIGO Q UE P REEN C H E A
F O N T E DE DA DO S C O N T RO L E À F O N T E DE DA DO S F O N T E DE DA DO S C O M DA DO S

Conjunto de dados Sim Sim

Modelo de Dados de Entidade Sim Sim

Serviço Sim Não

Objeto Sim Não

Conjunto de dados
Quando você arrasta uma tabela ou coluna da janela Fontes de Dados para o designer, Visual Studio gera XAML
o seguinte:
Adiciona o conjunto de dados e um novo CollectionViewSource aos recursos do contêiner arrastados
para o item. O CollectionViewSource é um objeto que pode ser usado para navegar e exibir os dados no
conjunto de dados.
Cria uma associação de dados para um controle. Se você arrastar o item para um controle existente no
designer, o XAML associará o controle ao item. Se você arrastar o item para um contêiner, o XAML criará
o controle selecionado para o item arrastado e ele vinculará o controle ao item. O controle é criado
dentro de um novo Grid.
O Visual Studio também faz as seguintes alterações no arquivo code-behind:
Cria um manipulador de eventos Loaded para o elemento Interface do usuário que contém o controle. O
manipulador de eventos preenche a tabela com dados, recupera o CollectionViewSource dos recursos do
contêiner e, em seguida, torna o primeiro item dados o item atual. Se um Loaded manipulador de eventos já
existir, Visual Studio esse código ao manipulador de eventos existente.
Modelos de dados de entidade
Quando você arrasta uma entidade ou uma propriedade de entidade da janela Fontes de Dados para o
designer, o Visual Studio gera XAML o seguinte:
Adiciona um novo CollectionViewSource aos recursos do contêiner arrastados para o item. O
CollectionViewSource é um objeto que pode ser usado para navegar e exibir os dados na entidade.
Cria uma associação de dados para um controle. Se você arrastar o item para um controle existente no
designer, o XAML associará o controle ao item. Se você arrastar o item para um contêiner, o criará o
controle selecionado para o item arrastado e ele vinculará o XAML controle ao item. O controle é criado
dentro de um novo Grid.
O Visual Studio também faz as seguintes alterações no arquivo code-behind:
Adiciona um novo método que retorna uma consulta para a entidade arrastada para o designer (ou a
entidade que contém a propriedade que você arrastou para o designer). O novo método tem o nome
Get<EntityName>Query , em que é o nome da \<EntityName> entidade.

Cria um manipulador de eventos Loaded para o elemento Interface do usuário que contém o controle. O
manipulador de eventos chama o método para preencher a entidade com dados, recupera o dos recursos
do contêiner e, em seguida, torna o primeiro Get<EntityName>Query item de dados o item
CollectionViewSource atual. Se um Loaded manipulador de eventos já existir, Visual Studio esse código
ao manipulador de eventos existente.
Serviços
Quando você arrasta um objeto de serviço ou uma propriedade da janela Fontes de Dados para o designer, o
Visual Studio gera que cria um controle de limite de dados (ou vincula um controle existente ao objeto ou XAML
propriedade). No entanto, Visual Studio não gera código que preenche o objeto de serviço proxy com dados.
Você deve gravar esse código sozinho. Para ver um exemplo que demonstra como fazer isso, consulte Vincular
controles WPF a um serviço de dados WCF.
O Visual Studio gera XAML, que faz o seguinte:
Adiciona um novo CollectionViewSource aos recursos do contêiner arrastados para o item. O
CollectionViewSource é um objeto que pode ser usado para navegar e exibir os dados no objeto
retornado pelo serviço.
Cria uma associação de dados para um controle. Se você arrastar o item para um controle existente no
designer, o XAML associará o controle ao item. Se você arrastar o item para um contêiner, o criará o
controle selecionado para o item arrastado e ele vinculará o XAML controle ao item. O controle é criado
dentro de um novo Grid.
Objetos
Quando você arrasta um objeto ou propriedade da janela Fontes de Dados para o designer, o Visual Studio gera
que cria um controle de limite de dados (ou vincula um controle existente ao objeto ou XAML propriedade). No
entanto, Visual Studio não gera código para preencher o objeto com dados. Você deve gravar esse código
sozinho.

NOTE
As classes personalizadas devem ser públicas e, por padrão, ter um construtor sem parâmetros. Eles não podem ser
classes aninhadas que têm um "ponto" em sua sintaxe. Para obter mais informações, consulte XAML e classes
personalizadas para o WPF.

Visual Studio gera XAML o que faz o seguinte:

Adiciona um novo CollectionViewSource aos recursos do contêiner arrastados para o item. O
CollectionViewSource é um objeto que pode ser usado para navegar e exibir os dados no objeto.
Cria uma associação de dados para um controle. Se você arrastar o item para um controle existente no
designer, o XAML associará o controle ao item. Se você arrastar o item para um contêiner, o XAML criará
o controle selecionado para o item arrastado e ele vinculará o controle ao item. O controle é criado
dentro de um novo Grid.

Confira também
Associar controles a dados no Visual Studio
Associar controles do WPF a um conjunto de dados
20/11/2021 • 8 minutes to read

Neste passo a passo, você cria um aplicativo WPF que contém controles com limite de dados. Os controles são
associados a registros de produto que são encapsulados em um conjunto de dados. Você também adiciona
botões para navegar pelos produtos e salvar as alterações nos registros do produto.
Este passo a passo ilustra as seguintes tarefas:
Criando um aplicativo WPF e um conjunto de dados gerado a partir de dados no banco de dados de
exemplo AdventureWorksLT.
Criando um conjunto de controles de associação de dados ao arrastar uma tabela de dados da janela
Fontes de Dados para uma janela do WPF Designer.
Criando botões que navegam para a frente e para trás nos registros de produtos.
Criando um botão para salvar as alterações que os usuários fazem nos registros de produtos na tabela de
dados e na fonte de dados subjacente.

Pré-requisitos
Você precisará dos seguintes componentes para concluir este passo a passo:
Visual Studio
Acesso a uma instância em execução do SQL Server ou SQL Server Express que tem o banco de dados de
exemplo AdventureWorks Light (AdventureWorksLT) anexado a ele. Para baixar o banco de dados,
consulte Bancos de dados de exemplo AdventureWorks.
Conhecimento prévio dos conceitos a seguir também é útil, mas não é necessário para concluir o passo a passo:
Conjuntos de dados e TableAdapters. Para obter mais informações, consulte Ferramentas de conjuntos de
dados no Visual Studio e TableAdapters.
Associação de dados do WPF. Para obter mais informações, consulte Visão geral da associação de dados.

Criar o projeto
Crie um novo projeto do WPF para exibir registros de produto.
1. Abra o Visual Studio.
2. No menu Arquivo, selecione Novo > Project .
3. Expanda Visual Basic ou Visual C# e selecione Windows .
4. Selecione o modelo de projeto aplicativo WPF.
5. Na caixa Nome, insira AdventureWorksProductsEditor e selecione OK.
1. Abra o Visual Studio.
2. Na janela inicial, escolha Criar um novo projeto.
3. Pesquise o modelo de projeto aplicativo WPF em C# e siga as etapas para criar o projeto, nomeando o
projeto AdventureWorksProductsEditor .
O Visual Studio cria o projeto AdventureWorksProductsEditor.

Criar um conjuntos de dados para o aplicativo

Antes de criar controles de associação de dados, você deve definir um modelo de dados para seu aplicativo e
adicioná-lo à janela Fontes de Dados . Neste passo a passo, você criará um conjunto de dados para usar como
modelo de dados.
1. No menu Dados , clique em Mostrar Fontes de Dados .
A janela Fontes de Dados é aberta.
2. Na janela Fontes de Dados , clique em Adicionar Nova Fonte de Dados .
O assistente de Configuração da Fonte de Dados é aberto.
3. Na página Escolher um Tipo de Fonte de Dados , selecione Banco de Dados e clique em Avançar .
4. Na página Escolher um Modelo de Banco de Dados , selecione Conjunto de Dados e clique em
Avançar .
5. Na página Escolha a Conexão de Dados , selecione uma das seguintes opções:
Se uma conexão de dados com o banco de dados de exemplo AdventureWorksLT estiver
disponível na lista suspensa, selecione-a e clique em Avançar .
Clique em Nova Conexão e crie uma conexão com o banco de dados AdventureWorksLT.
6. Na página Salvar a Cadeia de Conexão no Arquivo de Configuração do Aplicativo marque a
caixa de seleção Sim, salvar a conexão como e clique em Próximo .
7. Na página Escolher Objetos do Banco de Dados , expanda Tabelas e selecione a tabela Produto
(SalesLT) .
8. Clique em Concluir .
Visual Studio adiciona um novo arquivo ao projeto e adiciona um AdventureWorksLTDataSet.xsd item
AdventureWorksLTDataSet correspondente à janela Fontes de Dados. O
AdventureWorksLTDataSet.xsd arquivo define um conjuntos de dados com tipo chamado e um
AdventureWorksLTDataSet TableAdapter chamado ProductTableAdapter . A seguir neste passo a passo,
você usará o ProductTableAdapter para preencher o conjunto de dados com dados e salvar as alterações
no banco de dados.
9. Compile o projeto.

Editar o método de preenchimento padrão do TableAdapter

Para preencher o conjunto de dados com dados, use o método Fill do ProductTableAdapter . Por padrão, o
método Fill preenche o ProductDataTable no AdventureWorksLTDataSet com todas as linhas de dados da
tabela Produto. Você pode modificar esse método para retornar apenas um subconjunto das linhas. Para este
passo a passo, modifique o método Fill para retornar somente linhas de produtos com fotos.
1. No Gerenciador de Soluções , clique duas vezes no arquivo AdventureWorksLTDataSet.xsd.
O designer de conjunto de dados é aberto.
2. No designer, clique com o botão direito do mouse na consulta Fill ,GetData() e selecione Configurar .
O assistente Configuração do TableAdapter é aberto.
3. Na página Insira uma Instrução SQL , adicione a seguinte cláusula WHERE após a instrução SELECT na
caixa de texto.

WHERE ThumbnailPhotoFileName <> 'no_image_available_small.gif'

4. Clique em Concluir .

Definir a interface do usuário

Adicione vários botões à janela, modificando o XAML no WPF Designer. A seguir neste passo a passo, você
adicionará o código que permite aos usuários navegar e salvar alterações nos registros de produtos, usando
esses botões.
1. No Gerenciador de Soluções , clique duas vezes em MainWindow.xaml.
A janela é aberta no WPF Designer.
2. Na exibição XAML do designer, adicione o seguinte código entre as marcas <Grid> :

<Grid.RowDefinitions>
<RowDefinition Height="75" />
<RowDefinition Height="625" />
</Grid.RowDefinitions>
<Button HorizontalAlignment="Left" Margin="22,20,0,24" Name="backButton" Width="75"><</Button>
<Button HorizontalAlignment="Left" Margin="116,20,0,24" Name="nextButton" Width="75">></Button>
<Button HorizontalAlignment="Right" Margin="0,21,46,24" Name="saveButton" Width="110">Save
changes</Button>

3. Compile o projeto.

Criar controles com limite de dados

Crie controles que exibem registros do cliente arrastando Product a tabela da janela Fontes de Dados para o
Designer do WPF.
1. Na janela Fontes de Dados , abra o menu suspenso para o nó Produto e selecione Detalhes .
2. Expanda o nó Produto .
3. Neste exemplo, alguns campos não serão exibidos, portanto, clique no menu suspenso ao lado dos
seguintes nós e selecione Nenhum :
ProductCategoryID
ProductModelID
ThumbnailPhotoFileName
rowguid
ModifiedDate
4. Clique no menu suspenso ao lado do nó ThumbNailPhoto e selecione Imagem .

NOTE
Por padrão, todos os itens na janela Fontes de Dados que representam as imagens têm seu controle padrão
definido como Nenhum . Isso ocorre porque as imagens são armazenadas como matrizes de bytes em bancos de
dados e as matrizes de bytes podem conter qualquer coisa, desde uma simples matriz de bytes até um arquivo
executável de um aplicativo grande.

5. Na janela Fontes de Dados , arraste o nó Produto para a linha de grade sob a linha que contém os
botões.
O Visual Studio gera XAML que define um conjunto de controles associados aos dados na tabela
Produtos . Também gera um código que carrega os dados. Para obter mais informações sobre o XAML e
o código gerados, consulte Bind WPF controls to data in Visual Studio.
6. No designer, clique na caixa de texto ao lado do rótulo de ID do Produto .
7. Na janela Propriedades , marque a caixa de seleção ao lado da propriedade IsReadOnly .

Navegar pelos registros do produto

Adicione código que permite que os usuários rolem pelos registros de produto usando < and > os botões.
1. No designer, clique duas vezes no < botão na superfície da janela.
O Visual Studio abre o arquivo code-behind e cria um novo manipulador de eventos backButton_Click
para o evento Click.
2. Modifique o manipulador de eventos Window_Loaded para que ProductViewSource ,
AdventureWorksLTDataSet e AdventureWorksLTDataSetProductTableAdapter fiquem fora do método e
acessíveis a todo o formulário. Declare apenas esses como globais ao formulário e atribua-os dentro do
manipulador Window_Loaded de eventos semelhante ao seguinte:

private AdventureWorksProductsEditor.AdventureWorksLTDataSet AdventureWorksLTDataSet;

private AdventureWorksProductsEditor.AdventureWorksLTDataSetTableAdapters.ProductTableAdapter
adventureWorksLTDataSetProductTableAdapter;
private System.Windows.Data.CollectionViewSource productViewSource;

private void Window_Loaded(object sender, RoutedEventArgs e)

{
AdventureWorksLTDataSet = ((AdventureWorksProductsEditor.AdventureWorksLTDataSet)
(this.FindResource("adventureWorksLTDataSet")));
// Load data into the table Product. You can modify this code as needed.
adventureWorksLTDataSetProductTableAdapter = new
AdventureWorksProductsEditor.AdventureWorksLTDataSetTableAdapters.ProductTableAdapter();
adventureWorksLTDataSetProductTableAdapter.Fill(AdventureWorksLTDataSet.Product);
productViewSource = ((System.Windows.Data.CollectionViewSource)
(this.FindResource("productViewSource")));
productViewSource.View.MoveCurrentToFirst();
}
Dim ProductViewSource As System.Windows.Data.CollectionViewSource
Dim AdventureWorksLTDataSet As AdventureWorksProductsEditor.AdventureWorksLTDataSet
Dim AdventureWorksLTDataSetProductTableAdapter As
AdventureWorksProductsEditor.AdventureWorksLTDataSetTableAdapters.ProductTableAdapter

Private Sub Window_Loaded(ByVal sender As System.Object, ByVal e As System.Windows.RoutedEventArgs)

Handles MyBase.Loaded
AdventureWorksLTDataSet = CType(Me.FindResource("AdventureWorksLTDataSet"),
AdventureWorksProductsEditor.AdventureWorksLTDataSet)
'Load data into the table Product. You can modify this code as needed.
AdventureWorksLTDataSetProductTableAdapter = New
AdventureWorksProductsEditor.AdventureWorksLTDataSetTableAdapters.ProductTableAdapter()
AdventureWorksLTDataSetProductTableAdapter.Fill(AdventureWorksLTDataSet.Product)
ProductViewSource = CType(Me.FindResource("ProductViewSource"),
System.Windows.Data.CollectionViewSource)
ProductViewSource.View.MoveCurrentToFirst()
End Sub

3. Adicione o seguinte código ao manipulador de eventos do backButton_Click :

if (productViewSource.View.CurrentPosition > 0)
{
productViewSource.View.MoveCurrentToPrevious();
}

If ProductViewSource.View.CurrentPosition > 0 Then

ProductViewSource.View.MoveCurrentToPrevious()
End If

4. Retorne ao designer e clique duas vezes no > botão.

5. Adicione o seguinte código ao manipulador de eventos do nextButton_Click :

if (productViewSource.View.CurrentPosition < ((CollectionView)productViewSource.View).Count - 1)

{
productViewSource.View.MoveCurrentToNext();
}

If ProductViewSource.View.CurrentPosition < CType(ProductViewSource.View, CollectionView).Count - 1

Then
ProductViewSource.View.MoveCurrentToNext()
End If

Salvar alterações em registros de produto

Adicione o código que permite aos usuários salvar alterações em registros de produtos ao usar o botão Salvar
alterações .
1. No designer, clique duas vezes no botão Salvar alterações .
O Visual Studio abre o arquivo code-behind e cria um novo manipulador de eventos saveButton_Click
para o evento Click.
2. Adicione o seguinte código ao manipulador de eventos do saveButton_Click :
adventureWorksLTDataSetProductTableAdapter.Update(AdventureWorksLTDataSet.Product);

AdventureWorksLTDataSetProductTableAdapter.Update(AdventureWorksLTDataSet.Product)

NOTE
Este exemplo usa o método Save do TableAdapter para salvar as alterações. Isso ocorre neste passo a passo,
porque apenas uma tabela de dados está sendo alterada. Se for necessário salvar alterações em várias tabelas de
dados, você pode também usar o método UpdateAll do TableAdapterManager que o Visual Studio gera com o
seu conjunto de dados. Para obter mais informações, consulte TableAdapters.

Testar o aplicativo
Crie e execute o aplicativo. Verifique se você pode exibir e atualizar registros de produtos.
1. Pressione F5 .
O aplicativo é compilado e executado. Verifique o seguinte:
As caixas de texto exibem dados do primeiro registro do produto que tem uma foto. Este produto
tem a ID 713 e o nome Long-Sleeve Logo Jersey, S .
Você pode clicar nos > < botões ou para navegar por outros registros de produto.
2. Em um dos registros de produto, altere o valor Tamanho e clique em Salvar Alterações .
3. Feche o aplicativo e reinicie-o pressionando F5 no Visual Studio.
4. Navegue até o registro do produto que você alterou e verifique se a mudança persistiu.
5. Feche o aplicativo.

Próximas etapas
Depois de concluir este passo a passos, você pode tentar as seguintes tarefas relacionadas:
Saiba como usar a janela Fontes de Dados no Visual Studio para associar controles do WPF a outros
tipos de fontes de dados. Para obter mais informações, consulte associar controles WPF a um serviço de
dados WCF.
Saiba como usar a janela Fontes de Dados no Visual Studio para exibir dados relacionados (isto é,
dados em uma relação pai-filho) em controles do WPF. Para obter mais informações, consulte
Walkthrough: exibir dados relacionados em um aplicativo do WPF.

Confira também
Associar controles WPF a dados no Visual Studio
Ferramentas de conjunto de dados no Visual Studio
Visão geral da ligação de dados
Associar controles do WPF a um WCF Data Service
20/11/2021 • 10 minutes to read

Neste passo a passo, você criará um aplicativo WPF que contém controles de associação de dados. Os controles
são vinculados aos registros do cliente encapsulados em um Serviço de Dados WCF. Você também adicionará
botões que os clientes podem usar para exibir e atualizar registros.
Este passo a passo ilustra as seguintes tarefas:
Criando um Modelo de Dados de Entidade que é gerado a partir de dados no banco de dados de
exemplo AdventureWorksLT.
Criar um Serviço de Dados WCF que expõe os dados no Modelo de Dados de Entidade a um aplicativo
WPF.
Criando um conjunto de controles de associação de dados ao arrastar itens da janela Fontes de Dados
para o WPF Designer.
Criando botões que navegam para a frente e para trás nos registros de clientes.
Criar um botão que salva as alterações nos dados nos controles para o Serviço de Dados WCF e a fonte
de dados subjacente.

Pré-requisitos
Você precisará dos seguintes componentes para concluir este passo a passo:
Visual Studio
Acesso a uma instância em execução do SQL Server ou SQL Server Express que tenha o banco de dados
de exemplo AdventureWorksLT anexado a ele. Para baixar o banco de dados, consulte Bancos de dados
de exemplo AdventureWorks
Conhecimento prévio dos conceitos a seguir também é útil, mas não é necessário para concluir o passo a passo:
WCF Data Services.
Modelos de dados no WCF Data Services.
Modelos de Dados de Entidade e o ADO.NET Entity Framework. Para obter mais informações, consulte
Entity Framework visão geral.
Associação de dados do WPF. Para obter mais informações, confira Visão geral de associação de dados.

Criar o projeto de serviço

1. Comece este passo a passo criando um projeto C# ou Visual Basic ASP.NET Aplicativo Web. Nomeia o
projeto AdventureWorksSer vice.
2. No Gerenciador de Soluções , clique com o botão direito do mouse em Default.aspx e selecione
Excluir . Esse arquivo não é necessário para o passo a passo.

Criar um Modelo de Dados de Entidade para o serviço

Para expor dados a um aplicativo usando um Serviço de Dados WCF, você deve definir um modelo de dados
para o serviço. O Serviço de Dados WCF dá suporte a dois tipos de modelos de dados: Modelos de Dados de
Entidade e modelos de dados personalizados que são definidos usando objetos CLR (Common Language
Runtime) que implementam a IQueryable<T> interface. Neste passo a passo, você criará um Modelo de Dados
de Entidade para o modelo de dados.
1. No menu Projeto , clique em Adicionar Novo Item .
2. Na lista Modelos Instalados, clique em Dados e selecione o item do projeto Modelo de Dados de
Entidade ADO.NET .
3. Altere o nome para AdventureWorksModel.edmx e clique em Adicionar .
O Assistente do Modelo de Dados de Entidade será aberto.
4. Na página Escolher Conteúdo do Modelo , clique em Gerar do banco de dados e em Avançar .
5. Na página Escolha a Conexão de Dados , selecione uma das seguintes opções:
Se uma conexão de dados com o banco de dados de exemplo AdventureWorksLT estiver
disponível na lista suspensa, selecione-a.
Clique em Nova Conexão e crie uma conexão com o banco de dados AdventureWorksLT.
6. Na página Escolha a Conexão de Dados , verifique se a opção Salvar configurações de conexão de
entidade em App.Config como está selecionada e clique em Próximo .
7. Na página Escolher Objetos do Banco de Dados , expanda Tabelas e selecione a tabela
SalesOrderHeader .
8. Clique em Concluir .

Criar o serviço
Crie um Serviço de Dados WCF para expor os dados no Modelo de Dados de Entidade a um aplicativo WPF:
1. No menu Projeto , selecione Adicionar novo item .
2. Na lista Modelos Instalados , clique em Web e selecione o item de projeto Ser viço de Dados WCF .
3. Na caixa Nome, digite AdventureWorksService.svc e clique em Adicionar .
Visual Studio adiciona o AdventureWorksService.svc ao projeto.

Configurar o serviço
Você deve configurar o serviço para operar no Modelo de Dados de Entidade que você criou:
1. No arquivo AdventureWorks.svc de código, substitua a declaração de classe AdventureWorksSer vice
pelo código a seguir.
public class AdventureWorksService : DataService<AdventureWorksLTEntities>
{
// This method is called only once to initialize service-wide policies.
public static void InitializeService(IDataServiceConfiguration config)
{
config.SetEntitySetAccessRule("SalesOrderHeaders", EntitySetRights.All);
}
}

Public Class AdventureWorksService

Inherits DataService(Of AdventureWorksLTEntities)

' This method is called only once to initialize service-wide policies.

Public Shared Sub InitializeService(ByVal config As IDataServiceConfiguration)
config.SetEntitySetAccessRule("SalesOrderHeaders", EntitySetRights.All)
config.UseVerboseErrors = True
End Sub
End Class

Esse código atualiza a classe AdventureWorksSer vice, de modo que ela deriva de um que opera na
classe de contexto de objeto em DataService<T> seu AdventureWorksLTEntities Modelo de Dados de
Entidade. Ele também atualiza o método InitializeService para permitir aos clientes do serviço acesso
completo de leitura/gravação à entidade SalesOrderHeader .
2. Crie o projeto e verifique se ele foi criado sem erros.

Criar o aplicativo cliente WPF

Para exibir os dados do Serviço de Dados WCF, crie um novo aplicativo WPF com uma fonte de dados baseada
no serviço. A seguir neste passo a passo, você adicionará controles de associação de dados ao aplicativo.
1. No Gerenciador de Soluções , clique com o botão direito do mouse no nó da solução, clique em
Adicionar e selecione Novo Projeto .
2. Na caixa de diálogo Novo Projeto , expanda Visual Basic ou Visual C# e selecione Windows .
3. Selecione o modelo de projeto Aplicativo WPF .
4. Na caixa Nome , digite AdventureWorksSalesEditor e clique em OK .
Visual Studio adiciona o AdventureWorksSalesEditor projeto à solução.
5. No menu Dados , clique em Mostrar Fontes de Dados .
A janela Fontes de Dados é aberta.
6. Na janela Fontes de Dados , clique em Adicionar Nova Fonte de Dados .
O assistente de Configuração da Fonte de Dados é aberto.
7. Na página Escolher um Tipo de Fonte de Dados do assistente, selecione Ser viço e clique em
Próximo .
8. Na caixa de diálogo Adicionar Referência de Ser viço , clique em Descobrir .
Visual Studio pesquisa a solução atual para serviços disponíveis e adiciona à lista de serviços
AdventureWorksService.svc disponíveis na caixa Serviços.

9. Na caixa Namespace , digite AdventureWorksSer vice .

10. Na caixa Ser viços , clique em AdventureWorksSer vice.svc e em OK .
O Visual Studio baixa as informações de serviço e retorna ao Assistente de Configuração de Fonte
de Dados .
11. Na página Adicionar Referência de Ser viço , clique em Concluir .
O Visual Studio adiciona nós que representam os dados retornados pelo serviço à janela Fontes de
Dados .

Definir a interface do usuário

Adicione vários botões à janela, modificando o XAML no WPF Designer. A seguir neste passo a passo, você
adicionará código que permite aos usuários exibir e atualizar registros de vendas usando esses botões.
1. No Gerenciador de Soluções , clique duas vezes em MainWindow.xaml .
A janela é aberta no WPF Designer.
2. Na exibição XAML do designer, adicione o seguinte código entre as marcas <Grid> :

<Grid.RowDefinitions>
<RowDefinition Height="75" />
<RowDefinition Height="525" />
</Grid.RowDefinitions>
<Button HorizontalAlignment="Left" Margin="22,20,0,24" Name="backButton" Width="75"><</Button>
<Button HorizontalAlignment="Left" Margin="116,20,0,24" Name="nextButton" Width="75">></Button>
<Button HorizontalAlignment="Right" Margin="0,21,46,24" Name="saveButton" Width="110">Save
changes</Button>

3. Compile o projeto.

Criar os controles com limite de dados

Crie controles que exibem registros do cliente arrastando SalesOrderHeaders o nó da janela Fontes de Dados
para o designer.
1. Na janela Fontes de Dados , clique no menu suspenso para o nó SalesOrderHeaders e selecione
Detalhes .
2. Expanda o nó SalesOrderHeaders .
3. Neste exemplo, alguns campos não serão exibidos, portanto, clique no menu suspenso ao lado dos
seguintes nós e selecione Nenhum :
CreditCardApprovalCode
ModifiedDate
OnlineOrderFlag
RevisionNumber
rowguid
Essa ação impede que o Visual Studio crie controles de associação de dados para esses nós na etapa
seguinte. Para este passo a passo, suponha que o usuário final não precise ver esses dados.
4. Na janela Fontes de Dados , arraste o nó SalesOrderHeaders para a linha de grade sob a linha que
contém os botões.
O Visual Studio gera XAML e código que criam um conjunto de controles associados a dados na tabela
Produto . Para obter mais informações sobre o XAML gerado e o código, consulte Bind WPF controls to
data in Visual Studio.
5. No designer, clique na caixa de texto ao lado do rótulo de ID do Cliente .
6. Na janela Propriedades , marque a caixa de seleção ao lado da propriedade IsReadOnly .
7. Configure a propriedade IsReadOnly para cada uma das seguintes caixas de texto:
Número da ordem de compra
ID da Ordem de Venda
Sales Order Number

Carregar os dados do serviço

Use o objeto de proxy de serviço para carregar dados de vendas do serviço. Em seguida, atribua os dados
retornados à fonte de dados CollectionViewSource para o na janela do WPF.
1. No designer, para criar o manipulador de eventos, clique duas vezes no texto Window_Loaded que diz:
MainWindow .
2. Substitua o manipulador de eventos pelo código a seguir. Substitua o endereço localhost neste código
pelo endereço de host local no computador de desenvolvimento.

private AdventureWorksService.AdventureWorksLTEntities dataServiceClient;

private System.Data.Services.Client.DataServiceQuery<AdventureWorksService.SalesOrderHeader>
salesQuery;
private CollectionViewSource ordersViewSource;

private void Window_Loaded(object sender, RoutedEventArgs e)

{
// TODO: Modify the port number in the following URI as required.
dataServiceClient = new AdventureWorksService.AdventureWorksLTEntities(
new Uri("http://localhost:45899/AdventureWorksService.svc"));
salesQuery = dataServiceClient.SalesOrderHeaders;

ordersViewSource = ((CollectionViewSource)(this.FindResource("salesOrderHeadersViewSource")));
ordersViewSource.Source = salesQuery.Execute();
ordersViewSource.View.MoveCurrentToFirst();
}

Private DataServiceClient As AdventureWorksService.AdventureWorksLTEntities

Private SalesQuery As System.Data.Services.Client.DataServiceQuery(Of
AdventureWorksService.SalesOrderHeader)
Private OrdersViewSource As CollectionViewSource

Private Sub Window_Loaded(ByVal Sender As Object, ByVal e As RoutedEventArgs) Handles MyBase.Loaded

' TODO: Modify the port number in the following URI as required.
DataServiceClient = New AdventureWorksService.AdventureWorksLTEntities( _
New Uri("http://localhost:32415/AdventureWorksService.svc"))
SalesQuery = DataServiceClient.SalesOrderHeaders

OrdersViewSource = CType(Me.FindResource("SalesOrderHeadersViewSource"), CollectionViewSource)

OrdersViewSource.Source = SalesQuery.Execute()
OrdersViewSource.View.MoveCurrentToFirst()
End Sub
Navegar pelos registros de vendas
Adicione o código que permite que os usuários rolem pelos registros de vendas usando < and > os botões .
1. No designer, clique duas vezes no < botão na superfície da janela.
O Visual Studio abre o arquivo code-behind e cria um novo manipulador de eventos backButton_Click
para o evento Click.
2. Adicione o seguinte código ao manipulador de eventos backButton_Click gerado:

if (ordersViewSource.View.CurrentPosition > 0)
ordersViewSource.View.MoveCurrentToPrevious();

If OrdersViewSource.View.CurrentPosition > 0 Then

OrdersViewSource.View.MoveCurrentToPrevious()
End If

3. Retorne ao designer e clique duas vezes no > botão.

O Visual Studio abre o arquivo code-behind e cria um novo manipulador de eventos nextButton_Click
para o evento Click.
4. Adicione o seguinte código ao manipulador de eventos nextButton_Click gerado:

if (ordersViewSource.View.CurrentPosition < ((CollectionView)ordersViewSource.View).Count - 1)

{
ordersViewSource.View.MoveCurrentToNext();
}

If OrdersViewSource.View.CurrentPosition < CType(OrdersViewSource.View, CollectionView).Count - 1

Then
OrdersViewSource.View.MoveCurrentToNext()
End If

Salvar alterações em registros de vendas

Adicione o código que permite aos usuários exibir e salvar as alterações em registros de vendas ao usar o botão
Salvar alterações :
1. No designer, clique duas vezes no botão Salvar Alterações.
O Visual Studio abre o arquivo code-behind e cria um novo manipulador de eventos saveButton_Click
para o evento Click.
2. Adicione o seguinte código ao manipulador de eventos do saveButton_Click .

AdventureWorksService.SalesOrderHeader currentOrder =
(AdventureWorksService.SalesOrderHeader)ordersViewSource.View.CurrentItem;
dataServiceClient.UpdateObject(currentOrder);
dataServiceClient.SaveChanges();
Dim CurrentOrder As AdventureWorksService.SalesOrderHeader = CType(OrdersViewSource.View.CurrentItem,
AdventureWorksService.SalesOrderHeader)

DataServiceClient.UpdateObject(CurrentOrder)
DataServiceClient.SaveChanges()

Testar o aplicativo
Compile e execute o aplicativo para verificar se é possível exibir e atualizar os registros do cliente:
1. No menu Build, clique em Criar Solução . Verifique se a solução é compilada sem erros.
2. Pressione Ctrl + F5 .
O Visual Studio inicia o projeto AdventureWorksSer vice sem depurá-lo.
3. No Gerenciador de Soluções , clique com o botão direito do mouse no projeto
AdventureWorksSalesEditor .
4. No menu de clique com o botão direito do mouse (menu de contexto), em Depurar , clique em Iniciar
nova instância .
O aplicativo é executado. Verifique o seguinte:
As caixas de texto exibem diferentes campos de dados desde o primeiro registro de venda, que
tem a ID de ordem de venda 71774 .
Você pode clicar nos > botões ou para navegar por outros registros de < vendas.
5. Em um dos registros de vendas, digite algum texto na caixa Comentário e clique em Salvar alterações .
6. Feche o aplicativo e depois inicie-o novamente no Visual Studio.
7. Navegue até o registro de vendas que você alterou e verifique se a alteração persiste depois de fechar e
reabrir o aplicativo.
8. Feche o aplicativo.

Próximas etapas
Depois de completar este passo a passo, você poderá realizar as seguintes tarefas relacionadas:
Saiba como usar a janela Fontes de Dados no Visual Studio para associar controles do WPF a outros
tipos de fontes de dados. Para obter mais informações, consulte Vincular controles WPF a um conjuntos
de dados.
Saiba como usar a janela Fontes de Dados no Visual Studio para exibir dados relacionados (isto é,
dados em uma relação pai-filho) em controles do WPF. Para obter mais informações, consulte Passo a
passo: exibindo dados relacionados em um aplicativo WPF.

Confira também
Associar controles WPF a dados no Visual Studio
Associar controles do WPF a um conjunto de dados
Visão geral do WCF (.NET Framework)
Entity Framework visão geral (.NET Framework)
Visão geral da Associação de Dados (.NET Framework)
Criar tabelas de pesquisa em aplicativos do WPF
20/11/2021 • 4 minutes to read

O termo tabela de pesquisa (às vezes chamado de associação de pesquisa ) descreve um controle que exibe
informações de uma tabela de dados com base no valor de um campo de chave estrangeira em outra tabela.
Você pode criar uma tabela de pesquisa arrastando o nó principal de uma tabela ou objeto pai na janela Fontes
de Dados para um controle que já está vinculado a uma coluna ou propriedade em uma tabela filho relacionada.
Por exemplo, considere uma tabela de em Orders um banco de dados de vendas. Cada registro na Orders
tabela inclui um que indica qual cliente fez o CustomerID pedido. O CustomerID é uma chave estrangeira que
aponta para um registro de cliente na Customers tabela. Ao exibir uma lista de pedidos da tabela, talvez você
queira Orders exibir o nome real do cliente em vez do CustomerID . Como o nome do cliente está na
Customers tabela, você precisa criar uma tabela de análise para exibir o nome do cliente. A tabela de lookup usa
CustomerID o valor no registro para navegar pela relação e retornar o nome do Orders cliente.

Criar uma tabela de pesquisa

1. Adicione um dos seguintes tipos de fontes de dados com dados relacionados ao seu projeto:
Conjuntos de dados ou Modelo de Dados de Entidade.
Serviço de Dados WCF, serviço WCF ou serviço Web. Para obter mais informações, consulte Como
Conexão dados em um serviço.
Objetos. Para obter mais informações, consulte Bind to objects in Visual Studio.

NOTE
Antes de criar uma tabela de pesquisa, duas tabelas ou objetos relacionados devem existir como uma fonte de
dados para o projeto.

2. Abra o Designer do WPF e certifique-se de que o designer contenha um contêiner que seja um destino
de soltar válido para itens na janela Fontes de Dados.
Para obter mais informações sobre destinos de soltar válidos, consulte Bind WPF controls to data in
Visual Studio.
3. No menu Dados, clique em Mostrar Fontes de Dados para abrir a janela Fontes de Dados.
4. Expanda os nós na janela Fontes de Dados até que você possa ver a tabela ou objeto pai e a tabela ou
objeto filho relacionado.

NOTE
A tabela ou objeto filho relacionado é o nó que aparece como um nó filho expansível sob a tabela ou objeto pai.

5. Clique no menu suspenso do nó filho e selecione Detalhes.

6. Expanda o nó filho.
7. No nó filho, clique no menu suspenso do item que relaciona os dados pai e filho. (No exemplo anterior,
esse é o nó CustomerID.) Selecione um dos seguintes tipos de controles que suportam associação de
lookup:
ComboBox
ListBox
ListView

NOTE
Se o controle ListBox ou ListView não aparecer na lista, você poderá adicionar esses controles à lista.
Para obter informações, consulte Definir o controle a ser criado ao arrastar da janela Fontes de Dados.

Qualquer controle personalizado derivado de Selector .

NOTE
Para obter informações sobre como adicionar controles personalizados à lista de controles que você pode
selecionar para itens na janela Fontes de Dados, consulte Adicionar controles personalizados à janela
Fontes de Dados.

8. Arraste o nó filho da janela Fontes de Dados para um contêiner no designer do WPF. (No exemplo
anterior, o nó filho é o nó Orders.)
Visual Studio gera XAML que cria novos controles de limite de dados para cada um dos itens que você
arrasta. O XAML também adiciona um novo para a tabela ou objeto filho CollectionViewSource aos
recursos do destino de soltar. Para algumas fontes de dados, Visual Studio também gera código para
carregar dados na tabela ou objeto. Para obter mais informações, consulte Bind WPF controls to data in
Visual Studio.
9. Arraste o nó pai da janela Fontes de Dados para o controle de associação de pesquisa criado
anteriormente. (No exemplo anterior, o nó pai é o nó Clientes).
Visual Studio define algumas propriedades no controle para configurar a associação de lookup. A tabela a
seguir lista as propriedades que Visual Studio modifica. Se necessário, você pode alterar essas
propriedades no XAML ou na janela Propriedades.

P RO P RIEDA DE EXP L IC A Ç Ã O DA C O N F IGURA Ç Ã O

ItemsSource Essa propriedade especifica a coleção ou associação

usada para obter os dados exibidos no controle . Visual
Studio define essa propriedade como
CollectionViewSource para os dados pai arrastados para
o controle.

DisplayMemberPath Essa propriedade especifica o caminho do item de dados

exibido no controle . Visual Studio define essa
propriedade como a primeira coluna ou propriedade nos
dados pai, após a chave primária, que tem um tipo de
dados de cadeia de caracteres.

Se você quiser exibir uma coluna ou propriedade

diferente nos dados pai, altere essa propriedade para o
caminho de uma propriedade diferente.
P RO P RIEDA DE EXP L IC A Ç Ã O DA C O N F IGURA Ç Ã O

SelectedValue Visual Studio vincula essa propriedade à coluna ou

propriedade dos dados filho arrastados para o designer.
Essa é a chave estrangeira para os dados pai.

SelectedValuePath Visual Studio define essa propriedade como o caminho

da coluna ou propriedade dos dados filho que são a
chave estrangeira para os dados pai.

Confira também
Associar controles WPF a dados no Visual Studio
Exibir dados relacionados em aplicativos WPF
Passo a passo: exibindo dados relacionados em um aplicativo WPF
Exibir dados relacionados em aplicativos WPF
20/11/2021 • 2 minutes to read

Em alguns aplicativos, talvez você queira trabalhar com dados provenientes de várias tabelas ou entidades
relacionadas entre si em uma relação pai-filho. Por exemplo, talvez você queira exibir uma grade que exibe os
clientes de uma Customers tabela. Quando o usuário seleciona um cliente específico, outra grade exibe os
pedidos desse cliente de uma tabela relacionada Orders .
Você pode criar controles vinculados a dados que exibem dados relacionados arrastando itens da janela fontes
de dados para o designer do WPF.

Para criar controles que exibem registros relacionados

1. No menu dados , clique em mostrar fontes de dados para abrir a janela fontes de dados .
2. Clique em Adicionar Nova Fonte de Dados e complete o Assistente de Configuração de Fonte
de Dados .
3. Abra o designer do WPF e certifique-se de que o designer contém um contêiner que é um destino de
soltura válido para os itens na janela fontes de dados .
Para obter mais informações sobre destinos de destino válidos, consulte associar controles WPF a dados
em Visual Studio.
4. Na janela fontes de dados , expanda o nó que representa a tabela ou o objeto pai na relação. A tabela
ou o objeto pai está no lado "um" de uma relação um-para-muitos.
5. Arraste o nó pai (ou quaisquer itens individuais no nó pai) da janela fontes de dados para um destino
de soltura válido no designer.
Visual Studio gera um XAML que cria novos controles vinculados a dados para cada item que você
arrasta. O XAML também adiciona um novo CollectionViewSource para a tabela ou objeto pai aos
recursos do destino de soltura. para algumas fontes de dados, Visual Studio também gera código para
carregar os dados na tabela ou no objeto pai. Para obter mais informações, consulte associar controles
WPF a dados em Visual Studio.
6. Na janela fontes de dados , localize a tabela ou o objeto filho relacionado. As tabelas e os objetos filho
relacionados aparecem como nós expansíveis na parte inferior da lista de dados do nó pai.
7. Arraste o nó filho (ou qualquer item individual no nó filho) da janela fontes de dados para um destino
de soltura válido no designer.
Visual Studio gera um XAML que cria novos controles vinculados a dados para cada um dos itens que
você arrastar. O XAML também adiciona um novo CollectionViewSource para a tabela ou objeto filho aos
recursos do destino de soltura. Esse novo CollectionViewSource é associado à propriedade da tabela ou
objeto pai que você acabou de arrastar para o designer. para algumas fontes de dados, Visual Studio
também gera código para carregar os dados na tabela ou no objeto filho.
A figura a seguir demonstra a tabela de pedidos relacionados da tabela Customers em um conjunto de
dados na janela Data Sources .
Confira também
Associar controles WPF a dados no Visual Studio
Criar tabelas de pesquisa em aplicativos do WPF
Associar controles a imagens de um banco de
dados
20/11/2021 • 2 minutes to read

Você pode usar a janela Data Sources para associar uma imagem em um banco de dados a um controle em
seu aplicativo. por exemplo, você pode associar uma imagem a um Image controle em um aplicativo WPF ou a
um PictureBox controle em um aplicativo Windows Forms.
As imagens em um banco de dados normalmente são armazenadas como matrizes de bytes. Os itens na janela
fontes de dados que são armazenados como matrizes de bytes têm seu tipo de controle definido como
nenhum por padrão, pois as matrizes de bytes podem conter qualquer coisa de uma matriz simples de bytes
para o arquivo executável de um aplicativo grande. Para criar um controle de associação de dados para um item
de matriz de bytes na janela fontes de dados que representa uma imagem, você deve selecionar o controle a
ser criado.
O procedimento a seguir pressupõe que a janela de fontes de dados já esteja preenchida com um item
associado à sua imagem.

Para associar uma imagem em um banco de dados a um controle

1. verifique se a superfície de design à qual você deseja adicionar o controle está aberta no Designer do
WPF ou na Designer de Formulários do Windows.
2. Na janela fontes de dados , expanda a tabela ou o objeto desejado para exibir suas colunas ou
propriedades.

TIP
se a janela fontes de dados não estiver aberta, abra-a selecionando exibir > outras > fontes de dados
Windows.

3. Selecione a coluna ou propriedade que contém os dados da imagem e selecione um dos seguintes
controles na lista suspensa controle:
Se o designer do WPF estiver aberto, selecione imagem .
se o designer de Windows Forms estiver aberto, selecione PictureBox .
Como alternativa, você pode selecionar um controle diferente que dá suporte à vinculação de
dados e que pode exibir imagens. Se o controle que você deseja usar não estiver na lista de
controles disponíveis, você poderá adicioná-lo à lista e, em seguida, selecioná-lo. Para obter mais
informações, consulte Adicionar controles personalizados à janela fontes de dados.

Confira também
Associar controles WPF a dados no Visual Studio
Associar controles do Windows Forms a dados no
Visual Studio
20/11/2021 • 3 minutes to read

Você pode exibir dados para usuários do seu aplicativo vinculando dados ao Windows Forms. Para criar esses
controles vinculados a dados, arraste itens da janela Fontes de Dados para o Designer Windows Forms no
Visual Studio.

TIP
Se a janela Fontes de Dados não estiver visível, você poderá abri-la escolhendo Exibir Windows Fontes de Dados ou
pressionando > > Shift + Alt + D . Você deve ter um projeto aberto no Visual Studio para ver a janela Fontes de Dados.

Antes de arrastar itens, você pode definir o tipo de controle ao qual deseja se vincular. Valores diferentes
aparecem dependendo se você escolhe a própria tabela ou uma coluna individual. Você também pode definir
valores personalizados. Para uma tabela, Details significa que cada coluna está vinculada a um controle
separado.

Controles BindingSource e BindingNavigator

O BindingSource componente atende a duas finalidades. Primeiro, ele fornece uma camada de abstração ao
vincular os controles aos dados. Os controles no formulário são vinculados ao BindingSource componente em
vez de diretamente a uma fonte de dados. Em segundo lugar, ele pode gerenciar uma coleção de objetos .
Adicionar um tipo ao BindingSource cria uma lista desse tipo.
Para obter mais informações sobre o BindingSource componente, consulte:
Componente BindingSource
Visão geral do componente BindingSource
Arquitetura do componente BindingSource
O controle BindingNavigator fornece uma interface do usuário para navegar pelos dados exibidos por um
Windows aplicativo.

Vincular a dados em um controle DataGridView

Para um controle DataGridView, a tabela inteira é vinculada a esse único controle. Quando você arrasta um
DataGridView para o formulário, uma faixa de ferramentas para navegar em registros ( BindingNavigator )
também é exibida. Um DataSet, TableAdapter BindingSource , e aparecem na bandeja do BindingNavigator
componente. Na ilustração a seguir, um TableAdapterManager também é adicionado porque a tabela Customers
tem uma relação com a tabela Orders. Todas essas variáveis são declaradas no código gerado automaticamente
como membros privados na classe de formulário. O código gerado automaticamente para preencher o
DataGridView está localizado no manipulador Form_Load de eventos. O código para salvar os dados para
atualizar o banco de dados está localizado no manipulador Save de eventos do BindingNavigator. Você pode
mover ou modificar esse código conforme necessário.

Você pode personalizar o comportamento do DataGridView e do BindingNavigator clicando na marcação

inteligente no canto superior direito de cada um:
Se os controles de que seu aplicativo precisa não estão disponíveis na janela Fontes de Dados, você pode
adicionar controles. Para obter mais informações, consulte Adicionar controles personalizados à janela Fontes
de Dados.
Você também pode arrastar itens da janela Fontes de Dados para controles que já estão em um formulário
para vincular o controle aos dados. Um controle que já está vinculado aos dados tem suas vinculações de dados
redefinidas para o item arrastado mais recentemente para ele. Para serem destinos de soltar válidos, os
controles devem ser capazes de exibir o tipo de dados subjacente do item arrastado para ele da janela Fontes
de Dados. Por exemplo, não é válido arrastar um item que tem um tipo de dados de para um , porque o não é
capaz de DateTime CheckBox exibir uma CheckBox data.

Vincular a dados em controles individuais

Quando você vincula uma fonte de dados a Detalhes , cada coluna no conjuntos de dados é vinculada a um
controle separado.

IMPORTANT
Observe que, na ilustração anterior, você arrasta da propriedade Orders da tabela Clientes, não da tabela Orders. Ao se
vincular à Customer.Orders propriedade , os comandos de navegação feitos no DataGridView são refletidos
imediatamente nos controles de detalhes. Se você arrastasse da tabela Orders, os controles ainda seriam vinculados ao
conjuntos de dados, mas não seriam sincronizados com o DataGridView.

A ilustração a seguir mostra os controles padrão de limite de dados que são adicionados ao formulário depois
que a propriedade Orders na tabela Clientes é vinculada a Detalhes na janela Fontes de Dados.

Observe também que cada controle tem uma marca inteligente. Essa marca permite personalizações que se
aplicam somente a esse controle.

Confira também
Associando controles a dados no Visual Studio
Associação de dados Windows Forms (.NET Framework)
Filtrar e classificar dados em um aplicativo do
Windows Forms
20/11/2021 • 2 minutes to read

Você filtra os dados definindo a Filter propriedade como uma expressão de cadeia de caracteres que retorna os
registros desejados.
Você classifica os dados definindo a Sort propriedade como o nome da coluna na qual você deseja classificar;
acrescentar DESC para classificar em ordem decrescente ou acrescentar ASC para classificar em ordem
crescente.

NOTE
Se o seu aplicativo não usar BindingSource componentes, você poderá filtrar e classificar dados usando DataView objetos.
Para obter mais informações, consulte DataViews.

Para filtrar dados usando um componente BindingSource

Defina a Filter propriedade para a expressão que você deseja retornar. Por exemplo, o código a seguir
retorna clientes com um CompanyName que começa com "B":

customersBindingSource.Filter = "CompanyName like 'B'";

CustomersBindingSource.Filter = "CompanyName like 'B'"

Para classificar dados usando um componente BindingSource

Defina a Sort propriedade para a coluna que você deseja classificar. Por exemplo, o código a seguir
classifica os clientes na CompanyName coluna em ordem decrescente:

customersBindingSource.Sort = "CompanyName Desc";

CustomersBindingSource.Sort = "CompanyName Desc"

Confira também
Associar controles a dados no Visual Studio
Confirmar edições no processo em controles
associados a dados antes de salvar os dados
20/11/2021 • 2 minutes to read

Ao editar valores em controles vinculados a dados, os usuários devem navegar para fora do registro atual para
confirmar o valor atualizado para a fonte de dados subjacente à qual o controle está associado. Quando você
arrasta itens da janela fontes de dados para um formulário, o primeiro item que você remove gera código para
o evento de clique do botão salvar do BindingNavigator . Esse código chama o EndEdit método do
BindingSource . Portanto, a chamada para o EndEdit método é gerada somente para o primeiro BindingSource
que é adicionado ao formulário.
A chamada EndEdit confirma as alterações que estão em processo em qualquer controle de associação de dados
sendo editado no momento. Portanto, se um controle associado a dados ainda estiver em foco e você clicar no
botão Salvar , todas as edições pendentes nesse controle serão confirmadas antes da gravação real (o método
TableAdapterManager.UpdateAll ).

Você pode configurar seu aplicativo para confirmar as alterações automaticamente, mesmo se um usuário
tentar salvar dados sem confirmar as alterações, como parte do processo de salvamento.

NOTE
O designer adiciona o BindingSource.EndEdit código somente para o primeiro item descartado em um formulário.
Portanto, você precisa adicionar uma linha de código para chamar o EndEdit método para cada BindingSource no
formulário. Você pode adicionar manualmente uma linha de código para chamar o EndEdit método para cada
BindingSource . Como alternativa, você pode adicionar o EndEditOnAllBindingSources método ao formulário e chamá-
lo antes de executar um salvamento.

O código a seguir usa uma consulta LINQ (consulta integrada à linguagem) para iterar todos os BindingSource
componentes e chamar o EndEdit método para cada BindingSource um em um formulário.

Para chamar EndEdit para todos os componentes BindingSource em

um formulário
1. Adicione o código a seguir ao formulário que contém os BindingSource componentes.

private void EndEditOnAllBindingSources()

{
var BindingSourcesQuery =
from Component bindingSources in this.components.Components
where bindingSources is BindingSource
select bindingSources;

foreach (BindingSource bindingSource in BindingSourcesQuery)

{
bindingSource.EndEdit();
}
}
Private Sub EndEditOnAllBindingSources()
Dim BindingSourcesQuery = From bindingsources In Me.components.Components
Where (TypeOf bindingsources Is Windows.Forms.BindingSource)
Select bindingsources

For Each bindingSource As Windows.Forms.BindingSource In BindingSourcesQuery

bindingSource.EndEdit()
Next
End Sub

2. Adicione a seguinte linha de código imediatamente antes de qualquer chamada para salvar os dados do
formulário (o TableAdapterManager.UpdateAll() método):

EndEditOnAllBindingSources();

Me.EndEditOnAllBindingSources()

Confira também
Associar controles do Windows Forms a dados no Visual Studio
Atualização hierárquica
Criar tabelas de pesquisa em aplicativos do
Windows Forms
20/11/2021 • 3 minutes to read

A tabela de pesquisa de termos descreve os controles associados a duas tabelas de dados relacionadas. Esses
controles de pesquisa exibem dados da primeira tabela com base em um valor selecionado na segunda tabela.
Você pode criar tabelas de pesquisa arrastando o nó principal de uma tabela pai (da janela fontes de dados)
para um controle no formulário que já esteja associado à coluna na tabela filho relacionada.
Por exemplo, considere uma tabela de Orders em um banco de dados de vendas. Cada registro na Orders
tabela inclui um CustomerID , indicando qual cliente fez o pedido. O CustomerID é uma chave estrangeira que
aponta para um registro de cliente na Customers tabela. Nesse cenário, você expande a Orders tabela na janela
fontes de dados e define o nó principal como detalhes . Em seguida, defina a CustomerID coluna para usar
um ComboBox (ou qualquer outro controle que dê suporte à associação de pesquisa) e arraste o Orders nó
para o formulário. Por fim, arraste o Customers nó para o controle que está associado à coluna relacionada —
nesse caso, o ComboBox associado à CustomerID coluna.

Para associar um controle de pesquisa

1. com o projeto aberto, abra a janela fontes de dados escolhendo exibir > outras > fontes de dados
Windows.

NOTE
As tabelas de pesquisa exigem que duas tabelas ou objetos relacionados estejam disponíveis na janela fontes de
dados . Para obter mais informações, consulte relações em conjuntos dedados.

2. Expanda os nós na janela Data Sources até que você possa ver a tabela pai e todas as suas colunas e a
tabela filho relacionada e todas as suas colunas.

NOTE
O nó da tabela filho é o nó que aparece como um nó filho expansível na tabela pai.

3. Altere o tipo de descarte da tabela filho para detalhes selecionando detalhes na lista de controle no nó
da tabela filho. Para obter mais informações, consulte definir o controle a ser criado ao arrastar da janela
fontes de dados.
4. Localize o nó que relaciona as duas tabelas (o CustomerID nó no exemplo anterior). Altere seu tipo drop
para a ComboBox selecionando ComboBox na lista de controles.
5. Arraste o nó da tabela filho principal da janela fontes de dados para o formulário.
Os controles de ligação de vínculo (com rótulos descritivos) e uma faixa de ferramenta (
BindingNavigator ) aparecem no formulário. Um DataSet, o TableAdapter, BindingSource e
BindingNavigator aparece na bandeja do componente.
6. Agora, arraste o nó da tabela pai principal da janela fontes de dados diretamente para o controle de
pesquisa (o ComboBox ).
As associações de pesquisa agora são estabelecidas. Consulte a tabela a seguir para obter as
propriedades específicas que foram definidas no controle.

P RO P RIEDA DE EXP L IC A Ç Ã O DA C O N F IGURA Ç Ã O

DataSource O Visual Studio define esta propriedade para o

BindingSource criado para a tabela que você arrasta para
o controle (em oposição ao BindingSource criado quando
o controle foi criado).

Se você precisar fazer um ajuste, defina-o para a

BindingSource da tabela com a coluna que você deseja
exibir.

DisplayMember O Visual Studio define essa propriedade para a primeira

coluna após a chave primária que tem um tipo de dado
de cadeia da tabela que você arrasta para o controle.

Se você precisar fazer um ajuste, defina-o como o nome

da coluna que você deseja exibir.

ValueMember O Visual Studio define essa propriedade para a primeira

coluna participante da chave primária, ou a primeira
coluna na tabela, se nenhuma chave for definida.

Se você precisar fazer um ajuste, defina-o como a chave

primária na tabela com a coluna que você deseja exibir.

SelectedValue Visual Studio define essa propriedade como a coluna

original descartada da janela Data sources .

Se você precisar fazer um ajuste, defina isso para a

coluna de chave estrangeira na tabela relacionada.

Confira também
Associar controles do Windows Forms a dados no Visual Studio
Criar um Windows Form para pesquisar dados
20/11/2021 • 6 minutes to read

Um cenário de aplicativo comum exibirá dados selecionados em um formulário. Por exemplo, você pode querer
exibir os pedidos de um cliente específico ou os detalhes de um pedido específico. Nesse cenário, um usuário
insere informações em um formulário e uma consulta é executada com a entrada do usuário como parâmetro,
ou seja, os dados são selecionados com base em uma consulta parametrizada. A consulta retorna apenas os
dados que satisfazem os critérios inseridos pelo usuário. Este passo a passo mostra como criar uma consulta
que retorna clientes de uma cidade específica, como mudar a interface do usuário para que os usuários possam
inserir o nome de uma cidade e pressionar um botão para executar a consulta.
O uso de consultas parametrizadas ajuda a tornar seu aplicativo eficiente, permitindo que o banco de dados
funcione melhor, filtrando registros rapidamente. Por outro lado, se você solicitar uma tabela de banco de dados
inteira, transferi-la pela rede e usar a lógica do aplicativo para encontrar os registros que deseja, o aplicativo
poderá ficar lento e ineficiente.
Você pode adicionar consultas parametrizadas a qualquer TableAdapter (e controles para aceitar valores de
parâmetro e executar a consulta), usando a caixa de diálogo Construtor de Critérios de Pesquisa. Abra a caixa de
diálogo selecionando o comando Adicionar Consulta no menu Dados (ou em qualquer marcação inteligente
de TableAdapter).
As tarefas ilustradas neste passo a passo incluem:
Criando e configurando a fonte de dados em seu aplicativo com o assistente de Configuração da
Fonte de Dados.
Definir o tipo de soltar dos itens na janela Fontes de Dados.
Criar controles que exibem dados arrastando itens da janela Fontes de Dados para um formulário.
Adicionar controles para exibir os dados no formulário.
Concluindo a caixa de diálogo Construtor de Critérios de Pesquisa.
Inserindo parâmetros no formulário e executando a consulta parametrizada.

NOTE
Os procedimentos neste artigo se aplicam somente a projetos .NET Framework Windows Forms, não a projetos do .NET
Core Windows Forms.

Pré-requisitos
Você deve ter a carga de trabalho armazenamento e processamento de dados instalada. Consulte
Modificar Visual Studio.
Este passo a passo usa SQL Server Express LocalDB e o banco de dados de exemplo Northwind.
1. Se você não tiver um SQL Server Express LocalDB, instale-o na página de download SQL Server Express
oupor meio do Instalador do Visual Studio . No Instalador do Visual Studio , você pode instalar o
SQL Server Express LocalDB como parte da carga de trabalho armazenamento e processamento de
dados ou como um componente individual.
2. Instale o banco de dados de exemplo Northwind seguindo estas etapas:
a. No Visual Studio, abra a SQL Ser ver Pesquisador de Objetos janela. (SQL Server Pesquisador
de Objetos é instalado como parte da carga de trabalho armazenamento e processamento de
dados no Instalador do Visual Studio .) Expanda o SQL Ser ver nó. Clique com o botão direito
do mouse na LocalDB e selecione Nova Consulta .
Uma janela do editor de consultas é aberta.
b. Copie o script Northwind Transact-SQL para a área de transferência. Esse script T-SQL cria o banco
de dados Northwind do zero e o popula com dados.
c. Colar o script T-SQL no editor de consultas e, em seguida, escolha o botão Executar.
Após um curto período, a consulta termina a execução e o banco de dados Northwind é criado.

Criar o aplicativo Windows Forms

Crie um novo projeto Windows Forms (.NET Framework) para C# ou Visual Basic. Nomeie o projeto
WindowsSearchForm .

Criar a fonte de dados

Esta etapa cria uma fonte de dados por meio de um banco de dados usando o assistente de Configuração de
Fonte de Dados :
1. Para abrir a janela Fontes de Dados, no menu Dados, clique em Mostrar Fontes de Dados .
2. Na janela Fontes de Dados , selecione Adicionar Nova Fonte de Dados para iniciar o assistente de
Configuração de Fonte de Dados .
3. Selecione Banco de Dados na página Escolher um Tipo de Fonte de Dados e, em seguida, clique
em Avançar .
4. Na página Escolher sua Conexão de Dados, faça o seguinte:
Se uma conexão de dados com o banco de dados de exemplo Northwind estiver disponível na
lista suspensa, selecione-o.
Selecione Nova Conexão para inicializar a caixa de diálogo Adicionar/Modificar Conexão .
5. Se o banco de dados exigir uma senha, selecione a opção para incluir dados confidenciais e, em seguida,
clique em Avançar .
6. Na página Salvar cadeia de conexão no arquivo configuração de aplicativo, clique em Próximo.
7. Na página Escolher seus Objetos de Banco de Dados, expanda o nó Tabelas.
8. Selecione a tabela Clientes e clique em Concluir .
O Nor thwindDataSet é adicionado ao seu projeto e a tabela Clientes aparece na janela Fontes de
Dados .
Crie um novo projeto Windows Forms (.NET Framework) para C# ou Visual Basic. Nomeie o projeto
WindowsSearchForm .

Criar a fonte de dados

Esta etapa cria uma fonte de dados por meio de um banco de dados usando o assistente de Configuração de
Fonte de Dados :
1. Para abrir a janela Fontes de Dados, use a pesquisa rápida (Ctrl + Q ) e pesquise Fontes de Dados .
2. Na janela Fontes de Dados , selecione Adicionar Nova Fonte de Dados para iniciar o assistente de
Configuração de Fonte de Dados .
3. Selecione Banco de Dados na página Escolher um Tipo de Fonte de Dados e, em seguida, clique
em Avançar .
4. Na tela Escolher um Modelo de Banco de Dados, escolha Conjuntos de dados e clique em Próximo.
5. Na página Escolher sua Conexão de Dados, faça o seguinte:
Se uma conexão de dados com o banco de dados de exemplo Northwind estiver disponível na
lista suspensa, selecione-o.
Selecione Nova Conexão para inicializar a caixa de diálogo Adicionar/Modificar Conexão .
6. Na página Salvar cadeia de conexão no arquivo configuração de aplicativo, clique em Próximo.
7. Na página Escolher seus Objetos de Banco de Dados, expanda o nó Tabelas.
8. Selecione a tabela Clientes e clique em Concluir .
O Nor thwindDataSet é adicionado ao seu projeto e a tabela Clientes aparece na janela Fontes de
Dados .

Criar o formulário
Você pode criar controles de associação de dados arrastando itens da janela Fontes de Dados para um
formulário:
1. Certifique-se de que o designer Windows Forms tenha o foco ativo e se a janela Fontes de Dados está
aberta e fixada.
2. Expanda o nó Clientes na janela Fontes de Dados .
3. Arraste o nó Clientes da janela Fontes de Dados para o formulário.
Um DataGridView e uma faixa de ferramentas (BindingNavigator) para navegação em registros são
exibidos no formulário. Um NorthwindDataSet, CustomersTableAdapter, BindingSource e
BindingNavigator são exibidos na bandeja de componentes.

Adicionar parametrização (funcionalidade de pesquisa) à consulta

Você pode adicionar uma cláusula WHERE à consulta original usando a caixa de diálogo Construtor de
Critérios de Pesquisa:
1. Logo abaixo da superfície de design do formulário, selecione o botão customersTableAdapter e, na
janela Propriedades, escolha Adicionar Consulta....
2. Digite FillByCity na área Novo nome da consulta na caixa de diálogo Construtor de Critérios de
Pesquisa.
3. Adicione WHERE City = @City à consulta na área Texto da Consulta .
A consulta deve ser semelhante ao seguinte:
SELECT CustomerID, CompanyName, ContactName, ContactTitle,
Address, City, Region, PostalCode, Country, Phone, Fax
FROM Customers
WHERE City = @City

NOTE
As fontes de OLE DB de dados usam o ponto de interrogação ('?') para denotar parâmetros, de modo que a
cláusula WHERE teria esta aparência: WHERE City = ? .

4. Clique em OK para fechar a caixa de diálogo Construtor de Critérios de Pesquisa .

Um FillByCityToolStrip é adicionado ao formulário.

Testar o aplicativo
A execução do aplicativo abre o formulário e o torna pronto para assumir o parâmetro como entrada:
1. Pressione F5 para executar o aplicativo.
2. Digite Londres na caixa de texto Cidade e clique em FillByCity .
A grade de dados é preenchida com clientes que atendem aos critérios. Neste exemplo, a grade de dados
exibe os clientes que têm o valor Londres na coluna Cidade .

Próximas etapas
Dependendo dos requisitos de aplicativo, existem várias etapas que você talvez queira realizar após criar um
formulário parametrizado. Entre algumas das melhorias que você poderia fazer nessa explicação passo a passo
estão:
Adicionar controles que exibem dados relacionados. Para obter mais informações, consulte Relações em
conjuntos de dados.
Editando o conjunto de dados para adicionar ou remover objetos de banco de dados. Para obter mais
informações, consulte Create and configure datasets (Criar e configurar conjuntos de dados).

Confira também
Associar controles do Windows Forms a dados no Visual Studio
Criar um controle de usuário do Windows Forms
que dá suporte à vinculação de dados simples
20/11/2021 • 7 minutes to read

Ao exibir dados em formulários nos aplicativos do Windows, você poderá escolher os controles existentes da
Caixa de Ferramentas ou criar controles personalizados se o aplicativo exigir alguma funcionalidade que não
esteja disponível nos controles padrão. Este passo a passo mostra como criar um controle que implementa o
DefaultBindingPropertyAttribute. Os controles que implementam o DefaultBindingPropertyAttribute contêm
uma propriedade que pode ser associada a dados. Tais controles são semelhantes a um TextBox ou CheckBox.
Para obter mais informações sobre a criação de controle, consulte Desenvolvendo controles Windows Forms em
tempo de design.
Ao autorizar controles para uso em cenários de associação de dados, você deve implementar um dos seguintes
atributos de associação de dados:

USO DE AT RIB UTO DE A SSO C IA Ç Ã O DE DA DO S

Implemente o DefaultBindingPropertyAttribute em controles simples, como um TextBox, que exibe uma única coluna (ou
propriedade) de dados. (Esse processo é descrito nesta página de passo a passo.)

Implemente o ComplexBindingPropertiesAttribute nos controles, como um DataGridView que exibe listas (ou tabelas) de
dados. Para obter mais informações, consulte Criar um controle de usuário Windows Forms que dá suporte à associação de
dados complexa.

Implemente o LookupBindingPropertiesAttribute nos controles, como um ComboBoxque exibe listas (ou tabelas) de dados,
mas também precisa apresentar uma única coluna ou propriedade. Para obter mais informações, consulte Criar um controle de
usuário Windows Forms que dá suporte à associação de dados de pesquisa.

Este passo a passo cria um controle simples que exibe dados de uma única coluna em uma tabela. Este exemplo
usa a coluna Phone da tabela Customers do banco de dados de exemplo Northwind. O controle de usuário
simples exibe os números de telefone dos clientes em um formato de número de telefone padrão, usando um e
definindo a máscara MaskedTextBox como um número de telefone.
Durante este passo a passo, você aprenderá a:
Crie um novo aplicativo Windows Forms .
Adicionar um novo Controle de Usuário ao projeto.
Projetar visualmente o controle do usuário.
Implementar o atributo DefaultBindingProperty .
Crie um conjuntos de dados com o assistente de Configuração da Fonte de Dados.
Definir a coluna Telefone na janela Fontes de Dados para usar o novo controle.
Criar um formulário para exibir dados no novo controle.

Pré-requisitos
Este passo a passo usa SQL Server Express LocalDB e o banco de dados de exemplo Northwind.
1. Se você não tiver um SQL Server Express LocalDB, instale-o na página de download SQL Server Express
oupor meio do Instalador do Visual Studio . No Instalador do Visual Studio , você pode instalar o
SQL Server Express LocalDB como parte da carga de trabalho armazenamento e processamento de
dados ou como um componente individual.
2. Instale o banco de dados de exemplo Northwind seguindo estas etapas:
a. No Visual Studio, abra a SQL Ser ver Pesquisador de Objetos janela. (SQL Server Pesquisador
de Objetos é instalado como parte da carga de trabalho armazenamento e processamento de
dados no Instalador do Visual Studio .) Expanda o SQL Ser ver nó. Clique com o botão direito
do mouse na LocalDB e selecione Nova Consulta .
Uma janela do editor de consultas é aberta.
b. Copie o script Northwind Transact-SQL para a área de transferência. Esse script T-SQL cria o banco
de dados Northwind do zero e o popula com dados.
c. Colar o script T-SQL no editor de consultas e, em seguida, escolha o botão Executar.
Após um curto período, a consulta termina a execução e o banco de dados Northwind é criado.

Criar um aplicativo do Windows Forms

A primeira etapa é criar um aplicativo Windows Forms :
1. No Visual Studio, no menu Arquivo , selecione Novo > Projeto .
2. Expanda Visual C# ou Visual Basic no painel esquerdo e selecione Windows Desktop.
3. No painel central, selecione o tipo de projeto Windows Aplicativo de Formulários.
4. Nomeia o projeto SimpleControlWalkthrough e escolha OK.
O projeto SimpleControlWalkthrough é criado e adicionado ao Gerenciador de Soluções .

Adicionar um controle de usuário ao projeto

Este passo a passo cria um controle simples a vinciável de dados de um Controle de Usuário . Adicione um
item de Controle de Usuário ao projeto SimpleControlWalkthrough:
1. No menu Projeto , escolha Adicionar Controle do Usuário .
2. Digite PhoneNumberBox na área Nome e clique em Adicionar .
O controle PhoneNumberBox é adicionado ao Gerenciador de Soluções e abre no designer.

Criar o controle PhoneNumberBox

Este passo a passo se expande sobre o existente MaskedTextBox para criar o controle PhoneNumberBox:
1. Arraste um MaskedTextBox da Caixa de Ferramentas para a superfície de design do controle de
usuário.
2. Selecione a smart tag no MaskedTextBox que você acabou de arrastar e selecione Definir Máscara .
3. Selecione Número do telefone na caixa de diálogo Máscara de Entrada e clique em OK para
configurar a máscara.

Adicionar o atributo de associação de dados necessário

Para controles simples que dão suporte à associação de dados, implemente o DefaultBindingPropertyAttribute:
1. Alternar o controle PhoneNumberBox para a exibição de código. (No menu Exibir , escolha Código .)
2. Substitua o código no PhoneNumberBox pelo seguinte:

using System.Windows.Forms;

namespace CS
{
[System.ComponentModel.DefaultBindingProperty("PhoneNumber")]
public partial class PhoneNumberBox : UserControl
{
public string PhoneNumber
{
get{ return maskedTextBox1.Text; }
set{ maskedTextBox1.Text = value; }
}

public PhoneNumberBox()
{
InitializeComponent();
}
}
}

<System.ComponentModel.DefaultBindingProperty("PhoneNumber")>
Public Class PhoneNumberBox

Public Property PhoneNumber() As String

Get
Return MaskedTextBox1.Text
End Get
Set(ByVal value As String)
MaskedTextBox1.Text = value
End Set
End Property
End Class

3. No menu Build, escolha Criar Solução .

Criar uma fonte de dados do banco de dados

Esta etapa usa o assistente de Configuração da Fonte de Dados para criar uma fonte de dados com base na
tabela no banco de dados de exemplo Customers Northwind. É preciso ter acesso ao banco de dados de
exemplo Northwind para criar a conexão. Para obter informações sobre como configurar o banco de dados de
exemplo Northwind, consulte Como instalar bancos de dados de exemplo.
1. Para abrir a janela Fontes de Dados, no menu Dados, clique em Mostrar Fontes de Dados .
2. Na janela Fontes de Dados , selecione Adicionar Nova Fonte de Dados para iniciar o assistente de
Configuração de Fonte de Dados .
3. Na página Escolher um Tipo de Fonte de Dados , selecione Banco de Dados e clique em Avançar .
4. Na página Escolha a Conexão de Dados , faça o seguinte:
Se uma conexão de dados com o banco de dados de exemplo Northwind estiver disponível na
lista suspensa, selecione-o.
Selecione Nova Conexão para inicializar a caixa de diálogo Adicionar/Modificar Conexão .
5. Se o banco de dados exigir uma senha, selecione a opção para incluir dados confidenciais e, em seguida,
clique em Avançar .
6. Na página Salvar cadeia de conexão no arquivo configuração de aplicativo, clique em Próximo.
7. Na página Escolher seus Objetos de Banco de Dados, expanda o nó Tabelas.
8. Selecione a tabela Customers e clique em Concluir .
O Nor thwindDataSet é adicionado ao seu projeto e a Customers tabela aparece na janela Fontes de
Dados.

Definir a coluna de telefone para usar o controle PhoneNumberBox

Na janela Fontes de Dados, você pode definir o controle a ser criado antes de arrastar itens para o formulário:
1. Abra Form1 no designer.
2. Expanda o nó Clientes na janela Fontes de Dados .
3. Clique na seta suspensa no nó Clientes e escolha Detalhes na lista de controle.
4. Clique na seta suspensa na coluna Telefone e escolha Personalizar .
5. Selecione PhoneNumberBox na lista de Controles Associados na caixa de diálogo Opções de
Personalização da Interface do Usuário de Dados .
6. Clique na seta suspensa na coluna Telefone e escolha PhoneNumberBox .

Adicionar controles ao formulário

É possível criar controles de associação de dados ao arrastar itens da janela Fontes de Dados para o
formulário.
Para criar controles vinculados a dados no formulário, arraste o nó principal Clientes da janela Fontes de Dados
para o formulário e verifique se o controle PhoneNumberBox é usado para exibir os dados na coluna
Telefone.
Os controles de associação de dados com rótulos descritivos são exibidos no formulário, juntamente com uma
faixa de ferramentas (BindingNavigator) para registros de navegação. Um NorthwindDataSet,
CustomersTableAdapter, BindingSource e BindingNavigator são exibidos na bandeja de componentes.

Executar o aplicativo
Pressione F5 para executar o aplicativo.

Próximas etapas
Dependendo dos requisitos do aplicativo, existem várias etapas que você pode realizar após criar um controle
com suporte a associação de dados. Algumas etapas seguintes típicas incluem:
Colocando os controles personalizados em uma biblioteca de controles para que você possa reutilizá-los
em outros aplicativos.
Criando controles que suportam cenários de associação de dados mais complexos. Para obter mais
informações, consulte Criar um controle de usuário do Windows Forms que dá suporte à associação de
dados complexa e Criar um controle de usuário do Windows Forms que dá suporte à associação de
dados de pesquisa.
Confira também
Associar controles do Windows Forms a dados no Visual Studio
Definir o controle a ser criado quando arrastado da janela Fontes de Dados
Criar um controle de usuário do Windows Forms
que dá suporte à vinculação de dados complexos
20/11/2021 • 6 minutes to read

Ao exibir dados em formulários em Windows aplicativos, você pode escolher os controles existentes na Caixa de
Ferramentas . Ou você pode autor de controles personalizados se seu aplicativo exigir funcionalidades que não
estão disponíveis nos controles padrão. Este passo a passo mostra como criar um controle que implementa o
ComplexBindingPropertiesAttribute. Os controles que implementam o ComplexBindingPropertiesAttribute
contêm uma propriedade de DataSource e DataMember que pode ser associada a dados. Tais controles são
semelhantes a um DataGridView ou ListBox.
Para obter mais informações sobre a criação de controle, consulte Desenvolvendo controles Windows Forms em
tempo de design.
Ao criar controles para uso em cenários de associação de dados, é necessário implementar um dos seguintes
atributos de associação de dados:

USO DE AT RIB UTO DE A SSO C IA Ç Ã O DE DA DO S

Implemente o DefaultBindingPropertyAttribute em controles simples, como um TextBox, que exibe uma única coluna (ou
propriedade) de dados. Para obter mais informações, consulte Criar um controle de usuário Windows Forms que dá suporte à
associação de dados simples.

Implemente o ComplexBindingPropertiesAttribute nos controles, como um DataGridView que exibe listas (ou tabelas) de
dados. (Esse processo é descrito nesta página de passo a passo.)

Este passo a passo cria um controle complexo que exibe linhas de dados de uma tabela. Este exemplo usa a
tabela Customers do banco de dados de exemplo Northwind. O controle de usuário complexo exibirá a tabela
de clientes em uma DataGridView no controle personalizado.
Durante este passo a passo, você aprenderá a:
Adicionar um novo Controle de Usuário ao projeto.
Projetar visualmente o controle do usuário.
Implementar o atributo ComplexBindingProperty .
Crie um conjuntos de dados com o Assistente de Configuração da Fonte de Dados.
De definir a tabela Clientes na janela Fontes de Dados para usar o novo controle complexo.
Adicionar o novo controle, arrastando-o da janela Fontes de Dados para Form1 .

Pré-requisitos
Este passo a passo usa SQL Server Express LocalDB e o banco de dados de exemplo Northwind.
1. Se você não tiver um SQL Server Express LocalDB, instale-o na página de download SQL Server Express
oupor meio do Instalador do Visual Studio . No Instalador do Visual Studio , você pode instalar o
SQL Server Express LocalDB como parte da carga de trabalho armazenamento e processamento de
dados ou como um componente individual.
2. Instale o banco de dados de exemplo Northwind seguindo estas etapas:
a. No Visual Studio, abra a SQL Ser ver Pesquisador de Objetos janela. (SQL Server Pesquisador
de Objetos é instalado como parte da carga de trabalho armazenamento e processamento de
dados no Instalador do Visual Studio.) Expanda o SQL Ser ver nó. Clique com o botão direito do
mouse na LocalDB e selecione Nova Consulta .
Uma janela do editor de consultas é aberta.
b. Copie o script Northwind Transact-SQL para a área de transferência. Esse script T-SQL cria o banco
de dados Northwind do zero e o popula com dados.
c. Colar o script T-SQL no editor de consultas e, em seguida, escolha o botão Executar.
Após um curto período, a consulta termina a execução e o banco de dados Northwind é criado.

Criar um projeto de aplicativo Windows Forms

A primeira etapa é criar um projeto de aplicativo Windows Forms para C# ou Visual Basic. Nomeie o projeto
como ComplexControlWalkthrough .

Adicionar um controle de usuário ao projeto

Como este passo a passo cria um controle complexo a vinciável de dados de um Controle de Usuário, adicione
um item de Controle de Usuário ao projeto:
1. No menu Projeto , escolha Adicionar Controle do Usuário .
2. Digite ComplexDataGridView na área Nome e clique em Adicionar .
O controle ComplexDataGridView é adicionado ao Gerenciador de Soluções e abre no designer.

Criar o controle ComplexDataGridView

Para adicionar um DataGridView ao controle de usuário, arraste um da Caixa de Ferramentas para a
DataGridView superfície de design do controle de usuário.

Adicionar o atributo de associação de dados necessário

Para controles complexos que dão suporte à associação de dados, você pode implementar o
ComplexBindingPropertiesAttribute:
1. Alterne o controle ComplexDataGridView para exibição de código. (No menu Exibir , selecione
Código .)
2. Substitua o código no ComplexDataGridView pelo seguinte:
using System.Windows.Forms;

namespace CS
{
[System.ComponentModel.ComplexBindingProperties("DataSource", "DataMember")]
public partial class ComplexDataGridView : UserControl
{
public object DataSource
{
get{ return dataGridView1.DataSource; }
set{ dataGridView1.DataSource = value; }
}

public string DataMember

{
get{ return dataGridView1.DataMember; }
set{ dataGridView1.DataMember = value; }
}

public ComplexDataGridView()
{
InitializeComponent();
}
}
}

<System.ComponentModel.ComplexBindingProperties("DataSource", "DataMember")>
Public Class ComplexDataGridView

Public Property DataSource() As Object

Get
Return DataGridView1.DataSource
End Get
Set(ByVal value As Object)
DataGridView1.DataSource = value
End Set
End Property

Public Property DataMember() As String

Get
Return DataGridView1.DataMember
End Get
Set(ByVal value As String)
DataGridView1.DataMember = value
End Set
End Property
End Class

3. No menu Build, escolha Criar Solução .

Criar uma fonte de dados do banco de dados

Use o assistente de Configuração da Fonte de Dados para criar uma fonte de dados com base na tabela no
banco de dados de exemplo Customers Northwind:
1. Para abrir a janela Fontes de Dados, no menu Dados, clique em Mostrar Fontes de Dados .
2. Na janela Fontes de Dados , selecione Adicionar Nova Fonte de Dados para iniciar o assistente de
Configuração de Fonte de Dados .
3. Selecione Banco de Dados na página Escolher um Tipo de Fonte de Dados e, em seguida, clique
em Avançar .
4. Na página Escolher sua Conexão de Dados, faça o seguinte:
Se uma conexão de dados com o banco de dados de exemplo Northwind estiver disponível na
lista suspensa, selecione-o.
Selecione Nova Conexão para inicializar a caixa de diálogo Adicionar/Modificar Conexão .
5. Se o banco de dados exigir uma senha, selecione a opção para incluir dados confidenciais e, em seguida,
clique em Avançar .
6. Na página Salvar cadeia de conexão no arquivo configuração de aplicativo, clique em Próximo.
7. Na página Escolher seus Objetos de Banco de Dados, expanda o nó Tabelas.
8. Selecione a tabela Customers e clique em Concluir .
O Nor thwindDataSet é adicionado ao seu projeto e a Customers tabela aparece na janela Fontes de
Dados.

Definir a tabela Clientes para usar o controle ComplexDataGridView

Na janela Fontes de Dados, você pode definir o controle a ser criado antes de arrastar itens para o formulário:
1. Abra Form1 no designer.
2. Expanda o nó Clientes na janela Fontes de Dados .
3. Clique na seta suspensa no nó Clientes e escolha Personalizar .
4. Selecione ComplexDataGridView na lista de Controles Associados na caixa de diálogo Opções de
Personalização da Interface do Usuário de Dados .
5. Clique na seta suspensa na tabela Customers e escolha ComplexDataGridView na lista de controle.

Adicionar controles ao formulário

Você pode criar os controles vinculados a dados arrastando itens da janela Fontes de Dados para o formulário.
Arraste o nó principal Clientes da janela Fontes de Dados para o formulário. Verifique se o controle
ComplexDataGridView é usado para exibir os dados da tabela.

Executar o aplicativo
Pressione F5 para executar o aplicativo.

Confira também
Associar controles do Windows Forms a dados no Visual Studio
Definir o controle a ser criado quando arrastado da janela Fontes de Dados
Windows Controles de formulários
Criar um controle de usuário do Windows Forms
compatível com associação de dados de consulta
20/11/2021 • 7 minutes to read

Ao exibir dados no Windows Forms, você poderá escolher os controles existentes da Caixa de Ferramentas
ou criar controles personalizados se o aplicativo exigir alguma funcionalidade que não esteja disponível nos
controles padrão. Este passo a passo mostra como criar um controle que implementa o
LookupBindingPropertiesAttribute. Os controles que implementam o LookupBindingPropertiesAttribute contêm
três propriedade que podem ser associadas a dados. Tais controles são semelhantes a um ComboBox.
Para obter mais informações sobre a criação de controle, consulte Desenvolvendo controles Windows Forms em
tempo de design.
Ao criar controles para uso em cenários de associação de dados, é necessário implementar um dos seguintes
atributos de associação de dados:

USO DE AT RIB UTO DE A SSO C IA Ç Ã O DE DA DO S

Implemente o LookupBindingPropertiesAttribute nos controles, como um ComboBoxque exibe listas (ou tabelas) de dados,
mas também precisa apresentar uma única coluna ou propriedade. (Esse processo é descrito nesta página de passo a passo.)

Este passo a passo cria um controle de pesquisa que se associa aos dados de duas tabelas. Este exemplo usa as
tabelas Customers e Orders do banco de dados de exemplo Northwind. O controle de busca é vinculado ao
CustomerID campo da Orders tabela. Ele usa esse valor para procurar o CompanyName da Customers tabela.

Durante este passo a passo, você aprenderá a:

Crie um novo aplicativo Windows Forms .
Adicionar um novo Controle de Usuário ao projeto.
Projetar visualmente o controle do usuário.
Implementar o atributo LookupBindingProperty .
Crie um conjuntos de dados com o assistente de Configuração da Fonte de Dados.
Definir a coluna CustomerID na tabela Pedidos na janela Fontes de Dados para usar o novo controle.
Criar um formulário para exibir dados no novo controle.

Pré-requisitos
Este passo a passo usa SQL Server Express LocalDB e o banco de dados de exemplo Northwind.
1. Se você não tiver um SQL Server Express LocalDB, instale-o na página de download SQL Server Express
oupor meio do Instalador do Visual Studio . No Instalador do Visual Studio , você pode instalar o
SQL Server Express LocalDB como parte da carga de trabalho armazenamento e processamento de
dados ou como um componente individual.
2. Instale o banco de dados de exemplo Northwind seguindo estas etapas:
a. No Visual Studio, abra a SQL Ser ver Pesquisador de Objetos janela. (SQL Server Pesquisador
de Objetos é instalado como parte da carga de trabalho armazenamento e processamento de
dados no Instalador do Visual Studio.) Expanda o SQL Ser ver nó. Clique com o botão direito do
mouse na instância LocalDB e selecione Nova Consulta .
Uma janela do editor de consultas é aberta.
b. Copie o script Northwind Transact-SQL para a área de transferência. Esse script T-SQL cria o banco
de dados Northwind do zero e o popula com dados.
c. Colar o script T-SQL no editor de consultas e, em seguida, escolha o botão Executar.
Após um curto período, a consulta termina a execução e o banco de dados Northwind é criado.

Criar um projeto de aplicativo Windows Forms

A primeira etapa é criar um projeto de aplicativo Windows Forms.
1. No Visual Studio, no menu Arquivo , selecione Novo > Projeto .
2. Expanda Visual C# ou Visual Basic no painel esquerdo e selecione Windows Desktop.
3. No painel central, selecione o tipo de projeto Windows Aplicativo de Formulários.
4. Nomeia o projeto LookupControlWalkthrough e escolha OK.
O projeto LookupControlWalkthrough é criado e adicionado ao Gerenciador de Soluções .

Adicionar um controle de usuário ao projeto

Este passo a passo cria um controle de pesquisa de um Controle de Usuário , portanto, adicione um item de
Controle de Usuário ao projeto LookupControlWalkthrough .
1. No menu Projeto , selecione Adicionar Controle do Usuário .
2. Digite LookupBox na área Nome e clique em Adicionar .
O controle LookupBox é adicionado ao Gerenciador de Soluções e abre no designer.

Criar o controle LookupBox

Para criar o controle LookupBox, arraste um da Caixa de Ferramentas para a superfície de design do controle
ComboBox de usuário.

Adicionar o atributo de associação de dados necessário

Para controles de pesquisa que suportam associação de dados, você pode implementar o
LookupBindingPropertiesAttribute.
1. Mude o controle LookupBox para exibição de código. (No menu Exibir , escolha Código .)
2. Substitua o código no LookupBox pelo seguinte:
<System.ComponentModel.LookupBindingProperties("DataSource", "DisplayMember", "ValueMember",
"LookupMember")>
Public Class LookupBox

Public Property DataSource() As Object

Get
Return ComboBox1.DataSource
End Get
Set(ByVal value As Object)
ComboBox1.DataSource = value
End Set
End Property

Public Property DisplayMember() As String

Get
Return ComboBox1.DisplayMember
End Get
Set(ByVal value As String)
ComboBox1.DisplayMember = value
End Set
End Property

Public Property ValueMember() As String

Get
Return ComboBox1.ValueMember
End Get
Set(ByVal value As String)
ComboBox1.ValueMember = value
End Set
End Property

Public Property LookupMember() As String

Get
Return ComboBox1.SelectedValue.ToString()
End Get
Set(ByVal value As String)
ComboBox1.SelectedValue = value
End Set
End Property
End Class
using System.Windows.Forms;

namespace CS
{
[System.ComponentModel.LookupBindingProperties("DataSource", "DisplayMember", "ValueMember",
"LookupMember")]
public partial class LookupBox : UserControl
{
public object DataSource
{
get{ return comboBox1.DataSource; }
set{ comboBox1.DataSource = value; }
}

public string DisplayMember

{
get{ return comboBox1.DisplayMember; }
set{ comboBox1.DisplayMember = value; }
}

public string ValueMember

{
get{ return comboBox1.ValueMember; }
set{ comboBox1.ValueMember = value; }
}

public string LookupMember

{
get{ return comboBox1.SelectedValue.ToString(); }
set{ comboBox1.SelectedValue = value; }
}

public LookupBox()
{
InitializeComponent();
}
}
}

3. No menu Build, escolha Criar Solução .

Criar uma fonte de dados do banco de dados

Esta etapa cria uma fonte de dados usando o Assistente de Configuração de Fonte de Dados com base
nas tabelas Customers e Orders no banco de dados de exemplo Northwind.
1. Para abrir a janela Fontes de Dados, no menu Dados, clique em Mostrar Fontes de Dados .
2. Na janela Fontes de Dados , selecione Adicionar Nova Fonte de Dados para iniciar o assistente de
Configuração de Fonte de Dados .
3. Selecione Banco de Dados na página Escolher um Tipo de Fonte de Dados e, em seguida, clique
em Avançar .
4. Na página Escolher sua Conexão de Dados, faça o seguinte:
Se uma conexão de dados com o banco de dados de exemplo Northwind estiver disponível na
lista suspensa, selecione-o.
Selecione Nova Conexão para inicializar a caixa de diálogo Adicionar/Modificar Conexão .
5. Se o banco de dados exigir uma senha, selecione a opção para incluir dados confidenciais e, em seguida,
clique em Avançar .
6. Na página Salvar cadeia de conexão no arquivo configuração de aplicativo, clique em Próximo.
7. Na página Escolher seus Objetos de Banco de Dados, expanda o nó Tabelas.
8. Selecione as tabelas Customers e Orders e, em seguida, clique em Concluir .
O Nor thwindDataSet é adicionado ao seu projeto e as tabelas Customers e aparecem na janela Fontes
Orders de Dados.

Definir a coluna CustomerID da tabela Orders para usar o controle

LookupBox
Na janela Fontes de Dados , você pode definir o controle a ser criado antes de arrastar itens para seu
formulário.
1. Abra Form1 no designer.
2. Expanda o nó Clientes na janela Fontes de Dados .
3. Expanda o nó Pedidos (no nó Clientes abaixo da coluna Fax ).
4. Clique na seta suspensa no nó Pedidos e escolha Detalhes na lista de controle.
5. Clique na seta suspensa na coluna CustomerID (no nó Pedidos ) e escolha Personalizar .
6. Selecione LookupBox na lista de Controles Associados na caixa de diálogo Opções de
Personalização da Interface do Usuário de Dados .
7. Clique em OK .
8. Clique na seta suspensa na coluna CustomerID e escolha LookupBox .

Adicionar controles ao formulário

É possível criar controles de associação de dados ao arrastar itens da janela Fontes de Dados para Form1 .
Para criar controles com limite de dados no formulário Windows, arraste o nó Orders da janela Fontes de Dados
para o Formulário Windows e verifique se o controle LookupBox é usado para exibir os dados na CustomerID
coluna.

A bind the control to look up CompanyName from the Customers

table
Para configurar as vinculações de pesquisa, selecione o nó principal Clientes na janela Fontes de Dados e
arraste-o para a caixa de combinação na CustomerIDLookupBox no Form1 .
Isso configura a associação de dados para exibir o CompanyName da tabela Customers mantendo, ao mesmo
tempo, o valor CustomerID da tabela Orders .

Executar o aplicativo
Pressione F5 para executar o aplicativo.
Navegue por alguns registros e verifique se CompanyName aparece no controle LookupBox .

Confira também
Associar controles do Windows Forms a dados no Visual Studio
Passar dados entre formulários
20/11/2021 • 6 minutes to read

Este passo a passo fornece instruções detalhadas de como passar os dados de um formulário para outro.
Usando as tabelas de clientes e pedidos da Northwind, um formulário permite que os usuários selecionem um
cliente e um segundo formulário exibe os pedidos do cliente selecionado. Este passo a passo mostra como criar
um método no segundo formulário que recebe dados do primeiro formulário.

NOTE
Este passo a passo demonstra apenas uma maneira de passar dados entre formulários. Há outras opções para passar
dados para um formulário, incluindo a criação de um segundo construtor para receber dados ou a criação de uma
propriedade pública que pode ser definida com dados do primeiro formulário.

As tarefas ilustradas neste passo a passo incluem:

Criando um novo projeto de aplicativo Windows Forms.
Criando e configurando um conjuntos de dados com o Assistente de Configuraçãoda Fonte de Dados .
Selecionando o controle a ser criado no formulário ao arrastar itens da janela Fontes de Dados . Para
obter mais informações, consulte Definir o controle a ser criado ao arrastar da janela Fontes de Dados.
Criar controles associados a dados arrastando itens da janela Fontes de Dados para um formulário.
Criar um segundo formulário com uma grade para exibir dados.
Criar uma consulta TableAdapter para buscar pedidos de um cliente específico.
Passar dados entre formulários.

Pré-requisitos
Este passo a passo usa SQL Server Express LocalDB e o banco de dados de exemplo Northwind.
1. Se você não tiver um SQL Server Express LocalDB, instale-o na página de download SQL Server Express
oupor meio do Instalador do Visual Studio . No Instalador do Visual Studio, SQL Server Express
LocalDB pode ser instalado como parte da carga de trabalho armazenamento e processamento de dados
ou como um componente individual.
2. Instale o banco de dados de exemplo Northwind seguindo estas etapas:
a. No Visual Studio, abra a SQL Ser ver Pesquisador de Objetos janela. (SQL Server Pesquisador
de Objetos é instalado como parte da carga de trabalho armazenamento e processamento de
dados no Instalador do Visual Studio.) Expanda o SQL Ser ver nó. Clique com o botão direito do
mouse na LocalDB e selecione Nova Consulta .
Uma janela do editor de consultas é aberta.
b. Copie o script Northwind Transact-SQL para a área de transferência. Esse script T-SQL cria o banco
de dados Northwind do zero e o popula com dados.
c. Colar o script T-SQL no editor de consultas e, em seguida, escolha o botão Executar.
Após um curto período, a consulta termina a execução e o banco de dados Northwind é criado.
Criar o projeto de aplicativo Windows Forms
1. No Visual Studio, no menu Arquivo , selecione Novo > Projeto .
2. Expanda Visual C# ou Visual Basic no painel esquerdo e selecione Windows Desktop.
3. No painel central, selecione o tipo de projeto Windows Aplicativo de Formulários.
4. Nomeia o projeto PassingDataBetweenForms e escolha OK.
O projeto PassingDataBetweenForms é criado e adicionado ao Gerenciador de Soluções .

Criar a fonte de dados

1. Para abrir a janela Fontes de Dados, no menu Dados, clique em Mostrar Fontes de Dados .
2. Na janela Fontes de Dados , selecione Adicionar Nova Fonte de Dados para iniciar o assistente de
Configuração de Fonte de Dados .
3. Selecione Banco de Dados na página Escolher um Tipo de Fonte de Dados e, em seguida, clique
em Avançar .
4. Na página Escolha um Modelo de Banco de Dados , verifique se o Conjunto de dados foi
especificado e clique em Avançar .
5. Na página Escolha a Conexão de Dados , faça o seguinte:
Se uma conexão de dados com o banco de dados de exemplo Northwind estiver disponível na
lista suspensa, selecione-o.
Selecione Nova Conexão para inicializar a caixa de diálogo Adicionar/Modificar Conexão .
6. Se o banco de dados exigir uma senha e a opção para incluir dados confidenciais estiver habilitada, clique
em Avançar .
7. Na página Salvar cadeia de conexão no arquivo configuração de aplicativo, clique em Próximo.
8. Na página Escolher seus Objetos de Banco de Dados, expanda o nó Tabelas.
9. Selecione as tabelas Customers e Orders e, em seguida, clique em Finalizar .
O Nor thwindDataSet é adicionado ao projeto e as tabelas Customers e Orders aparecem na janela
Fontes de Dados .

Criar o primeiro formulário (Form1)

Você pode criar uma grade de associação de dados (um controle DataGridView), arrastando o nó Clientes da
janela Fontes de Dados para o formulário.
Para criar uma grade de associação de dados no formulário
Arraste o nó principal Clientes da janela Fontes de Dados para Form1 .
Um DataGridView e uma faixa de ferramentas (BindingNavigator) para navegação em registros são
exibidos no Form1 . Um NorthwindDataSet, CustomersTableAdapter, BindingSource e BindingNavigator
são exibidos na bandeja de componentes.

Criar o segundo formulário

Crie um segundo formulário para passar dados.
1. No menu Projeto , escolha Adicionar Formulário do Windows .
2. Deixe o nome padrão Form2 e clique em Adicionar .
3. Arraste o nó principal Pedidos da janela Fontes de Dados para Form2 .
Um DataGridView e uma faixa de ferramentas (BindingNavigator) para navegação em registros são
exibidos no Form2 . Um NorthwindDataSet, CustomersTableAdapter, BindingSource e BindingNavigator
são exibidos na bandeja de componentes.
4. Exclua o OrdersBindingNavigator da bandeja de componentes.
O OrdersBindingNavigator desaparece do Form2 .

Adicionar uma consulta TableAdapter

Adicione uma consulta TableAdapter ao Form2 para carregar pedidos para o cliente selecionado no Form1.
1. Clique duas vezes no arquivo Nor thwindDataSet.xsd no Gerenciador de Soluções .
2. Clique com o botão direito do mouse no OrdersTableAdapter e selecione Adicionar Consulta .
3. Deixe a opção padrão Usar instruções SQL e clique em Avançar .
4. Deixe a opção padrão SELECT que retorna linhas e clique em Avançar .
5. Adicione uma cláusula WHERE à consulta para retornar Orders com base no CustomerID . A consulta
deve ser semelhante ao seguinte:

SELECT OrderID, CustomerID, EmployeeID, OrderDate, RequiredDate, ShippedDate, ShipVia, Freight,

ShipName, ShipAddress, ShipCity, ShipRegion, ShipPostalCode, ShipCountry
FROM Orders
WHERE CustomerID = @CustomerID

NOTE
Verifique a sintaxe de parâmetro correta para o seu banco de dados. Por exemplo, no Microsoft Access, a cláusula
WHERE seria algo como: WHERE CustomerID = ? .

6. Clique em Próximo .
7. Para o nome Fill a DataTableMethod , digite FillByCustomerID .
8. Desmarque a opção Retornar uma DataTable e clique em Avançar .
9. Clique em Concluir .

Criar um método no Form2 para passar dados para

1. Clique com o botão direito do mouse no Form2 e selecione Exibir Código para abrir o Form2 no
Editor de Códigos .
2. Adicione o seguinte código ao Form2 depois do método Form2_Load :

Friend Sub LoadOrders(ByVal CustomerID As String)

OrdersTableAdapter.FillByCustomerID(NorthwindDataSet.Orders, CustomerID)
End Sub
internal void LoadOrders(String CustomerID)
{
ordersTableAdapter.FillByCustomerID(northwindDataSet.Orders, CustomerID);
}

Criar um método no Form1 para passar dados e exibir o Form2

1. No Form1 , clique com o botão direito do mouse na grade de dados do Cliente e clique em
Propriedades .
2. Na janela Propriedades , clique em Eventos .
3. Clique duas vezes no evento CellDoubleClick .
O Editor de Códigos é exibido.
4. Atualize a definição de método para corresponder ao seguinte exemplo:

private void customersDataGridView_DoubleClick(object sender, EventArgs e)

{
System.Data.DataRowView SelectedRowView;
NorthwindDataSet.CustomersRow SelectedRow;

SelectedRowView = (System.Data.DataRowView)customersBindingSource.Current;
SelectedRow = (NorthwindDataSet.CustomersRow)SelectedRowView.Row;

Form2 OrdersForm = new Form2();

OrdersForm.LoadOrders(SelectedRow.CustomerID);
OrdersForm.Show();
}

Private Sub CustomersDataGridView_DoubleClick() Handles CustomersDataGridView.DoubleClick

Dim SelectedRowView As Data.DataRowView

Dim SelectedRow As NorthwindDataSet.CustomersRow

SelectedRowView = CType(CustomersBindingSource.Current, System.Data.DataRowView)

SelectedRow = CType(SelectedRowView.Row, NorthwindDataSet.CustomersRow)

Dim OrdersForm As New Form2

OrdersForm.LoadOrders(SelectedRow.CustomerID)
OrdersForm.Show()
End Sub

Executar o aplicativo
Pressione F5 para executar o aplicativo.
Clique duas vezes em um registro de cliente no Form1 para abrir o Form2 com pedidos do cliente.

Próximas etapas
Dependendo dos requisitos de aplicativo, existem várias etapas que você talvez queira realizar após passar
dados entre formulários. Entre algumas das melhorias que você poderia fazer nessa explicação passo a passo
estão:
Editando o conjunto de dados para adicionar ou remover objetos de banco de dados. Para obter mais
informações, consulte Create and configure datasets (Criar e configurar conjuntos de dados).
Adicionar funcionalidade para salvar dados de volta no banco de dados. Para obter mais informações,
consulte Salvar dados de volta no banco de dados.

Confira também
Associar controles do Windows Forms a dados no Visual Studio
A bind objects as data sources in Visual Studio
20/11/2021 • 8 minutes to read

Visual Studio fornece ferramentas de tempo de design para trabalhar com objetos personalizados como a fonte
de dados em seu aplicativo. Quando você deseja armazenar dados de um banco de dados em um objeto que
você vincula a controles de interface do usuário, a abordagem recomendada é usar Entity Framework para gerar
a classe ou classes. Entity Framework gera automaticamente todo o código de controle de alterações clichê, o
que significa que todas as alterações nos objetos locais são persistida automaticamente no banco de dados
quando você chama AcceptChanges no objeto DbSet. Para obter mais informações, consulte Entity Framework
Documentaçãodo .

TIP
As abordagens de associação de objeto neste artigo só devem ser consideradas se seu aplicativo já estiver baseado em
conjuntos de dados. Você também poderá usar essas abordagens se já estiver familiarizado com conjuntos de dados e os
dados que você processará serão tabular e não muito complexos ou muito grandes. Para um exemplo ainda mais simples,
envolvendo o carregamento de dados diretamente em objetos usando um DataReader e atualizando manualmente a
interface do usuário sem a adição de dados, consulte Criar um aplicativo de dados simples usando ADO.NET.

Requisitos de objeto
O único requisito para que objetos personalizados funcionem com as ferramentas de design de dados no Visual
Studio é que o objeto precise de pelo menos uma propriedade pública.
Em geral, objetos personalizados não exigem interfaces, construtores ou atributos específicos para atuar como
uma fonte de dados para um aplicativo. No entanto, se você quiser arrastar o objeto da janela Fontes de Dados
para uma superfície de design para criar um controle com limite de dados e se o objeto implementar a interface
ou , o objeto deverá ter um construtor ITypedList IListSource padrão. Caso contrário, Visual Studio não pode
criar uma inciação do objeto de fonte de dados e exibe um erro quando você arrasta o item para a superfície de
design.

Exemplos de uso de objetos personalizados como fontes de dados

Embora haja inúmeras maneiras de implementar a lógica do aplicativo ao trabalhar com objetos como uma
fonte de dados, para bancos de dados do SQL há algumas operações padrão que podem ser simplificadas
usando os objetos TableAdapter gerados pelo Visual Studio. Esta página explica como implementar esses
processos padrão usando TableAdapters. Ele não se destina como um guia para criar seus objetos
personalizados. Por exemplo, você normalmente executará as seguintes operações padrão, independentemente
da implementação específica de seus objetos ou da lógica do aplicativo:
Carregando dados em objetos (normalmente de um banco de dados).
Criando uma coleção de objetos com tipo.
Adicionando objetos a e removendo objetos de uma coleção.
Exibindo os dados do objeto para os usuários em um formulário.
Alterando/editando os dados em um objeto .
Salvando dados de objetos de volta no banco de dados.
Carregar dados em objetos
Para este exemplo, você carrega dados em seus objetos usando TableAdapters. Por padrão, TableAdapters são
criados com dois tipos de métodos que buscam dados de um banco de dados e populam tabelas de dados.
O TableAdapter.Fill método preenche uma tabela de dados existente com os dados retornados.
O TableAdapter.GetData método retorna uma nova tabela de dados populada com dados.
A maneira mais fácil de carregar seus objetos personalizados com dados é chamar o método , fazer um loop
pela coleção de linhas na tabela de dados retornada e preencher cada objeto com os valores em
TableAdapter.GetData cada linha. Você pode criar um GetData método que retorna uma tabela de dados
populada para qualquer consulta adicionada a um TableAdapter.

NOTE
Visual Studio nomeia as consultas TableAdapter e, por padrão, mas você pode alterar esses Fill nomes para qualquer
nome de método GetData válido.

O exemplo a seguir mostra como fazer um loop pelas linhas em uma tabela de dados e preencher um objeto
com dados:
private void LoadCustomers()
{
NorthwindDataSet.CustomersDataTable customerData =
customersTableAdapter1.GetTop5Customers();

foreach (NorthwindDataSet.CustomersRow customerRow in customerData)

{
Customer currentCustomer = new Customer();
currentCustomer.CustomerID = customerRow.CustomerID;
currentCustomer.CompanyName = customerRow.CompanyName;

if (customerRow.IsAddressNull() == false)
{
currentCustomer.Address = customerRow.Address;
}

if (customerRow.IsCityNull() == false)
{
currentCustomer.City = customerRow.City;
}

if (customerRow.IsContactNameNull() == false)
{
currentCustomer.ContactName = customerRow.ContactName;
}

if (customerRow.IsContactTitleNull() == false)
{
currentCustomer.ContactTitle = customerRow.ContactTitle;
}

if (customerRow.IsCountryNull() == false)
{
currentCustomer.Country = customerRow.Country;
}

if (customerRow.IsFaxNull() == false)
{
currentCustomer.Fax = customerRow.Fax;
}

if (customerRow.IsPhoneNull() == false)
{
currentCustomer.Phone = customerRow.Phone;
}

if (customerRow.IsPostalCodeNull() == false)
{
currentCustomer.PostalCode = customerRow.PostalCode;
}

if (customerRow.IsRegionNull() == false)
{
currentCustomer.Region = customerRow.Region;
}

LoadOrders(currentCustomer);
customerBindingSource.Add(currentCustomer);
}
}
Private Sub LoadCustomers()
Dim customerData As NorthwindDataSet.CustomersDataTable =
CustomersTableAdapter1.GetTop5Customers()

Dim customerRow As NorthwindDataSet.CustomersRow

For Each customerRow In customerData

Dim currentCustomer As New Customer()
With currentCustomer

.CustomerID = customerRow.CustomerID
.CompanyName = customerRow.CompanyName

If Not customerRow.IsAddressNull Then

.Address = customerRow.Address
End If

If Not customerRow.IsCityNull Then

.City = customerRow.City
End If

If Not customerRow.IsContactNameNull Then

.ContactName = customerRow.ContactName
End If

If Not customerRow.IsContactTitleNull Then

.ContactTitle = customerRow.ContactTitle
End If

If Not customerRow.IsCountryNull Then

.Country = customerRow.Country
End If

If Not customerRow.IsFaxNull Then

.Fax = customerRow.Fax
End If

If Not customerRow.IsPhoneNull Then

.Phone = customerRow.Phone
End If

If Not customerRow.IsPostalCodeNull Then

.PostalCode = customerRow.PostalCode
End If

If Not customerRow.Is_RegionNull Then

.Region = customerRow._Region
End If

End With

LoadOrders(currentCustomer)
CustomerBindingSource.Add(currentCustomer)
Next
End Sub

Criar uma coleção de objetos com tipo

Você pode criar classes de coleção para seus objetos ou usar as coleções digitadas fornecidas automaticamente
pelo componente BindingSource.
Quando você estiver criando uma classe de coleção personalizada para objetos, sugerimos que você herde de
BindingList<T> . Essa classe genérica fornece funcionalidade para administrar sua coleção, bem como a
capacidade de ative eventos que enviam notificações para a infraestrutura de associação de dados no Windows
Forms.
A coleção gerada automaticamente no BindingSource usa um para sua coleção BindingList<T> digitada. Se o
aplicativo não exigir funcionalidade adicional, você poderá manter sua coleção dentro do BindingSource . Para
obter mais informações, consulte List a propriedade da classe BindingSource .

NOTE
Se sua coleção exigir funcionalidade não fornecida pela implementação base do , você deverá criar uma coleção
personalizada para que possa adicionar à BindingList<T> classe conforme necessário.

O código a seguir mostra como criar a classe para uma coleção de objetos fortemente Order digitada:

/// <summary>
/// A collection of Orders
/// </summary>
public class Orders: System.ComponentModel.BindingList<Order>
{
// Add any additional functionality required by your collection.
}

''' <summary>
''' A collection of Orders
''' </summary>
Public Class Orders
Inherits System.ComponentModel.BindingList(Of Order)

' Add any additional functionality required by your collection.

End Class

Adicionar objetos a uma coleção

Você adiciona objetos a uma coleção chamando o Add método de sua classe de coleção personalizada ou do
BindingSource .

NOTE
O Add método é fornecido automaticamente para sua coleção personalizada quando você herda de BindingList<T> .

O código a seguir mostra como adicionar objetos à coleção digitada em um BindingSource :

Customer currentCustomer = new Customer();

customerBindingSource.Add(currentCustomer);

Dim currentCustomer As New Customer()

CustomerBindingSource.Add(currentCustomer)

O código a seguir mostra como adicionar objetos a uma coleção digitada que herda de BindingList<T> :

NOTE
Neste exemplo, a Orders coleção é uma propriedade do objeto Customer .
Order currentOrder = new Order();
currentCustomer.Orders.Add(currentOrder);

Dim currentOrder As New Order()

currentCustomer.Orders.Add(currentOrder)

Remover objetos de uma coleção

Você remove objetos de uma coleção chamando o Remove método ou de sua classe de coleção personalizada
ou de RemoveAt BindingSource .

NOTE
Os Remove métodos e são RemoveAt fornecidos automaticamente para sua coleção personalizada quando você herda
de BindingList<T> .

O código a seguir mostra como localizar e remover objetos da coleção digitada em um BindingSource com o
RemoveAt método :

int customerIndex = customerBindingSource.Find("CustomerID", "ALFKI");

customerBindingSource.RemoveAt(customerIndex);

Dim customerIndex As Integer = CustomerBindingSource.Find("CustomerID", "ALFKI")

CustomerBindingSource.RemoveAt(customerIndex)

Exibir dados de objeto para os usuários

Para exibir os dados em objetos para usuários, crie uma fonte de dados de objeto usando o assistente de
Configuração da Fonte de Dados e arraste todo o objeto ou propriedades individuais para o formulário da
janela Fontes de Dados.
Modificar os dados em objetos
Para editar dados em objetos personalizados que são vinculados a dados Windows forms, basta editar os dados
no controle vinculado (ou diretamente nas propriedades do objeto). A arquitetura de associação de dados
atualiza os dados no objeto .
Se seu aplicativo exigir o acompanhamento de alterações e a replicação das alterações propostas em seus
valores originais, você deverá implementar essa funcionalidade em seu modelo de objeto. Para ver exemplos de
como as tabelas de dados acompanham as alterações propostas, DataRowState consulte HasChanges , e
GetChanges .
Salvar dados em objetos de volta no banco de dados
Salve os dados de volta no banco de dados passando os valores do objeto para os métodos DBDirect do
TableAdapter.
Visual Studio cria métodos DBDirect que podem ser executados diretamente no banco de dados. Esses métodos
não exigem objetos DataSet ou DataTable.

M ÉTO DO S DB DIREC T TA B L EA DA P T ER DESC RIÇ Ã O

TableAdapter.Insert Adiciona novos registros a um banco de dados, permitindo

que você passe valores de coluna individuais como
parâmetros de método.
M ÉTO DO S DB DIREC T TA B L EA DA P T ER DESC RIÇ Ã O

TableAdapter.Update Atualiza os registros existentes em um banco de dados. O

método Update assume valores de coluna originais e novos
como parâmetros de método. Os valores originais são
usados para localizar o registro original e os novos valores
são usados para atualizar esse registro.

O método também é usado para reconciliar alterações em

um conjunto de dados de volta para o banco de dados,
utilizando uma matriz , , ou de s como
TableAdapter.Update DataSet DataTable DataRow
DataRow parâmetros de método.

TableAdapter.Delete Exclui registros existentes do banco de dados com base nos

valores de coluna originais passados como parâmetros de
método.

Para salvar dados de uma coleção de objetos, loop pela coleção de objetos (por exemplo, usando um loop for-
next). Envie os valores de cada objeto para o banco de dados usando os métodos DBDirect do TableAdapter.
O exemplo a seguir mostra como usar o TableAdapter.Insert método DBDirect para adicionar um novo cliente
diretamente ao banco de dados:

private void AddNewCustomers(Customer currentCustomer)

{
customersTableAdapter.Insert(
currentCustomer.CustomerID,
currentCustomer.CompanyName,
currentCustomer.ContactName,
currentCustomer.ContactTitle,
currentCustomer.Address,
currentCustomer.City,
currentCustomer.Region,
currentCustomer.PostalCode,
currentCustomer.Country,
currentCustomer.Phone,
currentCustomer.Fax);
}

Private Sub AddNewCustomer(ByVal currentCustomer As Customer)

Confira também
Associar controles a dados no Visual Studio
Personalizar como o Visual Studio cria legendas
para controles associados a dados
20/11/2021 • 4 minutes to read

Quando você arrasta itens da janela Fontes de Dados para um designer, uma consideração especial entra em
cena: os nomes de coluna nos rótulos de legenda são reformatados em uma cadeia de caracteres mais acessível
quando duas ou mais palavras são consideradas concatenadas juntas.
Você pode personalizar a maneira como esses rótulos são criados definindo os valores
Smar tCaptionExpression, Smar tCaptionReplacement e Smar tCaptionSuffix na chave
HKEY_CURRENT_USER\Software\Microsoft\VisualStudio\15.0\Data Designers registro.
Você pode personalizar a maneira como esses rótulos são criados definindo os valores
Smar tCaptionExpression, Smar tCaptionReplacement e Smar tCaptionSuffix na chave
HKEY_CURRENT_USER\Software\Microsoft\VisualStudio\16.0\Data Designers registro.

NOTE
Essa chave do Registro não existe até que você a crie.

A legenda inteligente é controlada pela expressão regular inserida no valor do valor

Smar tCaptionExpression. Adicionar a chave do Registro de Designers de Dados substitui a expressão
regular padrão que controla os rótulos de legenda. Para obter mais informações sobre expressões regulares,
consulte Usando expressões regulares no Visual Studio.
A tabela a seguir descreve os valores do Registro que controlam rótulos de legenda.

IT EM DO REGIST RO DESC RIÇ Ã O

Smar tCaptionExpression A expressão regular que você usa para corresponder aos
seus padrões.

Smar tCaptionReplacement O formato para exibir todos os grupos que corresponderam

no Smar tCaptionExpression.

Smar tCaptionSuffix Uma cadeia de caracteres opcional a ser anexada ao final da

legenda.

A tabela a seguir lista as configurações padrão internas para esses valores do Registro.

IT EM DO REGIST RO VA LO R PA DRÃ O EXP L IC A Ç Ã O

Smar tCaptionExpression ( \ \p{Ll})( \ \p{Lu})|_+ Corresponde a um caractere minúsculo

seguido por um caractere em letras
maiúsculas ou um sublinhado.
IT EM DO REGIST RO VA LO R PA DRÃ O EXP L IC A Ç Ã O

Smar tCaptionReplacement US$ 1 US$ 2 O $1 representa todos os caracteres

que corresponderam nos primeiros
parênteses da expressão, e $2
representa todos os caracteres que
corresponderam no segundo
parêntese. A substituição é a primeira,
um espaço e, em seguida, a segunda.

Smar tCaptionSuffix : Representa um caractere anexado à

cadeia de caracteres retornada. Por
exemplo, se a legenda for
Company Name , o sufixo o fará
Company Name:

Cau t i on

Tenha muito cuidado ao fazer qualquer coisa no Editor do Registro. Fazer o back-up do Registro antes de editá-
lo. Se você usar o Editor do Registro incorretamente, poderá causar sérios problemas que podem exigir a
reinstalação do sistema operacional. A Microsoft não garante que os problemas causados usando o Editor do
Registro possam ser resolvidos incorretamente. Use o Editor de Registro por sua conta e risco.
Para obter informações sobre como fazer o back-up, editar e restaurar o registro, consulte Windows
informações do Registro para usuários avançados.

Modificar o comportamento de legenda inteligente da janela Fontes

de Dados
1. Abra uma janela comando clicando em Iniciar e em Executar .
2. Digite regedit na caixa de diálogo Executar e clique em OK.
3. Expanda o HKEY_CURRENT_USER > Software > Microsoft > VisualStudio.
4. Clique com o botão direito do mouse no nó 15.0 e crie uma nova Chave chamada Data Designers .
4. Clique com o botão direito do mouse no nó 16.0 e crie uma nova Chave chamada Data Designers .

5. Clique com o botão direito do mouse no nó Designers de Dados e crie três novos valores de cadeia de
caracteres:
SmartCaptionExpression
SmartCaptionReplacement
SmartCaptionSuffix

6. Clique com o botão direito do mouse no valor smar tCaptionExpression e selecione Modificar .
7. Insira a expressão regular que você deseja que a janela Fontes de Dados use.
8. Clique com o botão direito do mouse no valor Smar tCaptionReplacement e selecione Modificar .
9. Insira a cadeia de caracteres de substituição formatada da maneira que você deseja exibir os padrões de
acordo com sua expressão regular.
10. Clique com o botão direito do mouse no valor smar tCaptionSuffix e selecione Modificar .
11. Insira os caracteres que você deseja que apareçam no final da legenda.
Na próxima vez que você arrastar itens da janela Fontes de Dados, os rótulos de legenda serão criados
usando os novos valores de Registro fornecidos.
Desativar o recurso de legenda inteligente
1. Abra uma janela comando clicando em Iniciar e em Executar .
2. Digite regedit na caixa de diálogo Executar e clique em OK.
3. Expanda o HKEY_CURRENT_USER > Software > Microsoft > VisualStudio.
4. Clique com o botão direito do mouse no nó 15.0 e crie uma nova Chave chamada Data Designers .
4. Clique com o botão direito do mouse no nó 16.0 e crie uma nova Chave chamada Data Designers .

5. Clique com o botão direito do mouse no nó Designers de Dados e crie três novos valores de cadeia de
caracteres:
SmartCaptionExpression
SmartCaptionReplacement
SmartCaptionSuffix

6. Clique com o botão direito do mouse no item Smar tCaptionExpression e selecione Modificar .
7. Insira (.*) para o valor. Isso corresponderá a toda a cadeia de caracteres.
8. Clique com o botão direito do mouse no item Smar tCaptionReplacement e selecione Modificar .
9. Insira $1 para o valor. Isso substitui a cadeia de caracteres pelo valor de matched, que é a cadeia de
caracteres inteira para que ela permaneça inalterada.
Na próxima vez que você arrastar itens da janela Fontes de Dados, os rótulos de legenda serão criados
com legendas não modificadas.

Confira também
Associar controles a dados no Visual Studio
Serviços do Windows Communication Foundation e
WCF Data Services no Visual Studio
20/11/2021 • 13 minutes to read

Visual Studio fornece ferramentas para trabalhar com Windows Communication Foundation (WCF) e WCF Data
Services, tecnologias da Microsoft para a criação de aplicativos distribuídos. este tópico fornece uma introdução
aos serviços de uma perspectiva Visual Studio. para obter a documentação completa, consulte WCF Data
Services 4,5.

O que é o WCF?
Windows O WCF (Communication Foundation) é uma estrutura unificada para a criação de aplicativos
distribuídos seguros, confiáveis, transacionados e interoperáveis. ele substitui as tecnologias de comunicação
entre processos mais antigas, como serviços web ASMX, .net Remoting, serviços de Enterprise (DCOM) e
MSMQ. O WCF reúne a funcionalidade de todas essas tecnologias em um modelo de programação unificado.
Isso simplifica a experiência de desenvolvimento de aplicativos distribuídos.
O que são WCF Data Services
WCF Data Services é uma implementação do padrão de protocolo OData (Open Data). WCF Data Services
permite que você exponha dados tabulares como um conjunto de APIs REST, permitindo que você retorne
dados usando verbos HTTP padrão, como GET, POST, PUT ou DELETE. no lado do servidor, WCF Data Services
estão sendo substituídas por ASP.NET Web API para criar novos serviços OData. a biblioteca de cliente do WCF
Data Services continua sendo uma boa opção para consumir serviços OData em um aplicativo .net do Visual
Studio (Project > Adicionar Referência de Ser viço ). para obter mais informações, consulte WCF Data
Services 4,5.
Modelo de programação do WCF
O modelo de programação do WCF se baseia na comunicação entre duas entidades: um serviço WCF e um
cliente WCF. O modelo de programação é encapsulado no System.ServiceModel namespace no .net.
Serviço WCF
Um serviço WCF é baseado em uma interface que define um contrato entre o serviço e o cliente. Ele é marcado
com um ServiceContractAttribute atributo, conforme mostrado no código a seguir:

[ServiceContract]
public interface IService1

<ServiceContract()>
Public Interface IService1

Você define funções ou métodos que são expostos por um serviço WCF marcando-os com um
OperationContractAttribute atributo.

[OperationContract]
string GetData(string value);
<OperationContract()>
Function GetData(ByVal value As String) As String

Além disso, você pode expor dados serializados marcando um tipo composto com um DataContractAttribute
atributo. Isso habilita a vinculação de dados em um cliente.
Depois que uma interface e seus métodos são definidos, eles são encapsulados em uma classe que implementa
a interface. Uma única classe de serviço WCF pode implementar vários contratos de serviço.
Um serviço WCF é exposto para consumo por meio do que é conhecido como um ponto de extremidade. O
ponto de extremidade fornece a única maneira de se comunicar com o serviço; Você não pode acessar o serviço
por meio de uma referência direta como faria com outras classes.
Um ponto de extremidade consiste em um endereço, uma associação e um contrato. O endereço define onde o
serviço está localizado; pode ser uma URL, um endereço FTP ou uma rede ou um caminho local. Uma
associação define a maneira como você se comunica com o serviço. as associações do WCF fornecem um
modelo versátil para especificar um protocolo como HTTP ou FTP, um mecanismo de segurança como Windows
autenticação ou nomes de usuário e senhas, e muito mais. Um contrato inclui as operações que são expostas
pela classe de serviço do WCF.
Vários pontos de extremidade podem ser expostos para um único serviço WCF. Isso permite que diferentes
clientes se comuniquem com o mesmo serviço de diferentes maneiras. Por exemplo, um serviço bancário pode
fornecer um ponto de extremidade para funcionários e outro para clientes externos, cada um usando um
endereço, associação e/ou contrato diferente.
Cliente de WCF
Um cliente WCF consiste em um proxy que permite que um aplicativo se comunique com um serviço WCF e um
ponto de extremidade que corresponde a um ponto de extremidade definido para o serviço. O proxy é gerado
no lado do cliente no arquivo de app.config e inclui informações sobre os tipos e métodos que são expostos
pelo serviço. para serviços que expõem vários pontos de extremidade, o cliente pode selecionar aquele que
melhor atenda às suas necessidades, por exemplo, para se comunicar via HTTP e usar Windows autenticação.
Após a criação de um cliente WCF, você faz referência ao serviço em seu código, assim como faria com qualquer
outro objeto. Por exemplo, para chamar o GetData método mostrado anteriormente, você escreveria um código
semelhante ao seguinte:

private void button1_Click(System.Object sender, System.EventArgs e)

{
ServiceReference1.Service1Client client = new
ServiceReference1.Service1Client();
string returnString;

returnString = client.GetData(textBox1.Text);
label1.Text = returnString;
}

Private Sub Button1_Click(ByVal sender As System.Object, _

ByVal e As System.EventArgs) Handles Button1.Click
Dim client As New ServiceReference1.Service1Client
Dim returnString As String

returnString = client.GetData(TextBox1.Text)
Label1.Text = returnString
End Sub
Ferramentas do WCF no Visual Studio
Visual Studio fornece ferramentas para ajudá-lo a criar serviços wcf e clientes wcf. Para um passo a passo que
demonstra as ferramentas, consulte instruções passo a passo: Criando um serviço WCF simples no Windows
Forms.
Criar e testar serviços WCF
você pode usar os modelos de Visual Studio do WCF como uma base para criar rapidamente seu próprio
serviço. Em seguida, você pode usar o cliente de teste do WCF e o host automático do WCF para depurar e
testar o serviço. Essas ferramentas juntas fornecem um ciclo de depuração e teste rápido e conveniente e
eliminam a necessidade de se comprometer com um modelo de hospedagem em um estágio inicial.
Modelos do WCF
os modelos de Visual Studio do WCF fornecem uma estrutura de classe básica para o desenvolvimento de
serviços. vários modelos WCF estão disponíveis na caixa de diálogo adicionar novo Project . Isso inclui
projetos do serviço WCF lLibrary, sites de serviço WCF e modelos de item de serviço WCF.
Quando você seleciona um modelo, os arquivos são adicionados a um contrato de serviço, uma implementação
de serviço e uma configuração de serviço. Todos os atributos necessários já foram adicionados, criando um tipo
simples de serviço "Olá, Mundo" e você não precisou escrever nenhum código. Você certamente vai querer
adicionar código para fornecer funções e métodos para seu serviço real, mas os modelos fornecem a base
básica.
para saber mais sobre os modelos do wcf, consulte wcf Visual Studio templates.
Host de serviço do WCF
quando você inicia o depurador de Visual Studio (pressionando F5 ) para um projeto de serviço wcf, a
ferramenta Host de serviço do wcf é iniciada automaticamente para hospedar o serviço localmente. O host de
serviço WCF enumera os serviços em um projeto de serviço WCF, carrega a configuração do projeto e cria uma
instância de um host para cada serviço que ele encontra.
Usando o host de serviço do WCF, você pode testar um serviço WCF sem gravar código extra ou confirmá-lo em
um host específico durante o desenvolvimento.
Para saber mais sobre o host de serviço WCF, consulte host de serviço WCF (WcfSvcHost.exe).
Cliente de teste do WCF
A ferramenta de cliente de teste do WCF permite que você insira parâmetros de teste, envie essa entrada para
um serviço WCF e exiba a resposta que o serviço envia de volta. Ele fornece uma experiência de teste de serviço
conveniente quando você a combina com o host de serviço WCF. localize a ferramenta na pasta % programfiles
(x86)% \ Microsoft Visual Studio \ 2017 \ Enterprise \Common7\IDE .
Quando você pressiona F5 para depurar um projeto de serviço WCF, o cliente de teste do WCF é aberto e exibe
uma lista de pontos de extremidade de serviço que são definidos no arquivo de configuração. Você pode testar
os parâmetros e iniciar o serviço e repetir esse processo para testar e validar continuamente seu serviço.
Para saber mais sobre o cliente de teste do WCF, consulte WCF Test Client (WcfTestClient.exe).
Acessando serviços WCF no Visual Studio
o Visual Studio simplifica a tarefa de criar clientes WCF, gerando automaticamente um proxy e um ponto de
extremidade para os serviços que você adiciona usando a caixa de diálogo Adicionar Referência de Ser viço .
Todas as informações de configuração necessárias são adicionadas ao arquivo de app.config . Na maioria das
vezes, tudo o que você precisa fazer é instanciar o serviço para usá-lo.
A caixa de diálogo Adicionar referência de ser viço permite que você insira o endereço de um serviço ou
procure um serviço que esteja definido em sua solução. A caixa de diálogo retorna uma lista de serviços e as
operações fornecidas por esses serviços. Ele também permite que você defina o namespace pelo qual você fará
referência aos serviços no código.
A caixa de diálogo Configurar referências de ser viço permite que você personalize a configuração de um
serviço. Você pode alterar o endereço de um serviço, especificar o nível de acesso, o comportamento assíncrono
e os tipos de contrato de mensagem e configurar a reutilização de tipo.

Como: selecionar um ponto de extremidade de serviço

alguns serviços do Windows Communication Foundation (WCF) expõem vários pontos de extremidade por
meio dos quais um cliente pode se comunicar com o serviço. por exemplo, um serviço pode expor um ponto de
extremidade que usa associação HTTP e nome de usuário e segurança de senha e um segundo ponto de
extremidade que usa FTP e autenticação de Windows. O primeiro ponto de extremidade pode ser usado por
aplicativos que acessam o serviço de fora de um firewall, enquanto o segundo pode ser usado em uma intranet.
Nesse caso, você pode especificar o endpointConfigurationName como um parâmetro para o construtor para
uma referência de serviço.

Para selecionar um ponto de extremidade de serviço

1. Adicione uma referência a um serviço WCF clicando com o botão direito do mouse no nó do projeto em
Gerenciador de soluções e escolhendo Adicionar referência de ser viço .
2. No editor de código, adicione um construtor para a referência de serviço:

Dim proxy As New ServiceReference.Service1Client(

ServiceReference.Service1Client proxy = new ServiceReference.Service1Client(

NOTE
Substitua o inreference pelo namespace para a referência de serviço e substitua Service1Client pelo nome do
serviço.

3. Uma lista do IntelliSense é exibida, incluindo as sobrecargas do construtor. Selecione a

endpointConfigurationName As String sobrecarga.

4. Após a sobrecarga, digite = ConfigurationName, em que ConfigurationName é o nome do ponto de

extremidade que você deseja usar.

NOTE
Se você não souber os nomes dos pontos de extremidade disponíveis, poderá encontrá-los no arquivo de
app.config .

Para localizar os pontos de extremidade disponíveis para um serviço WCF

1. No Gerenciador de soluções , clique com o botão direito do mouse no arquivo app.config do projeto
que contém a referência de serviço e clique em abrir . O arquivo aparece no editor de código.
2. Procure a <Client> marca no arquivo.
3. Pesquise abaixo da <Client> marca para obter uma marca que comece com <Endpoint> .
Se a referência de serviço fornecer vários pontos de extremidade, haverá duas ou mais <Endpoint
marcas.
4. Dentro da <EndPoint> marca, você encontrará um name=" parâmetro SomeService " (em que
SomeService representa um nome de ponto de extremidade). Esse é o nome do ponto de extremidade
que pode ser passado para a endpointConfigurationName As String sobrecarga de um construtor para
uma referência de serviço.

Como: chamar um método de serviço de forma assíncrona

a maioria dos métodos nos serviços Windows Communication Foundation (WCF) pode ser chamada de forma
síncrona ou assíncrona. Chamar um método de forma assíncrona permite que seu aplicativo continue
funcionando enquanto o método está sendo chamado quando ele opera em uma conexão lenta.
Por padrão, quando uma referência de serviço é adicionada a um projeto, ela é configurada para chamar
métodos de forma síncrona. Você pode alterar o comportamento para chamar métodos de forma assíncrona
alterando uma configuração na caixa de diálogo Configurar referência de ser viço .

NOTE
Essa opção é definida em uma base por serviço. Se um método para um serviço for chamado de forma assíncrona, todos
os métodos deverão ser chamados de forma assíncrona.

Para chamar um método de serviço de forma assíncrona

1. Em Gerenciador de soluções , selecione a referência de serviço.
2. no menu Project , clique em configurar referência de ser viço .
3. Na caixa de diálogo Configurar referência de ser viço , marque a caixa de seleção gerar operações
assíncronas .

Como associar dados retornados por um serviço

você pode associar dados retornados por um serviço de Windows Communication Foundation (WCF) a um
controle, assim como você pode associar qualquer outra fonte de dados a um controle. Quando você adiciona
uma referência a um serviço WCF, se o serviço contiver tipos compostos que retornam dados, eles serão
adicionados automaticamente à janela fontes de dados .
Para associar um controle a um único campo de dados retornado por um serviço WCF
1. No menu Dados , clique em Mostrar Fontes de Dados .
A janela Fontes de Dados é exibida.
2. Na janela fontes de dados , expanda o nó para a referência de serviço. Todos os tipos compostos
retornados pela exibição do serviço.
3. Expanda um nó para um tipo. Os campos de dados para esse tipo são exibidos.
4. Selecione um campo e clique na seta suspensa para exibir uma lista de controles que estão disponíveis
para o tipo de dados.
5. Clique no tipo de controle ao qual você deseja associar.
6. Arraste o campo para um formulário. O controle é adicionado ao formulário, junto com um
BindingSource componente e um BindingNavigator componente.
7. Repita as etapas 4 a 6 para todos os outros campos que você deseja associar.
Para associar um controle ao tipo composto retornado por um serviço WCF
1. No menu dados , selecione mostrar fontes de dados . A janela Fontes de Dados é exibida.
2. Na janela fontes de dados , expanda o nó para a referência de serviço. Todos os tipos compostos
retornados pela exibição do serviço.
3. Selecione um nó para um tipo e clique na seta suspensa para exibir uma lista de opções disponíveis.
4. Clique em DataGridView para exibir os dados em uma grade ou detalhes para exibir os dados em
controles individuais.
5. Arraste o nó para o formulário. Os controles são adicionados ao formulário, junto com um BindingSource
componente e um BindingNavigator componente.

Como: configurar um serviço para reutilizar tipos existentes

Quando uma referência de serviço é adicionada a um projeto, todos os tipos definidos no serviço são gerados
no projeto local. Em muitos casos, isso cria tipos duplicados quando um serviço usa tipos .NET comuns ou
quando os tipos são definidos em uma biblioteca compartilhada.
Para evitar esse problema, os tipos em assemblies referenciados são compartilhados por padrão. Se você quiser
desabilitar o compartilhamento de tipo para um ou mais assemblies, poderá fazer isso na caixa de diálogo
Configurar referências de ser viço .
Para desabilitar o compartilhamento de tipo em um único assembly
1. Em Gerenciador de soluções , selecione a referência de serviço.
2. no menu Project , clique em configurar referência de ser viço .
3. Na caixa de diálogo Configurar referências de ser viço , selecione reutilizar tipos em assemblies
referenciados especificados .
4. Marque a caixa de seleção para cada assembly no qual você deseja habilitar o compartilhamento de tipo.
Para desabilitar o compartilhamento de tipo para um assembly, deixe a caixa de seleção desmarcada.
Para desabilitar o compartilhamento de tipo em todos os assemblies
1. Em Gerenciador de soluções , selecione a referência de serviço.
2. no menu Project , clique em configurar referência de ser viço .
3. Na caixa de diálogo Configurar referências de ser viço , desmarque a caixa de seleção reutilizar
tipos em assemblies referenciados .

Tópicos relacionados
T ÍT ULO DESC RIÇ Ã O

Passo a passo: criando um Serviço WCF em Windows Forms Fornece uma demonstração passo a passo de como criar e
usar serviços WCF no Visual Studio.

Walkthrough: Criando um serviço de dados WCF com o WPF fornece uma demonstração passo a passo de como criar e
e Entity Framework usar WCF Data Services no Visual Studio.

Usando as ferramentas de desenvolvimento do WCF Discute como criar e testar serviços WCF no Visual Studio.

Como: Adicionar, atualizar ou remover uma referência do

WCF Data Service

Solucionando problemas de referências de serviço Apresenta alguns erros comuns que podem ocorrer com
referências de serviço e como evitá-los.

Depurando serviços WCF Descreve problemas comuns de depuração e técnicas que

você pode encontrar ao depurar serviços WCF.

Walkthrough: Criando um aplicativo de dados de n camadas Fornece instruções passo a passo para criar um conjunto de
dados tipado e separar o código do TableAdapter e do
conjunto de dados em vários projetos.

Caixa de diálogo Configurar referência de serviço Descreve os elementos da interface do usuário da caixa de
diálogo Configurar referência de ser viço .

Referência
System.ServiceModel
System.Data.Services

Confira também
Ferramentas de dados do Visual Studio para .NET
Trabalhar com um modelo conceitual (WCF Data
Services)
20/11/2021 • 2 minutes to read

Ao usar um modelo conceitual para descrever os dados em um banco de dados, você pode consultar dados por
meio de seus objetos em vez de ter que traduzir entre um esquema de banco de dados e um modelo de objeto.
Você pode usar modelos conceituais com WCF Data Services aplicativos. Os tópicos a seguir mostram como
consultar dados por meio de um modelo conceitual.

TÓ P IC O DESC RIÇ Ã O

Como executar consultas do Serviço de Dados Mostra como consultar um serviço de dados de um
aplicativo .NET.

Como: Project resultados da consulta Mostra como reduzir a quantidade de dados retornados por
meio de uma consulta de serviço de dados.

Ao usar um modelo conceitual, você pode definir que tipo de dados é válido no idioma que corresponde ao seu
domínio. Você pode definir dados válidos no modelo ou adicionar validação às operações que executa em uma
entidade ou serviço de dados.
Os tópicos a seguir mostram como adicionar validação a WCF Data Services aplicativos.

TÓ P IC O DESC RIÇ Ã O

Como interceptar mensagens do Serviço de Dados Mostra como adicionar validação a uma operação de serviço
de dados.

Os tópicos a seguir mostram como criar, atualizar e excluir dados executando operações em entidades.

TÓ P IC O DESC RIÇ Ã O

Como adicionar, modificar e excluir entidades Mostra como criar, atualizar e excluir dados de entidade em
um serviço de dados.

Como definir relações de entidade Mostra como criar ou alterar relações em um serviço de
dados.

Confira também
Serviços do Windows Communication Foundation e WCF Data Services no Visual Studio
Consultar o serviço de dados
Como se conectar a dados em um serviço
20/11/2021 • 2 minutes to read

Conecte seu aplicativo aos dados retornados de um serviço executando o Assistente de configuração da fonte
de dados e selecionando ser viço na página escolher um tipo de fonte de dados .
Após a conclusão do assistente, uma referência de serviço é adicionada ao seu projeto e fica imediatamente
disponível na janela fontes de dados.

NOTE
Os itens que aparecem na janela Fontes de Dados são dependentes das informações que o serviço retorna. Alguns
serviços podem não fornecer informações suficientes para o Assistente de Configuração de Fonte de Dados criar
objetos associáveis. Por exemplo, se o serviço retornar um conjunto de dados não tipado, nenhum item aparecerá na
janela Data Sources após a conclusão do assistente. Isso ocorre porque os conjuntos de dados não tipados não
fornecem o esquema, portanto, o assistente não tem informações suficientes para criar a fonte de dados.

Para conectar seu aplicativo a um serviço

1. No menu Dados , clique em Adicionar Nova Fonte de Dados .
2. Selecione ser viço na página escolher um tipo de fonte de dados e clique em Avançar .
3. Insira o endereço do serviço que você deseja usar ou clique em descobrir para localizar os serviços na
solução atual e, em seguida, clique em ir .
4. Opcionalmente, você pode digitar um novo namespace no lugar do valor padrão.

NOTE
Clique em avançado para abrir a caixa de diálogo Configurar referência de serviço.

5. Clique em OK para adicionar uma referência de serviço ao seu projeto.

6. Clique em Concluir .
A fonte de dados é adicionada à janela fontes de dados .

Próximas etapas
Para adicionar funcionalidade ao seu aplicativo, selecione um item na janela fontes de dados e arraste-o para
um formulário para criar controles associados. Para obter mais informações, confira Associar controles a dados
no Visual Studio.
Confira também
Associar controles do WPF a um WCF Data Service
Windows Serviços do Communication Foundation e WCF Data Services no Visual Studio
Walkthrough: criar um serviço WCF simples no
Windows Forms
20/11/2021 • 3 minutes to read

este tutorial demonstra como criar um serviço de Windows Communication Foundation simples (WCF), testá-lo
e, em seguida, acessá-lo em um aplicativo Windows Forms.

Criar um serviço
1. Abra o Visual Studio.
2. no menu arquivo , escolha novo > Project .
3. na caixa de diálogo novo Project , expanda o nó Visual Basic ou Visual C# e escolha wcf , seguido
pela biblioteca de ser viços wcf .
4. Clique em OK para criar o projeto.

2. Na janela iniciar, escolha criar um novo projeto .

3. Digite biblioteca de ser viços WCF na caixa de pesquisa na página criar um novo projeto . selecione
o modelo C# ou Visual Basic para a biblioteca de ser viços do WCF e clique em avançar .
TIP
se você não vir nenhum modelo, talvez seja necessário instalar o componente Windows Communication
Foundation do Visual Studio. escolha instalar mais ferramentas e recursos para abrir o Instalador do Visual
Studio. escolha a guia componentes individuais , role para baixo até atividades de desenvolvimento e, em
seguida, selecione Windows Communication Foundation . Clique em Modificar .

4. Na página configurar seu novo projeto , clique em criar .

NOTE
Isso cria um serviço de trabalho que pode ser testado e acessado. As duas etapas a seguir demonstram como você pode
modificar o método padrão para usar um tipo de dados diferente. Em um aplicativo real, você também adicionaria suas
próprias funções ao serviço.

5. Em Gerenciador de soluções , clique duas vezes em ISer vice1. vb ou ISer vice1. cs .

Localize a seguinte linha:

[OperationContract]
string GetData(int value);
<OperationContract()>
Function GetData(ByVal value As Integer) As String

Altere o tipo do value parâmetro para cadeia de caracteres:

[OperationContract]
string GetData(string value);

<OperationContract()>
Function GetData(ByVal value As String) As String

No código acima, observe os <OperationContract()> atributos ou [OperationContract] . Esses atributos

são necessários para qualquer método exposto pelo serviço.
6. Em Gerenciador de soluções , clique duas vezes em Ser vice1. vb ou Ser vice1. cs .

Localize a seguinte linha:

Public Function GetData(ByVal value As Integer) As String Implements IService1.GetData

Return String.Format("You entered: {0}", value)
End Function

public string GetData(int value)

{
return string.Format("You entered: {0}", value);
}

Altere o tipo do value parâmetro para cadeia de caracteres:

public string GetData(string value)

{
return string.Format("You entered: {0}", value);
}

Public Function GetData(ByVal value As String) As String Implements IService1.GetData

Return String.Format("You entered: {0}", value)
End Function

Teste o serviço
1. Pressione F5 para executar o serviço. Um formulário de cliente de teste do WCF é exibido e carrega o
serviço.
2. No formulário do cliente de teste do WCF , clique duas vezes no método GetData () em ISer vice1 . A
guia GetData é exibida.

3. Na caixa solicitação , selecione o campo valor e digite Hello .

4. Clique no botão invocar . Se uma caixa de diálogo aviso de segurança for exibida, clique em OK . O
resultado é exibido na caixa resposta .
5. No menu arquivo , clique em sair para fechar o formulário de teste.

Acessar o serviço
Referenciar o serviço WCF
1. No menu arquivo , aponte para Adicionar e clique em novo Project .
2. na caixa de diálogo novo Project , expanda o nó Visual Basic ou Visual C# , selecione Windows e, em
seguida, selecione Windows Forms aplicativo . Clique em OK para abrir o projeto.

3. Clique com o botão direito do mouse em WindowsApplication1 e clique em Adicionar referência de

ser viço . A caixa de diálogo Adicionar Referência de Ser viço é exibida.
4. Na caixa de diálogo Adicionar Referência de Ser viço , clique em Descobrir .
Ser vice1 é exibido no painel Ser viços .
5. Clique em OK para adicionar a referência de serviço.
Compilar um aplicativo cliente
1. em Gerenciador de Soluções , clique duas vezes em form1. vb ou Form1. cs para abrir o Designer de
Formulários do Windows se ele ainda não estiver aberto.
2. Na caixa de ferramentas , arraste um TextBox controle, Label um controle e um Button controle
para o formulário.

3. Clique duas vezes em Button e adicione o seguinte código ao manipulador de Click eventos:
private void button1_Click(System.Object sender, System.EventArgs e)
{
ServiceReference1.Service1Client client = new
ServiceReference1.Service1Client();
string returnString;

returnString = client.GetData(textBox1.Text);
label1.Text = returnString;
}

Private Sub Button1_Click(ByVal sender As System.Object, _

ByVal e As System.EventArgs) Handles Button1.Click
Dim client As New ServiceReference1.Service1Client
Dim returnString As String

returnString = client.GetData(TextBox1.Text)
Label1.Text = returnString
End Sub

4. Em Gerenciador de soluções , clique com o botão direito do mouse em WindowsApplication1 e

clique em definir como inicialização Project .
5. Pressione F5 para executar o projeto. Insira algum texto e clique no botão. O rótulo exibe "você inseriu:" e
mostra o texto que você inseriu.

Confira também
Serviços do Windows Communication Foundation e WCF Data Services no Visual Studio
Passo a passo: criando um Serviço de Dados WCF
com WPF e Entity Framework
20/11/2021 • 9 minutes to read

Este passo a passo demonstra como criar um WCF Data Services simples que é hospedado em um aplicativo
Web do ASP.NET e como acessá-lo de um aplicativo do Windows Forms.
Neste tutorial, você:
Criará um aplicativo Web para hospedar um WCF Data Services.
Crie um Modelo de Dados de Entidade que represente a Customers tabela no banco de dados
Northwind.
Criará um WCF Data Services.
Criará um aplicativo cliente e adicionará uma referência ao WCF Data Services.
Habilitará a associação de dados ao serviço e gerará a interface de usuário.
Se desejar, adicionará recursos de filtragem ao aplicativo.

Pré-requisitos
este passo a passos usa SQL Server Express LocalDB e o banco de dados de exemplo Northwind.
1. se você não tiver SQL Server Express LocalDB, instale-o na página de download SQL Server Expressou
por meio do Instalador do Visual Studio . no Instalador do Visual Studio , você pode instalar SQL
Server Express LocalDB como parte da carga de trabalho de armazenamento e processamento de
dados ou como um componente individual.
2. Instale o banco de dados de exemplo Northwind seguindo estas etapas:
a. no Visual Studio, abra a janela pesquisador de objetos do SQL Ser ver . (SQL Ser ver
pesquisador de objetos é instalado como parte da carga de trabalho de armazenamento e
processamento de dados no Instalador do Visual Studio.) expanda o nó SQL Ser ver . clique
com o botão direito do mouse em sua instância do LocalDB e selecione nova consulta .
Uma janela do editor de consultas é aberta.
b. copie o script Northwind Transact-SQL para a área de transferência. esse script T-SQL cria o banco
de dados Northwind do zero e popula-o com eles.
c. cole o script T-SQL no editor de consultas e, em seguida, escolha o botão executar .
Após um curto período, a consulta terminará de ser executada e o banco de dados Northwind será
criado.

Criando o serviço
Para criar um WCF Data Services, você adicionará um projeto Web, criará um Modelo de Dados de Entidade e,
em seguida, criará o serviço usando o modelo.
Na primeira etapa, você adiciona um projeto Web para hospedar o serviço.
NOTE
Seu computador pode mostrar diferentes nomes ou locais para alguns dos elementos de interface do usuário do Visual
Studio neste artigo. Você pode estar usando outra edição do Visual Studio ou outras configurações de ambiente. Para
obter mais informações, confira Personalizar o IDE.

Para criar o projeto Web

1. na barra de menus, escolha arquivo > novo > Project .
2. Na caixa de diálogo Novo Projeto , expanda os nós Visual Basic ou Visual C# e Web e escolha o
modelo Aplicativo Web ASP .NET .
3. Na caixa de texto Nome , insira Nor thwindWeb e escolha o botão OK .
4. Na caixa de diálogo Novo Projeto ASP.NET , na lista Selecionar um modelo , escolha Vazio e o botão
OK .
Na próxima etapa, você cria um Modelo de Dados de Entidade que representa a Customers tabela no banco de
dados Northwind.
Para criar o Modelo de Dados de Entidade
1. na barra de menus, escolha Project > adicionar novo Item .
2. Na caixa de diálogo Adicionar Novo Item , escolha o nó Dados e, em seguida, o item Modelo de
Dados de Entidade ADO.NET .
3. Na caixa de texto nome , digite NorthwindModel e, em seguida, escolha o botão Adicionar .
O Assistente do Modelo de Dados de Entidade é aberto.
4. No assistente de Modelo de Dados de Entidade, na página escolher conteúdo do modelo , escolha o
designer do EF do item do banco de dados e, em seguida, escolha o botão Avançar .
5. Na página Escolha a Conexão de Dados , executa uma das seguintes etapas:
Se uma conexão de dados com o banco de dados de exemplo Northwind estiver disponível na
lista suspensa, selecione-a.
-ou-
Escolha o botão Nova Conexão para configurar uma nova conexão de dados. Para obter mais
informações, consulte adicionar novas conexões.
6. Se o banco de dados exigir uma senha, escolha o botão de opção Sim, incluir os dados confidenciais
da cadeia de conexão e escolha o botão Avançar .

NOTE
Se uma caixa de diálogo for exibida, escolha Sim para salvar o arquivo no seu projeto.

7. Na página Escolha sua versão , escolha o botão de opção Entity Framework 5.0 e o botão Avançar .

NOTE
Para usar a versão mais recente do Entity Framework 6 com Serviço WCF, você precisará instalar o pacote NuGet
do provedor do Entity Framework do WCF Data Services. consulte usando WCF Data Services 5.6.0 com Entity
Framework 6 +.
8. Na página Escolher Objetos do Banco de Dados , expanda o nó Tabelas , marque a caixa de seleção
Clientes e escolha o botão Concluir .
O diagrama de modelo de entidade é exibido e um arquivo NorthwindModel. edmx é adicionado ao seu
projeto.
Na próxima etapa, você criará e testará o serviço de dados.
Para criar o serviço de dados
1. na barra de menus, escolha Project > adicionar novo Item .
2. Na caixa de diálogo Adicionar Novo Item , escolha o nó Web e, em seguida, o item WCF Data
Ser vices 5.6 .
3. Na caixa de texto nome , digite NorthwindCustomers e, em seguida, escolha o botão Adicionar .
O arquivo Nor thwindCustomers.svc aparece no Editor de Códigos .
4. No Editor de Códigos , localize o primeiro comentário TODO: e substitua o código pelo seguinte:

Inherits DataService(Of northwindEntities)

public class NorthwindCustomers : DataService<northwindEntities>

5. Substitua os comentários no manipulador de eventos InitializeService pelo seguinte código:

config.SetEntitySetAccessRule("*", EntitySetRights.All)

config.SetEntitySetAccessRule("*", EntitySetRights.All);

6. Na barra de menus, escolha depurar > Iniciar sem depuração para executar o serviço. Uma janela do
navegador é aberta e o esquema XML para o serviço é exibido.
7. Na barra de endereços , digite Customers no final da URL para Nor thwindCustomers. svc e escolha a
tecla Enter .
Uma representação XML dos dados na Customers tabela é exibida.

NOTE
Em alguns casos, o Internet Explorer interpretará incorretamente os dados como um RSS feed. Você deve verificar
se a opção para exibir RSS feeds está desabilitada. Para obter mais informações, consulte Solucionando problemas
de referências de serviço.

8. Feche a janela do navegador.

nas próximas etapas, você criará um aplicativo cliente Windows Forms para consumir o serviço.

Criando o aplicativo cliente

Para criar o aplicativo cliente, você adiciona um segundo projeto, adiciona uma referência de serviço ao projeto,
configura uma fonte de dados e cria uma interface do usuário para exibir os dados do serviço.
na primeira etapa, você adiciona um projeto Windows Forms à solução e o define como o projeto de
inicialização.
Para criar o aplicativo cliente
1. na barra de menus, escolha arquivo, adicionar > novo Project .
2. na caixa de diálogo novo Project , expanda o nó Visual Basic ou Visual C# , escolha o nó Windows e,
em seguida, escolha Windows Forms aplicativo .
3. Na caixa de texto Nome , insira NorthwindClient e, em seguida, escolha o botão OK .
4. No Gerenciador de Soluções , escolha o nó de projeto Nor thwindClient .
5. Na barra de menus, escolha Projeto , Definir como Projeto de Inicialização .
Na próxima etapa, você adiciona uma referência de serviço ao WCF Data Services no projeto Web.
Para adicionar uma referência de serviço
1. na barra de menus, escolha Project > Adicionar Referência de Ser viço .
2. Na caixa de diálogo Adicionar Referência de Ser viço , escolha o botão Descobrir .
A URL do serviço NorthwindCustomers é exibida no campo Endereço .
3. Escolha o botão OK para adicionar a referência de serviço.
Na próxima etapa, você configura uma fonte de dados para habilitar a vinculação de dados ao serviço.
Para habilitar a associação de dados ao serviço
1. na barra de menus, escolha exibir > outros Windows > fontes de dados .
A janela Fontes de Dados é aberta.
2. Na janela Fontes de Dados , escolha o botão Adicionar Nova Fonte de Dados .
3. Na página Escolher um Tipo de Fonte de Dados do Assistente de Configuração de Fonte de
Dados , escolha Objeto e, em seguida, o botão Próximo .
4. Na página Selecionar os Objetos de Dados , expanda os nós Nor thwindClient e
Nor thwindClient.Ser viceReference1 .
5. Marque a caixa de seleção Customer e escolha o botão Finalizar .
Na próxima etapa, você cria a interface do usuário que exibe os dados do serviço.
Para criar a interface do usuário
1. Na janela Fontes de Dados , abra o menu de atalho do nó Clientes e escolha Copiar .
2. No designer de formulários Form1.vb ou Form1.cs , abra o menu de atalho e escolha Colar .
Um controle DataGridView, um componente BindingSource e um componente BindingNavigator são
adicionados ao formulário.
3. Escolha o controle customersDataGridView e, na janela Propriedades , defina a propriedade Dock
como Fill .
4. No Gerenciador de soluções , abra o menu de atalho para o nó Form1 e escolha Exibir código para
abrir o editor de código e adicione a Imports seguinte Using instrução ou na parte superior do arquivo:

Imports NorthwindClient.ServiceReference1
using NorthwindClient.ServiceReference1;

5. Adicione o seguinte código ao manipulador de eventos do Form1_Load :

Private Sub Form1_Load(sender As Object, e As EventArgs) Handles MyBase.Load

Dim proxy As New NorthwindEntities _
(New Uri("http://localhost:53161/NorthwindCustomers.svc/"))
Me.CustomersBindingSource.DataSource = proxy.Customers
End Sub

private void Form1_Load(object sender, EventArgs e)

{
NorthwindEntities proxy = new NorthwindEntities(new
Uri("http://localhost:53161/NorthwindCustomers.svc/"));
this.CustomersBindingSource.DataSource = proxy.Customers;
}

6. No Gerenciador de Soluções , abra o menu de atalho do arquivo Nor thwindCustomers.svc e

escolha Exibir no Navegador . O Internet Explorer é aberto e o esquema XML para o serviço é exibido.
7. Copie a URL da barra de endereços do Internet Explorer.
8. No código que você adicionou na etapa 4, selecione http://localhost:53161/NorthwindCustomers.svc/ eo
substitua pela URL que acabou de copiar.
9. Na barra de menus, escolha depurar > Iniciar Depuração para executar o aplicativo. As informações
do cliente são mostradas.
Agora você tem um aplicativo funcional que exibe uma lista de clientes do serviço NorthwindCustomers.
Se desejar expor dados adicionais por meio do serviço, você pode modificar o Modelo de Dados de
Entidade para incluir tabelas adicionais do banco de dados da Northwind.
Na próxima etapa opcional, você aprenderá a filtrar os dados retornados pelo serviço.

Adicionando recursos de filtragem

Nesta etapa, você personaliza o aplicativo para filtrar os dados pela cidade do cliente.
Para adicionar a filtragem por cidade
1. No Gerenciador de Soluções , abra o menu de atalho do nó Form1.vb ou Form1.cs e escolha Abrir .
2. Adicione um controle TextBox e um controle Button da Caixa de Ferramentas ao formulário.
3. Abra o menu de atalho para o Button controle, escolha Exibir código e, em seguida, adicione o seguinte
código ao Button1_Click manipulador de eventos:

Private Sub Button1_Click(sender As Object, e As EventArgs) Handles Button1.Click

Dim proxy As New northwindEntities _
(New Uri("http://localhost:53161/NorthwindCustomers.svc"))
Dim city As String = TextBox1.Text

If city <> "" Then

Me.CustomersBindingSource.DataSource = From c In _
proxy.Customers Where c.City = city
End If

End Sub
private void Button1_Click(object sender, EventArgs e)
{
ServiceReference1.northwindModel.northwindEntities proxy = new northwindEntities(new
Uri("http://localhost:53161/NorthwindCustomers.svc"));
string city = TextBox1.Text;

if (!string.IsNullOrEmpty(city)) {
this.CustomersBindingSource.DataSource = from c in proxy.Customers where c.City == city;
}

4. No código anterior, substitua http://localhost:53161/NorthwindCustomers.svc pela URL do manipulador

de eventos Form1_Load .
5. Na barra de menus, escolha depurar > Iniciar Depuração para executar o aplicativo.
6. Na caixa de texto, insira Londres e escolha o botão. Somente os clientes de London são exibidos.

Confira também
Serviços do Windows Communication Foundation e WCF Data Services no Visual Studio
Como: Adicionar, atualizar ou remover uma referência do WCF Data Service
Solucionar problemas de referências de serviço
20/11/2021 • 3 minutes to read

Este tópico lista problemas comuns que podem ocorrer quando você está trabalhando com o Windows WCF
(Communication Foundation) ou WCF Data Services referências no Visual Studio.

Erro ao retornar dados de um serviço

Ao retornar um ou de um serviço, você poderá receber uma exceção "A cota de tamanho máximo para
mensagens de entrada DataSet DataTable foi excedida". Por padrão, a propriedade para algumas vinculações é
definida como um valor relativamente pequeno para limitar a exposição a ataques de negação
MaxReceivedMessageSize de serviço. Você pode aumentar esse valor para evitar a exceção. Para obter mais
informações, consulte MaxReceivedMessageSize.
Para corrigir esse erro:
1. No Gerenciador de Soluções , clique duas vezes no arquivoapp.config para abri-lo.
2. Localize MaxReceivedMessageSize a propriedade e altere-a para um valor maior.

Não é possível encontrar um serviço em minha solução

Quando você clica no botão Descobrir na caixa de diálogo Adicionar Referências de Serviço, um ou mais
projetos da Biblioteca de Serviços do WCF na solução não aparecem na lista de serviços. Isso pode ocorrer se
uma Biblioteca de Serviços tiver sido adicionada à solução, mas ainda não tiver sido compilada.
Para corrigir esse erro:
No Gerenciador de Soluções , clique com o botão direito do mouse no projeto da Biblioteca de Serviços
do WCF e clique em Criar .

Erro ao acessar um serviço em uma área de trabalho remota

Quando um usuário acessa um serviço WCF hospedado na Web em uma conexão de área de trabalho remota e
o usuário não tem permissões administrativas, a autenticação NTLM é usada. Se o usuário não tiver permissões
administrativas, o usuário poderá receber a seguinte mensagem de erro: "A solicitação HTTP não está autorizada
com o esquema de autenticação de cliente 'Anônimo'. O header de autenticação recebido do servidor era
'NTLM'."
Para corrigir esse erro:
1. No projeto do site, abra as páginas Propriedades.
2. Na guia Opções de Início, des marque a caixa de seleção Autenticação NTLM.

NOTE
Você deve desativar a autenticação NTLM somente para sites que contêm exclusivamente serviços WCF. A
segurança para serviços WCF é gerenciada por meio da configuração no arquivoweb.config dados. Isso torna a
autenticação NTLM desnecessária.

O nível de acesso para a configuração de classes geradas não tem

nenhum efeito
Definir a opção Nível de acesso para classes geradas na caixa de diálogo Configurar Referências de
Serviço como Interno ou Amigo pode nem sempre funcionar. Embora a opção pareça estar definida na caixa de
diálogo, as classes de suporte resultantes são geradas com um nível de acesso de Public .
Essa é uma limitação conhecida de determinados tipos, como aqueles serializados usando o XmlSerializer .

Erro ao depurar o código do serviço

Ao entrar no código de um serviço WCF do código do cliente, você poderá receber um erro relacionado a
símbolos ausentes. Isso pode ocorrer quando um serviço que fazia parte da solução foi movido ou removido da
solução.
Quando você adiciona pela primeira vez uma referência a um serviço WCF que faz parte da solução atual, uma
dependência de build explícita é adicionada entre o projeto de serviço e o projeto de cliente de serviço. Isso
garante que o cliente sempre acesse binários de serviço atualizados, o que é especialmente importante para
cenários de depuração, como passar do código do cliente para o código de serviço.
Se o projeto de serviço for removido da solução, essa dependência de build explícita será invalidada. Visual
Studio pode mais garantir que o projeto de serviço seja reconstruído conforme necessário.
Para corrigir esse erro, você precisa recriar manualmente o projeto de serviço:
1. No menu Ferramentas , clique em Opções .
2. Na caixa de diálogo Opções, expanda Projetos e Soluções e selecione Geral.
3. Verifique se a caixa de seleção Mostrar configurações de build avançadas está marcada e clique em
OK.
4. Carregue o projeto de serviço WCF.
5. Na caixa de Gerenciador de Configurações de diálogo, depure a configuração da solução Ativa
como Depurar . Para obter mais informações, consulte Como criar e editar configurações.
6. No Gerenciador de Soluções , selecione o projeto de serviço WCF.
7. No menu Criar, clique em Recomar para recriar o projeto de serviço WCF.

WCF Data Services não são exibidos no navegador

Quando ele tenta exibir uma representação XML de dados em um , Internet Explorer pode interpretar os dados
in WCF Data Services RSS feed. Certifique-se de que a opção para exibir feeds RSS está desabilitada.
Para corrigir esse erro, desabilite os feeds RSS:
1. No Internet Explorer, no menu Ferramentas, clique em Opções da Internet.
2. Na guia Conteúdo, na seção Feeds, clique em Configurações .
3. Na caixa de diálogo Configurações feed, des marque a caixa de seleção Ativar exibição de leitura do
feed e clique em OK.
4. Clique em OK para fechar a caixa de diálogo Opções da Internet.

Confira também
Serviços do Windows Communication Foundation e WCF Data Services no Visual Studio
Caixa de diálogo Configurar Referência de Serviço
20/11/2021 • 3 minutes to read

A caixa de diálogo Configurar Referência de Serviço permite que você configure o comportamento dos
Windows WCF (Communication Foundation).
Para acessar a caixa de diálogo Configurar Referência de Serviço, clique com o botão direito do mouse em
uma referência de serviço no Gerenciador de Soluções e escolha Configurar Referência de Ser viço . Você
também pode acessar a caixa de diálogo clicando no botão Avançado na Adicionar Referência de Serviço Caixa
de Diálogo .

Lista de tarefas
Para alterar o endereço em que um serviço WCF está hospedado, insira o novo endereço no campo
Endereço.
Para alterar o nível de acesso para classes em um cliente WCF, selecione uma palavra-chave de nível de
acesso na lista Nível de acesso para classes geradas.
Para chamar os métodos de um serviço WCF de forma assíncrona, marque a caixa de seleção Gerar
operações assíncronas.
Para gerar tipos de contrato de mensagem em um cliente WCF, marque a caixa de seleção Sempre
gerar contratos de mensagem.
Para especificar tipos de coleção de lista ou dicionário para um cliente WCF, selecione os tipos nas listas
Tipo de coleção e Tipo de coleção de dicionário.
Para desabilitar o compartilhamento de tipos, des marque a caixa de seleção Reutilizar tipos em
assemblies referenciados. Para habilitar o compartilhamento de tipos para um subconjunto de
assemblies referenciados, marque a caixa de seleção Reutilizar tipos em assemblies referenciados,
selecione Reutilizar tipos em assemblies referenciados especificados e selecione as referências
desejadas na lista Assemblies referenciados .

Lista de elementos de interface do usuário

Endereço
Atualiza o endereço Web em que uma referência de serviço procura um serviço. Por exemplo, durante o
desenvolvimento, o serviço pode ser hospedado em um servidor de desenvolvimento e, posteriormente,
movido para um servidor de produção, exigindo uma alteração de endereço.

NOTE
O elemento Address não está disponível quando a caixa de diálogo Configurar Referência de Serviço é exibida no
Adicionar Referência de Serviço Caixa de Diálogo .

Nível de acesso para classes geradas

Determina o nível de acesso de código para classes de cliente WCF.
NOTE
Para projetos de site, essa opção sempre é definida como Public e não pode ser alterada. Para obter mais informações,
consulte Solucionando problemas de referências de serviço.

Gerar operações assíncronas

Determina se os métodos de serviço WCF são chamados de forma síncrona (o padrão) ou de forma assíncrona.
Gerar operações baseadas em tarefas
Ao escrever código assíncrono, essa opção permite que você aproveite a TPL (Biblioteca Paralela de Tarefas) que
foi introduzida com o .NET 4. Consulte Biblioteca de Paralelidade de Tarefas (TPL).
Sempre gerar contratos de mensagem
Determina se os tipos de contrato de mensagem são gerados para um cliente WCF. Para obter mais informações
sobre contratos de mensagens, consulte Usando contratos de mensagem.
Tipo de coleção
Especifica o tipo de coleção de lista para um cliente WCF. O tipo padrão é Array.
Tipo de coleção de dicionário
Especifica o tipo de coleção de dicionários para um cliente WCF. O tipo padrão é Dictionary<TKey,TValue>.
Usar novamente os tipos em assemblies consultados
Determina se um cliente WCF tenta reutilizar o que já existe em assemblies referenciados em vez de gerar
novos tipos quando um serviço é adicionado ou atualizado. Por padrão, essa opção é marcada.
Usar novamente os tipos em todos os assemblies consultados
Quando selecionado, todos os tipos na lista Assemblies referenciados serão reutilizados, se possível. Por
padrão, essa opção é selecionada.
Usar novamente os tipos em determinados assemblies consultados
Quando selecionado, somente os tipos selecionados na lista Assemblies referenciados são reutilizados.
Lista de assemblies referenciados
Contém uma lista de assemblies referenciados para o projeto ou site. Ao selecionar Reutilizar tipos em
assemblies referenciados especificados, você pode selecionar ou limpar assemblies individuais.
Adicionar Referência Web
Exibe a caixa de diálogo Adicionar Referência da Web.

NOTE
Essa opção só deve ser usada para projetos destinados à versão 2.0 do .NET Framework.

NOTE
O botão Adicionar Referência da Web só estará disponível quando a caixa de diálogo Configurar Referência de Serviço
for exibida Adicionar Referência de Serviço caixa de diálogo .
Confira também
Como adicionar uma referência a um serviço Web
Serviços do Windows Communication Foundation e WCF Data Services
Como adicionar, atualizar ou remover uma
referência de serviço de dados do WCF
20/11/2021 • 4 minutes to read

Uma referência de serviço permite que um projeto acesse um ou mais WCF Data Services . Use a Adicionar
Referência de Ser viço caixa de diálogo para pesquisar na solução atual, localmente, em uma rede local ou
WCF Data Services na Internet.
Você pode usar o nó Ser viços Conectados no Gerenciador de Soluções para acessar o Microsoft WCF
Web Ser vice Reference Provider , que permite gerenciar referências de serviço de dados do WCF (Windows
Communication Foundation).

Adicionar uma referência de serviço WCF

Para adicionar uma referência a um serviço externo
1. No Gerenciador de Soluções , clique com o botão direito do mouse no nome do projeto ao qual você
deseja adicionar o serviço e clique em Adicionar Referência de Ser viço .
A caixa de diálogo Adicionar Referência de Ser viço é exibida.
2. Na caixa Endereço, insira a URL do serviço e clique em Ir para pesquisar o serviço. Se o serviço
implementar a segurança de nome de usuário e senha, você poderá ser solicitado a solicitar um nome de
usuário e uma senha.

NOTE
Você só deve fazer referência a serviços de uma fonte confiável. A adição de referências de uma fonte não
confiável pode comprometer a segurança.

Você também pode selecionar a URL na lista Endereço, que armazena as 15 URLs anteriores nas quais os
metadados de serviço válidos foram encontrados.
Uma barra de progresso é exibida quando a pesquisa está sendo executada. Você pode interromper a
pesquisa a qualquer momento clicando em Parar .
3. Na lista Ser viços, expanda o nó do serviço que você deseja usar e selecione um conjunto de entidades.
4. Na caixa Namespace , digite o namespace que deseja usar para a referência.
5. Clique em OK para adicionar a referência ao projeto.
Um cliente de serviço (proxy) é gerado e os metadados que descrevem o serviço são adicionados ao
app.config arquivo.
1. No Gerenciador de Soluções , clique duas vezes ou toque no nó Ser viços Conectados.
A guia Configurar Ser viços é aberta.
2. Escolha Microsoft WCF Web Ser vice Reference Provider .
A caixa de diálogo WCF Web Ser vice Reference configuração é exibida.

3. Na caixa URI, insira a URL do serviço e clique em Ir para pesquisar o serviço. Se o serviço implementar a
segurança de nome de usuário e senha, você poderá ser solicitado a solicitar um nome de usuário e uma
senha.

NOTE
Você só deve fazer referência a serviços de uma fonte confiável. A adição de referências de uma fonte não
confiável pode comprometer a segurança.

Você também pode selecionar a URL na lista de URI, que armazena as 15 URLs anteriores nas quais os
metadados de serviço válidos foram encontrados.
Uma barra de progresso é exibida quando a pesquisa está sendo executada. Você pode interromper a
pesquisa a qualquer momento clicando em Parar .
4. Na lista Ser viços, expanda o nó do serviço que você deseja usar e selecione um conjunto de entidades.
5. Na caixa Namespace , digite o namespace que deseja usar para a referência.
6. Clique em Concluir para adicionar a referência ao projeto.
Um cliente de serviço (proxy) é gerado e os metadados que descrevem o serviço são adicionados ao
app.config arquivo.
Para adicionar uma referência a um serviço na solução atual
1. No Gerenciador de Soluções , clique com o botão direito do mouse no nome do projeto ao qual você
deseja adicionar o serviço e clique em Adicionar Referência de Ser viço .
A caixa de diálogo Adicionar Referência de Ser viço é exibida.
2. Clique em Descobrir .
Todos os serviços WCF Data Services (e serviços WCF) na solução atual são adicionados à lista
Ser viços.
3. Na lista Ser viços, expanda o nó do serviço que você deseja usar e selecione um conjunto de entidades.
4. Na caixa Namespace , digite o namespace que deseja usar para a referência.
5. Clique em OK para adicionar a referência ao projeto.
Um cliente de serviço (proxy) gera e os metadados que descrevem o serviço são adicionados ao
arquivoapp.config serviço.
1. No Gerenciador de Soluções , clique duas vezes ou toque no nó Ser viços Conectados.
A guia Configurar Ser viços é aberta.
2. Escolha Microsoft WCF Web Ser vice Reference Provider .
A caixa de diálogo WCF Web Ser vice Reference configuração é exibida.
3. Clique em Descobrir .
Todos os serviços WCF Data Services (e serviços WCF) na solução atual são adicionados à lista
Ser viços.
4. Na lista Ser viços, expanda o nó do serviço que você deseja usar e selecione um conjunto de entidades.
5. Na caixa Namespace , digite o namespace que deseja usar para a referência.
6. Clique em Concluir para adicionar a referência ao projeto.
Um cliente de serviço (proxy) gera e os metadados que descrevem o serviço são adicionados ao
arquivoapp.config serviço.

Atualizar uma referência de serviço

O Modelo de Dados de Entidade para um WCF Data Services às vezes muda. Quando isso acontece, você deve
atualizar a referência de serviço.
Para atualizar uma referência de serviço
No Gerenciador de Soluções , clique com o botão direito do mouse na referência de serviço e clique
em Atualizar Referência de Ser viço .
Uma caixa de diálogo de progresso é exibida enquanto a referência é atualizada de seu local original e o
cliente de serviço é regenerado para refletir as alterações nos metadados.

Remover uma referência de serviço

Se uma referência de serviço não estiver mais sendo usada, você poderá removê-la da solução.
Para remover uma referência de serviço
No Gerenciador de Soluções , clique com o botão direito do mouse na referência de serviço e clique
em Excluir .
O cliente de serviço será removido da solução e os metadados que descrevem o serviço serão removidos
do arquivo app.config serviço.
NOTE
Qualquer código que referencia a referência de serviço deve ser removido manualmente.

Confira também
Windows Serviços do Communication Foundation e serviços de dados WCF Visual Studio
Atualizar arquivos .mdf
20/11/2021 • 4 minutes to read

Este tópico descreve as opções para atualizar um arquivo de banco de dados (.mdf) depois de instalar uma
versão mais recente do Visual Studio. Ele inclui instruções para as seguintes tarefas:
Atualizar um arquivo de banco de dados para usar uma versão mais recente do SQL Server Express
LocalDB
Atualizar um arquivo de banco de dados para usar uma versão mais recente do SQL Server Express
Trabalhar com um arquivo de banco de dados Visual Studio mas manter a compatibilidade com uma
versão mais antiga do SQL Server Express ou LocalDB
Fazer SQL Server Express mecanismo de banco de dados padrão
Você pode usar Visual Studio para abrir um projeto que contém um arquivo de banco de dados (.mdf) que foi
criado usando uma versão mais antiga do SQL Server Express ou LocalDB. No entanto, para continuar a
desenvolver seu projeto no Visual Studio, você deve ter essa versão do SQL Server Express ou LocalDB instalada
no mesmo computador que o Visual Studio ou você deve atualizar o arquivo de banco de dados. Se você
atualizar o arquivo de banco de dados, não poderá acessá-lo usando versões mais antigas do SQL Server
Express ou LocalDB.
Você também poderá ser solicitado a atualizar um arquivo de banco de dados que foi criado por meio de uma
versão anterior do SQL Server Express ou LocalDB se a versão do arquivo não for compatível com a instância do
SQL Server Express ou LocalDB que está instalada no momento. Para resolver o problema, Visual Studio
solicitará que você atualize o arquivo.

IMPORTANT
Recomendamos que você faça o back-up do arquivo de banco de dados antes de atualize-o.

WARNING
Se você atualizar um arquivo .mdf criado no LocalDB 2014 (V12) de 32 bits para o LocalDB 2016 (V13) ou posterior, você
não poderá abrir o arquivo novamente na versão de 32 bits do LocalDB.

Antes de atualizar um banco de dados, considere os seguintes critérios:

Não atualize se quiser trabalhar em seu projeto em uma versão mais antiga e em uma versão mais
recente do Visual Studio.
Não atualize se seu aplicativo for usado em ambientes que usam SQL Server Express em vez de LocalDB.
Não atualize se seu aplicativo usar conexões remotas, porque LocalDB não as aceita.
Não atualize se seu aplicativo depende de Serviços de Informações da Internet (IIS).
Considere atualizar se você quiser testar aplicativos de banco de dados em um ambiente de área
sandbox, mas não quiser administrar um banco de dados.
Para atualizar um arquivo de banco de dados para usar a LocalDB versão
1. No Gerenciador de Ser vidores , selecione o botão Conexão para Banco de Dados.
2. Na caixa de diálogo Adicionar Conexão, especifique as seguintes informações:
Fonte de dados : Microsoft SQL Server (SqlClient)

Nome do Ser vidor :

Para usar a versão padrão: (localdb)\MSSQLLocalDB . Isso especificará ProjectV12 ou
ProjectV13, dependendo de qual versão do Visual Studio está instalada e quando a primeira
instância LocalDB foi criada. O nó MSSQLLocalDB no SQL Ser ver Pesquisador de
Objetos mostra para qual versão ele está apontando.
Para usar uma versão específica: ou , em que (localdb)\ProjectsV12 (localdb)\ProjectsV13
V12 é LocalDB 2014 e V13 é LocalDB 2016.
Anexar um arquivo do banco de dados : O caminho físico da réplica primária mdf arquivo.
Nome lógico : O nome que você deseja usar com o arquivo.
3. Selecione o botão OK .
4. Quando solicitado, selecione o botão Sim para atualizar o arquivo.
O banco de dados é atualizado, está anexado ao mecanismo LocalDB banco de dados e não é mais
compatível com a versão mais antiga do LocalDB.
Você também pode modificar uma conexão SQL Server Express para usar LocalDB abrindo o menu de atalho
para a conexão e, em seguida, selecionando Modificar Conexão . Na caixa de diálogo Modificar Conexão,
altere o nome do servidor para (LocalDB)\MSSQLLocalDB . Na caixa de diálogo Propriedades Avançadas ,
certifique-se de que a Instância de Usuário está definida como False.
Para atualizar um arquivo de banco de dados para usar a SQL Server Express versão
1. No menu de atalho da conexão com o banco de dados, selecione Modificar Conexão .
2. Na caixa de diálogo Modificar Conexão, selecione o botão Avançado.
3. Na caixa de diálogo Propriedades Avançadas, selecione o botão OK sem alterar o nome do servidor.
O arquivo de banco de dados é atualizado para corresponder à versão atual do SQL Server Express.
Para trabalhar com o banco de dados Visual Studio mas manter a compatibilidade com SQL Server Express
No Visual Studio, abra o projeto sem atualá-lo.
Para executar o projeto, selecione a tecla F5.
Para editar o banco de dados, abra o arquivo .mdf no Gerenciador de Soluções e expanda o nó
no Gerenciador de Servidores para trabalhar com seu banco de dados.
Para fazer com que SQL Server Express mecanismo de banco de dados padrão
1. Na barra de menus, selecione Ferramentas > Opções .
2. Na caixa de diálogo Opções, expanda as opções Ferramentas de Banco de Dados e selecione
Conexões de Dados .
3. Na caixa SQL Ser ver nome da instância, especifique o nome da instância do SQL Server Express ou
LocalDB que você deseja usar. Se a instância não for nomeada, especifique
.\SQLEXPRESS or (LocalDB)\MSSQLLocalDB .

4. Selecione o botão OK .
SQL Server Express será o mecanismo de banco de dados padrão para seus aplicativos.
Confira também
Acessando dados no Visual Studio
Métodos de DataContext (Designer de Objeto
Relacional)
20/11/2021 • 4 minutes to read

DataContextmétodos (no contexto do LINQ to SQL Tools no Visual Studio) são métodos da classe que executar
procedimentos armazenados e funções em um banco de DataContext dados.
A classe DataContext é uma classe LINQ to SQL que atua como um conduto entre um banco de dados SQL
Server e as classes de entidade LINQ to SQL mapeadas para o banco de dados. A classe contém as informações
da cadeia de conexão e os métodos para se conectar a um banco de dados e manipular DataContext os dados
no banco de dados. Por padrão, a classe contém vários métodos que você pode chamar, como o método que
envia dados atualizados de DataContext classes para o banco de SubmitChanges LINQ to SQL dados. Você
também pode criar métodos DataContext adicionais que mapeiem para procedimentos armazenados e funções.
Em outras palavras, chamar esses métodos personalizados executa o procedimento armazenado ou a função no
banco de dados para o qual o DataContext método é mapeado. Você pode adicionar novos métodos à classe
DataContext exatamente como adiciona métodos para estender qualquer classe. No entanto, em discussões
sobre métodos no contexto do DataContext Designer O/R, são os métodos que são mapeados para
procedimentos armazenados e funções que estão sendo DataContext discutidos.

Painel Métodos
DataContextmétodos que mapeiam para procedimentos armazenados e funções são exibidos no painel
Métodos do Designer de O/R. O painel Métodos é o painel na lateral direita do painel Entidades (a
superfície de design principal). O painel Métodos lista todos os métodos que você criou usando o Designer
DataContext O/R. Por padrão, o painel Métodos está vazio; arraste procedimentos armazenados ou funções
de Gerenciador de Ser vidores ou Gerenciador de Banco de Dados para o Designer de O/R para criar
métodos e preencher o DataContext painel Métodos. Para obter mais informações, consulte Como criar
métodos DataContext mapeados para procedimentos armazenados e funções (Designer O/R).

NOTE
Abra e feche o painel de métodos clicando com o botão direito do mouse no Designer O/R e clicando em Ocultar Painel
de Métodos ou Mostrar Painel de Métodos ou use o atalho de teclado CTRL + 1 .

Dois tipos de métodos de DataContext

Os métodos de DataContext são os métodos que mapeiam para procedimentos armazenados e funções no
banco de dados. Você pode criar e adicionar métodos DataContext no painel Métodos do Designer O/R. Há
dois tipos distintos de métodos de DataContext; os que retornam um ou vários conjuntos de resultados e os que
não retornam:
DataContext métodos que retornam um ou mais conjuntos de resultados:
Crie esse tipo de método DataContext quando seu aplicativo precisar apenas executar procedimentos
armazenados e funções no banco de dados e retornar os resultados. Para obter mais informações,
consulte Como criar métodos DataContext mapeados para procedimentos armazenados e funções
(Designer O/R),System.Data.Linq.ISingleResult <T> e IMultipleResults .
DataContext métodos que não retornam conjuntos de resultados: como Inserções, Atualizações e
Exclusões para uma classe de entidade específica.
Crie esse tipo de método de DataContext quando seu aplicativo precisar executar procedimentos
armazenados em vez de usar o comportamento padrão do LINQ to SQL para salvar dados modificados
entre uma classe de entidade e o banco de dados. Para obter mais informações, consulte Como atribuir
procedimentos armazenados para executar atualizações, inserções e exclusões (Designer O/R).

Tipos de retorno de métodos de DataContext

Quando você arrasta procedimentos armazenados e funções de Gerenciador de Ser vidores ou
Gerenciador de Banco de Dados para o Designer O/R, o tipo de retorno do método gerado difere
dependendo de onde você solta DataContext o item. Soltar os itens diretamente em uma classe de entidade
existente cria um método com o tipo de retorno da classe de entidade; soltar itens em uma área vazia do
Designer de Objetos (em qualquer painel) cria um método que retorna um tipo gerado DataContext DataContext
automaticamente. O tipo gerado automaticamente tem o nome que corresponde ao procedimento armazenado
ou nome da função e propriedades, que são mapeados para os campos retornados pelo procedimento
armazenado ou função.

NOTE
Você pode alterar o tipo de retorno de um método de DataContext depois de adicioná-lo ao painel de métodos. Para
inspecionar ou alterar o tipo de retorno de um método DataContext, selecione-o e inspecione a propriedade Tipo de
Retorno na janela Propriedades . Para obter mais informações, consulte Como alterar o tipo de retorno de um método
DataContext (Designer O/R).

Os objetos que você arrasta do banco de dados para a superfície do Designer de OBJETOS são nomeados
automaticamente, com base no nome dos objetos no banco de dados. Se você arrastar o mesmo objeto mais de
uma vez, um número será adicionado ao final do novo nome que diferencia os nomes. Quando os nomes dos
objetos do banco de dados contêm espaços ou caracteres, que não são suportados no Visual Basic ou no C#, o
espaço ou o caractere inválido é substituído por um sublinhado.

Confira também
LINQ to SQL ferramentas no Visual Studio
LINQ to SQL
Procedimentos armazenados
Como criar métodos DataContext mapeados para procedimentos armazenados e funções (Designer
Relacional de Objetos)
Como atribuir procedimentos armazenados para executar atualizações, inserções e exclusões (Designer
Relacional de Objetos)
Passo a passo: personalizando a inserção, a atualização e o comportamento de exclusão de classes de
entidade
Passo a passo: criando classes LINQ to SQL (Designer Relacional de Objetos)
Herança de classe de dados (Designer Relacional de
Objetos)
20/11/2021 • 2 minutes to read

Assim como outros objetos, LINQ to SQL classes podem usar herança e ser derivadas de outras classes. Em
código, você pode especificar relações de herança entre objetos declarando uma classe que herda de outra. Em
uma base de dados, as relações de herança são criadas de várias maneiras. O Object Relational Designer
(Designer O/R ) dá suporte ao conceito de herança de tabela única, pois geralmente é implementado em
sistemas relacionais.
A herança de tabela única, há uma única tabela de base de dados que contém colunas para ambos base e
classes derivadas. Com dados relacionais, uma coluna de discriminador contém o valor que determina qual
classe qualquer determinado registro pertence. Por exemplo, considere uma Persons tabela que contém todos
os funcionários de uma empresa. Algumas pessoas são funcionários e algumas pessoas são gerentes. A tabela
contém uma coluna chamada que tem um valor de 1 para gerentes e um Persons valor de Type 2 para
funcionários. A Type coluna é a coluna discriminadora. Nesse cenário, você pode criar uma subclasse de
funcionários e preencher a classe com apenas registros que têm Type um valor de 2.
Quando você configura a herança na classe entidade usando Designer Relacional de Objetos, arraste a única
tabela que contém os dados de herança no designer duas vezes: uma vez para cada classe na hierarquia de
herança. Após adicionar tabelas ao designer, conectar-las com um item de herança da caixa de ferramentas de
Object Relational Designer e então defina as quatro propriedades de herança na janela Propriedades .

Propriedades de herança
A seguinte tabela lista as propriedades de herança e suas descrições:

P RO P RIEDA DE DESC RIÇ Ã O

Propriedade Discriminatória A propriedade (mapeado para a coluna) que determina qual

classe ao registro atual pertence.

Valor Discriminador de Classe Base O valor (na coluna designada como a propriedade
Discriminator ) que determina que um registro é da classe
base.

Valor Discriminatório da Classe Derivada O valor (na propriedade designada como a propriedade
Discriminator ) que determina que um registro é da classe
derivada.

Padrão de Herança A classe que é populada quando o valor na propriedade

designada como a Propriedade Discriminator não
corresponder ao Valor Discriminador da Classe Base ou ao
Valor Discriminador de Classe Derivada .

Criar um modelo de objeto que usar herança e corresponde a dados relacionais pode ser um pouco confuso.
Este tópico fornece informações sobre os conceitos básicos e as propriedades individuais que são necessários
configurando a herança. Os tópicos a seguir fornecem uma explicação mais clara de como configurar a herança
com o Designer de O/R.
TÓ P IC O DESC RIÇ Ã O

Como configurar a herança usando o Designer Relacional de Descreve como configurar classes de entidade que usam
Objetos herança de tabela única usando o Designer O/R.

Passo a passo: criando LINQ to SQL classes usando herança Fornece instruções passo a passo sobre como configurar
de tabela única (Designer O/R) classes de entidade que usam herança de tabela única
usando o Designer O/R.

Confira também
LINQ to SQL ferramentas no Visual Studio
Passo a passo: criando classes LINQ to SQL (Designer Relacional de Objetos)
Passo a passo: criando LINQ to SQL classes usando herança de tabela única (Designer O/R)
Guia de Introdução
A classe selecionada não pode ser excluída porque
é usada como um tipo de retorno para um ou mais
métodos DataContext
20/11/2021 • 2 minutes to read

O tipo de retorno de um ou mais métodos de DataContext é a classe de entidade selecionada. A exclusão de

uma classe de entidade usada como o tipo de retorno para um método faz com que a DataContext compilação
do projeto falhe. Para excluir a classe selecionada de entidade, identifica os métodos de DataContext que a usam
e definem seus tipos de retorno para uma classe diferente de entidade.
Para reverter os tipos de retorno de métodos de DataContext para seus tipos gerados automaticamente de
original, primeiro excluir o método de DataContext do painel Métodos e arraste então o objeto de
Gerenciador de Ser vidores /Gerenciador de Banco de Dados no Designer Relacional de Objetos
novamente.

Para corrigir este erro

1. Identifica os métodos de DataContext que usam a classe de entidade como um tipo de retorno
selecionando um método de DataContext no painel Métodos e inspecionando a propriedade de Tipo de
Retorno na janela Propriedades .
2. Definir Tipo de Retorno a uma classe diferente de entidade ou exclui o método de DataContext do
painel métodos.

Confira também
LINQ to SQL ferramentas no Visual Studio
A cadeia de conexão contém credenciais com uma
senha de texto não criptografado e não estiver
usando segurança integrada
20/11/2021 • 2 minutes to read

Deseja salvar a cadeia de conexão no arquivo DBML atual e nos arquivos de configuração do aplicativo com
essas informações confidenciais? Clique em Não para salvar a cadeia de conexão sem as informações
confidenciais.
Ao trabalhar com conexões de dados que incluem informações confidenciais (senhas que são incluídas na
cadeia de conexão), você tem a opção de salvar a cadeia de conexão no arquivo DBML de um projeto e o
arquivo de configuração do aplicativo com ou sem informações sigilosas.

WARNING
Explicitamente definindo a propriedade de Configurações do Aplicativo propriedades de Conexão a False adicionará
a senha para o arquivo DBML.

Opções de salvamento
Para salvar a cadeia de conexão com as informações confidenciais, escolha Sim.
A cadeia de conexão é armazenada como uma configuração de aplicativo. A cadeia de conexão inclui
informações sigilosas em texto sem formatação. O arquivo DBML não contém informações sigilosas.
Para salvar a cadeia de conexão sem as informações confidenciais, escolha Não .
A cadeia de conexão é armazenada como uma configuração de aplicativo, mas a senha não é incluído.

Confira também
LINQ to SQL ferramentas no Visual Studio
A propriedade <nome da propriedade> não pode
ser excluída porque está participando da associação
<nome da associação>
20/11/2021 • 2 minutes to read

A propriedade selecionada é definida como Propriedade de associação para a associação entre as classes
mencionadas na mensagem de erro. Propriedades não podem ser excluídas estão participando em uma
associação entre classes de dados.
Defina Propriedade de Associação para uma propriedade diferente da classe de dados para permitir que a
propriedade desejada seja excluída com êxito.

Para corrigir este erro

1. Selecione a linha de associação no Designer O/R que conecta as classes de dados indicadas na
mensagem de erro.
2. Clique duas vezes na linha para abrir a caixa de diálogo Editor de Associação .
3. Remova a propriedade de Propriedades de Associação .
4. Tente excluir novamente a propriedade.

Confira também
LINQ to SQL ferramentas no Visual Studio
A propriedade <property name> não pode ser
excluída
20/11/2021 • 2 minutes to read

A propriedade não pode ser excluída porque está definida como a propriedade <property name>
Discriminator para a herança entre <class name> e <class name>
A propriedade selecionada está definida como a propriedade discriminatória para herança entre as classes
mencionadas na mensagem de erro. Propriedades não podem ser excluídas estão participando na configuração
de herança entre classes de dados.
Defina a propriedade discriminatória para uma propriedade diferente da classe de dados para permitir que
a propriedade desejada seja excluída com êxito.

Para corrigir este erro

1. No Designer de O/R, selecione a linha de herança que conecta as classes de dados indicadas na
mensagem de erro.
2. Defina a propriedade discriminatória para uma propriedade diferente.
3. Tente excluir novamente a propriedade.

Confira também
LINQ to SQL ferramentas no Visual Studio
A propriedade de conexão no arquivo de
configurações do aplicativo está ausente ou
incorreta
20/11/2021 • 2 minutes to read

A propriedade de conexão no arquivo de Configurações de Aplicativo está ausente ou incorreta. A cadeia de

conexão no arquivo .dbml foi usada em seu lugar.
O arquivo .dbml contém uma referência a uma cadeia de conexão nas configurações do aplicativo arquivos que
não podem ser encontradas. Essa mensagem é informativa; a configuração da cadeia de conexão será criada
quando OK é clicado.
Para responder a essa mensagem, selecione OK . As informações de conexão contidas no arquivo . dbml são
adicionadas às configurações do aplicativo.

Confira também
ferramentas de LINQ to SQL no Visual Studio
Não é possível criar uma associação <nome da
associação> – os tipos de propriedade não
correspondem
20/11/2021 • 2 minutes to read

Não é possível criar uma <association name> associação – os tipos de propriedade não são match. As
propriedades não têm tipos correspondentes: <property names> .
Associações são definidas pelas Propriedades de Associação , selecionadas na caixa de diálogo Editor de
Associação . As propriedades em cada lado de associação devem ser do mesmo tipo de dados.
As propriedades listadas na mensagem não têm os mesmos tipos de dados.

Para corrigir este erro

1. Examine a mensagem e observe as propriedades chamadas na mensagem.
2. Clique OK para descartar a caixa de diálogo.
3. Inspecione Propriedades de Associação e selecione propriedades do mesmo tipo de dados.
4. Clique em OK .

Confira também
LINQ to SQL ferramentas no Visual Studio
Como criar uma associação entre classes LINQ to SQL (Designer O/R)
Aviso: foram feitas alterações na caixa de diálogo
comportamento de configuração que não foram
aplicadas
20/11/2021 • 2 minutes to read

Aviso. As alterações foram feitas à caixa de diálogo configurar o comportamento que não foram aplicadas. Você
deseja aplicar as alterações?
A caixa de diálogo Configurar compor tamento permite configurar Insert , Update e o Delete
comportamento de todas as classes disponíveis. Esta mensagem aparece quando você seleciona uma nova
combinação de Classe e Compor tamento e a alteração anterior ainda não foi aplicada.

Alterar as opções
Para aplicar a alteração e continuar, clique em Sim . A alteração é aplicada à classe e ao
compor tamento selecionados.
Para cancelar a alteração anterior e continuar, clique em não .

Confira também
ferramentas de LINQ to SQL no Visual Studio
Você tiver selecionado um objeto de base de dados
de um provedor de base de dados sem suporte
20/11/2021 • 2 minutes to read

O Designer de O/R dá suporte apenas ao .NET Framework Provedor de Dados para SQL Server (
System.Data.SqlClient ). Embora você possa clicar em OK e continuar trabalhando com objetos de provedores
de banco de dados sem suporte, você pode enfrentar um comportamento inesperado em tempo de execução.

NOTE
Somente as conexões de dados que usam o provedor de dados. NET Framework para SQL Server são suportadas.

Opções
Clique em OK para continuar a criar as classes de entidade que mapeiam para a conexão que usa o
provedor de banco de dados sem suporte. Você pode apresentar comportamento inesperado quando
você usa provedores de base de dados sem suporte.
Clique em Cancelar para interromper a ação. Crie ou use uma conexão de dados diferente que usa o
provedor .NET Framework para SQL Server.

Confira também
LINQ to SQL ferramentas no Visual Studio
Este método relacionado é o método de suporte
para a seguir inserção, atualização, ou métodos
padrão de exclusão
20/11/2021 • 2 minutes to read

Esse método relacionado é o método de backup para os seguintes Insert métodos padrão, Update ou Delete
. Se ele for excluído, esses métodos também serão excluídos. Deseja continuar?
O DataContext método selecionado é usado atualmente como um dos Insert métodos, Update ou Delete
para uma das classes de entidade no designer do o /R . A exclusão do método selecionado faz com que a classe
de entidade que estava usando esse método reverta para o comportamento de tempo de execução padrão para
executar INSERT, Update ou Delete durante uma atualização.

Opções do método selecionado

Para excluir o método selecionado, fazendo com que a classe de entidade use atualizações de tempo de
execução, clique em Sim .
o método selecionado é excluído e todas as classes que usaram esse método para substituir o
comportamento de atualização são revertidas para usar o comportamento padrão de tempo de execução
de LINQ to SQL.
Para fechar a caixa de mensagem, deixando o método selecionado inalterado, clique em não .
A caixa de mensagem fecha e nenhuma alteração é feita.

Confira também
ferramentas de LINQ to SQL no Visual Studio
Um ou mais itens selecionados contêm um tipo de
dados que não é suportado pelo designer
20/11/2021 • 2 minutes to read

Um ou mais dos itens arrastados do Gerenciador de Ser vidores ou Gerenciador de Banco de Dados para
o Designer O/R contém um tipo de dados que não tem suporte do Designer O/R, por exemplo, tipos
CLRdefinidos pelo usuário .

Para corrigir este erro

1. Criar uma exibição que são baseadas na tabela desejada e que não inclui o tipo de dados sem suporte.
2. Arraste a exibição de Gerenciador de Ser vidores ou Gerenciador de Banco de Dados para o
designer.

Confira também
LINQ to SQL ferramentas no Visual Studio
Altere o tipo de retorno de um método
DataContext não pode ser desfeito
20/11/2021 • 2 minutes to read

A alteração do tipo retornado por um método DataContext não pode ser desfeita. Para reverter de volta para o
tipo gerado automaticamente, você deve arraste o item do Gerenciador de Ser vidores ou Gerenciador de
Banco de Dados no Designer Relacional de Objetos novamente. Tem certeza de que deseja alterar o tipo
retornado?
O tipo de retorno de um método de DataContext diferem dependendo de onde você ignora o item em Designer
Relacional de Objetos. Se você soltar um item diretamente em uma classe existente de entidade, um método de
DataContext que tem o tipo de retorno de classe de entidade é criado. Se você soltar um item em uma área
vazia de Designer Relacional de Objetos, um método de DataContext que retorna um tipo gerado
automaticamente é criado. Você pode alterar o tipo de retorno de um método de DataContext depois de
adicioná-lo ao painel de métodos. Verificar ou altere o tipo de retorno de um método de DataContext, selecione-
o e clique na propriedade de Tipo de Retorno na janela Propriedades .

Para alterar o tipo de retorno de um DataContext

Clique em Sim .

Para sair da caixa de mensagem e deixar o tipo de retorno inalterado

Clique em Não .

Para reverter para o tipo de retorno original após alterar o tipo de

retorno
1. Selecione o método DataContext em Designer Relacional de Objetos e exclua-o.
2. Localize o item em Gerenciador de Ser vidores/Gerenciador de Banco de Dados e arraste-o até
Designer Relacional de Objetos.
Um método de DataContext é criado com o tipo de retorno padrão original.

Confira também
ferramentas de LINQ to SQL no Visual Studio
O designer não pode ser alterado para depuração
20/11/2021 • 2 minutes to read

Esta mensagem aparece quando é feita uma tentativa de modificar itens no Designer Relacional de Objetos
enquanto o aplicativo está sendo executado no modo de depuração. Quando o aplicativo está em execução no
modo de depuração, o Designer de O/R é somente leitura.
Para corrigir esse erro, selecione Parar Depuração no menu Depurar. O aplicativo interrompe a depuração e
você pode modificar itens no Designer de Objetos.

Confira também
LINQ to SQL ferramentas no Visual Studio
A conexão selecionada usa um provedor de base de
dados sem suporte
20/11/2021 • 2 minutes to read

Essa mensagem aparece quando você arrasta itens que não usam o .NET Framework Provedor de Dados para
SQL Server do Gerenciador de Ser vidores ou Gerenciador de Banco de Dados para as ferramentas
LINQ to SQL no Visual Studio.
O Designer de O/R dá suporte apenas a conexões de dados que usam o provedor .NET Framework para SQL
Server. Somente as conexões a Microsoft SQL Server ou o Arquivo base de dados do Microsoft SQL Server são
válidos.
Para corrigir esse erro, adicione apenas itens de conexões de dados que usam o .NET Framework Provedor de
Dados para SQL Server ao Designer de Objetos.

Confira também
System.Data.SqlClient
LINQ to SQL ferramentas no Visual Studio
Os objetos que você está adicionando ao designer
usam uma conexão de dados diferente do designer
20/11/2021 • 2 minutes to read

Os objetos que você está adicionando ao designer usam uma conexão de dados diferente da que o designer
está usando no momento. Deseja substituir a conexão usada pelo designer?
Quando você adiciona itens ao Object Relational Designer (Designer de Objetos), todos os itens usam
uma conexão de dados compartilhada. (A superfície de design representa DataContext o , que usa uma única
conexão para todos os objetos na superfície.) Se você adicionar um objeto ao designer que usa uma conexão de
dados diferente da conexão de dados que está sendo usada no momento pelo designer, essa mensagem será
exibida. Para resolver esse erro, você pode escolher para manter a conexão existente. Se você fizer essa opção, o
objeto selecionado não será adicionado. Como alternativa, você pode escolher para adicionar o objeto e para
redefinir a conexão de DataContext para a nova conexão.

Opções de conexão
Para substituir a conexão existente pela conexão usada pelo objeto selecionado, clique em Sim.
O objeto selecionado é adicionado ao Designer O/R e DataContext.Connection é definido como a nova
conexão.

NOTE
Se você clicar em Sim , todas as classes de entidade no Designer de So/R serão mapeadas para a nova conexão.

Para continuar a usar a conexão existente e cancelar a adição do objeto selecionado, clique em Não.
A ação é cancelada. O DataContext.Connection permanece definido como a conexão existente.

Confira também
LINQ to SQL ferramentas no Visual Studio
Não é possível criar uma associação <nome da
associação> – propriedade listada duas vezes
20/11/2021 • 2 minutes to read

Não é possível criar uma associação <association name> . A mesma propriedade é listada mais de uma vez:
<property name> .
Associações são definidas pelas Propriedades de Associação , selecionadas na caixa de diálogo Editor de
Associação . As propriedades podem ser listadas apenas uma vez para cada classe na associação.
A propriedade na mensagem aparece mais de uma vez na classe pai ou filho das Propriedades de
Associação .

Para resolver essa condição

Examine a mensagem e observe a propriedade especificada na mensagem.
Clique em OK para descartar a caixa de mensagem.
Inspecione Propriedades de Associação e remova as entradas duplicadas.
Clique em OK .

Confira também
LINQ to SQL ferramentas no Visual Studio
Como criar uma associação entre classes LINQ to SQL (Designer O/R)
Não foi possível recuperar informações de esquema
para o objeto de banco de dados <object name>
20/11/2021 • 2 minutes to read

Esta mensagem aparece normalmente quando um objeto no Gerenciador de Ser vidores /Gerenciador de
Banco de Dados é copiado para a área de transferência, excluído do banco de dados e colado no designer.
Porque o objeto de base de dados não existir, esta mensagem aparece.

Confira também
LINQ to SQL ferramentas no Visual Studio
Um ou mais objetos de base de dados selecionado
retornam um esquema que não corresponde ao
esquema de classe de destino
20/11/2021 • 2 minutes to read

Um ou mais objetos de base de dados selecionado retornam um esquema que não corresponde ao esquema de
classe de destino. Nada foi adicionado ao designer.
Quando você arrastar objetos de base de dados existentes em classes de entidade, os dados retornados pelo
objeto base de dados devem coincidir com o esquema de classe de entidade de destino. Verifique se o objeto de
base de dados correto é selecionado e que a classe correta de entidade está sendo destino atual.

Para corrigir este erro

1. Clique OK para descartar a caixa de diálogo.
2. Selecione um objeto de banco de dados que retorna os dados que correspondem ao esquema de classe
de destino (a classe para a qual o objeto de banco de dados está sendo arrastado no Designer
Relacional de Objetos ).

Confira também
LINQ to SQL ferramentas no Visual Studio

Manual C#

Enviado por

Manual C#

Enviado por

Contents

Configurar o banco de dados de exemplo

Criar os formulários e adicionar controles

C O N T RO L ES PA RA O F O RM UL Á RIO DE N AVEGA Ç Ã O P RO P RIEDA DES

Botão Nome = btnGoToAdd

Botão Nome = btnGoToFillOrCancel

Botão Nome = btnExit

TextBox Name = txtCustomerName

TextBox Nome = txtCustomerID

Botão Nome = btnCreateAccount

DateTimePicker Formato = Curto

Botão Nome = btnPlaceOrder

Botão Nome = btnAddAnotherAccount

Botão Nome = btnAddFinish

TextBox Nome = txtOrderID

Botão Nome = btnFindByOrderID

DateTimePicker Formato = Curto

DataGridView Nome = dgvCustomerOrders

Botão Nome = btnCancelOrder

Botão Nome = btnFillOrder

Botão Nome = btnFinishUpdates

Armazenar a cadeia de conexão

Escrever o código para os formulários

' Verify that CustomerID is present.

' Verify that order amount isn't 0.

// Add the output parameter.

// Run the stored procedure.

// Customer ID is an IDENTITY value from the database.

// Put the Customer ID value into the read-only text box.

// Add the @OrderDate input parameter.

// Add the @Amount order amount input parameter.

// Add the @Status order status input parameter.

// Run the stored procedure.

// Display the order number.

' Ensure a customer name has been entered.

' Create the SqlConnection object.

' Add the customer ID output parameter.

' Run the stored procedure.

' Convert the Customer ID value to an Integer.

' Insert the customer ID into the corresponding text box.

' Create the connection.

' Create SqlCommand and identify it as a stored procedure.

' Add the @OrderDate parameter.

' Add the @Amount parameter.

' Run the stored procedure.

' Display the order number.

// Check for characters other than integers.

' Storage for OrderID.

' Check for input in the Order ID text box.

' Check for characters other than integers.

// Create a SqlCommand object.

// Run the query by calling ExecuteReader().

// Load the data from SqlDataReader into the data table.

// Close the SqlDataReader.

// Add the order ID input parameter for the stored procedure.

// Run the command to execute the stored procedure.

// Add the order ID input parameter for the stored procedure.

// Execute the stored procedure.

' Prepare the connection and the command.

' Create the connection.

' Create a SqlCommand object.

' Define the @orderID parameter and its value.

' Execute the query.

' Create a data table to hold the retrieved data.

' Close the SqlDataReader.

' Set up and run stored procedure only if OrderID is valid.

' Create the connection.

' Create command and identify it as a stored procedure.

' Add input parameter for the stored procedure.

' Add second input parameter.

' Run the SqlCommand.

' Create the connection.

' Create the command and identify it as a stored procedure.

' Add input parameter for the stored procedure.

' Run the SqlCommand.

Instalar e conectar-se ao Northwind