Visualstudio Data Tools vs 2022

Dê a sua opinião sobre a experiência de download do PDF.
Trabalhar com dados no Visual Studio

Artigo • 23/01/2025
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 se fizesse 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 associar dados à interface do usuário. O 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 Armazenamento do Azure.
Usando do Visual Studio Connected Services, você pode simplificar o processo de

adição de suporte de banco de dados aos seus projetos.
Para cenários do SQL Server, há suporte por meio dos Serviços Conectados:
SQL Server local. Nesse cenário, você instala o SQL Server em algum lugar da rede
local e se conecta a ele.
SQL Server em seu computador local. Nesse cenário, você instala o SQL Server em
seu computador local e se conecta a ele.
SQL Server Express LocalDB. Você não instala nada além do Visual Studio; você
simplesmente se conecta a ele.
SQL Server Express LocalDB no Contêiner. LocalDB como na opção anterior, mas
dentro de um contêiner local.
Banco de Dados SQL do Azure. Conecte-se ao serviço em execução ao vivo no
Azure.
Para outras tecnologias relacionadas a dados, o Visual Studio 2022 dá suporte ao

seguinte:
Armazenamento do Azure (local e remoto)

Azure Cosmos DB (local e remoto)
SQLite (opção somente local)
PostgreSQL no contêiner (opção somente local)
MongoDB no contêiner (opção somente local)
Além dos Serviços Conectados, as listas a seguir mostram apenas alguns dos vários
sistemas de banco de dados e armazenamento que podem ser usados do Visual Studio.
As ofertas 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 permite que você trabalhe
com armazenamentos de dados do Azure diretamente do Visual Studio.
A maioria dos outros produtos de banco de dados SQL e NoSQL listados aqui pode ser
hospedada em um computador local, em uma rede local ou no Microsoft Azure em uma
máquina virtual. Se você hospedar o banco de dados em uma máquina virtual do
Microsoft Azure, será responsável pelo gerenciamento do próprio banco de dados.
Microsoft Azure
SQL Data Warehouse

Banco de Dados Stretch do SQL Server
StorSimple
E mais...
SQL
Firebird
MariaDB
MySQL
Oráculo
E mais...
NoSQL
Apache Cassandra
CouchDB
MongoDB
NDatabase
OrientDB|
RavenDB
VelocityDB
E mais...
７ Observação
O suporte estendido para o SQL Server 2005 terminou em 12 de abril de 2016. Não
há garantia de que as ferramentas de dados no Visual Studio 2015 e posterior
continuarão a funcionar com o SQL Server 2005.
Idiomas do .NET
A tecnologia de acesso a dados descrita na documentação do Visual Studio usa
ADO.NET. ADO.NET é uma estrutura de acesso a dados herdada e não é recomendada
para aplicativos de dados modernos. Recomendamos direcionar o .NET Core ou o .NET
5 e versões posteriores e usar Entity Framework Core para desenvolvimento de acesso a
dados.
ADO.NET é um conjunto de classes que define uma interface para acessar qualquer tipo
de fonte de dados, relacional e não relacional. O Visual Studio tem várias ferramentas e
designers que trabalham com 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 com
os objetos de comando ADO.NET. Para obter mais informações sobre como chamar as
APIs de ADO.NET diretamente, consulte ADO.NET.
Para obter a documentação de acesso a dados relacionada ao ASP.NET, consulte

Trabalhando com Dados no site ASP.NET. Para obter um tutorial sobre como usar o
Entity Framework com ASP.NET Model-View-Controller (MVC), consulte Introdução ao
Entity Framework 6 Code First usando o MVC 5.
Aplicativos da Plataforma Universal do Windows (UWP) em C# ou Visual Basic podem

usar o SDK do Microsoft Azure para .NET para acessar o Armazenamento do Azure e
outros serviços do Azure. A classe Windows.Web.HttpClient habilita a comunicação com
qualquer serviço RESTful. Para obter mais informações, consulte Como se conectar a um
servidor HTTP usando oWindows.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 o Entity
Framework. Para mais informações, confira Acesso a dados.
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 em 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 provedores de dados ADO.NET para produtos do SQL
Server, bem como provedores ODBC e OLE DB.
７ Observação
Se você estiver usando o Visual Studio para se conectar a bancos de dados usando
provedores de dados OLEDB ou ODBC, precisará estar ciente de que as versões do
Visual Studio antes do 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 você estiver usando o Visual Studio 2022 para se conectar a bancos de dados,
precisará estar ciente de que o 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 Conjunto de Dados, 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 foi um processo de 32 bits foi o 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 ACE (Mecanismo de Conectividade de Acesso). Confira
Provedor OLE DB para Jet e Driver ODBC são versões exclusivas de 32 bits 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 em relação a dados relacionais como objetos .NET de primeira classe.
Para novos aplicativos, 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 mapeador 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: o mais antigo 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 logicamente se
assemelham a objetos do Banco de Dados SQL muito mais do que objetos .NET.
Para aplicativos relativamente simples com base em fontes de dados SQL, 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 em um
objeto de coleção, como List<T>.
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, o OLE DB será necessário e, para isso, você usará o do 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 funcionalidade personalizada que não pode ser
acessada por meio da interface ODBC. O OLE DB é uma tecnologia herdada de acesso a
dados COM que ainda tem suporte, mas não é recomendada para novos aplicativos.
Para obter mais informações, consulte Data Access no Visual C++.
Os programas C++ que consomem serviços REST podem usar o SDK REST do C++ .
Modelagem de dados — o Visual Studio não fornece uma camada ORM para C++.
ODB é um ORM de software livre popular para C++.
Para saber mais sobre como se conectar a bancos de dados de aplicativos em C++,
consulte ferramentas de dados do Visual Studio para C++.
JavaScript
JavaScript no Visual Studio é uma linguagem de primeira classe para a criação de
aplicativos multiplataforma, aplicativos UWP, serviços de nuvem, sites e aplicativos Web.
Você pode usar Bower, Grunt, Gulp, npm e NuGet de dentro do Visual Studio para
instalar suas bibliotecas JavaScript e produtos de banco de dados favoritos. Conecte-se
ao Armazenamento do Microsoft Azure e aos serviços baixando SDKs do site do
Azure . Edge.js é uma biblioteca que conecta o JavaScript do lado do servidor
(Node.js) a fontes de dados ADO.NET.
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 aos dados,
incluindo o seguinte:
Django e Banco de Dados SQL no Azure

Django e MySQL no Azure
Trabalhe com blobs, arquivos , filas de e tabelas de (Cosmo DB).
Conteúdo relacionado
o Microsoft Azure Storage— 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 conectar-se ao Banco de Dados SQL
do Azure, um banco de dados relacional como 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.
ADO.NET— Descreve a arquitetura ADO.NET e como usar as classes ADO.NET para

gerenciar dados do aplicativo e interagir com fontes de dados e XML.
ADO.NET Entity Framework— descreve como criar aplicativos de dados que permitem
que os desenvolvedores programem em relação a um modelo conceitual, em vez de
diretamente em um banco de dados relacional.
WCF Data Services 4.5— descreve como usar os Serviços de Dados do WCF para
implantar serviços de dados na Web ou em uma intranet que implemente o OData
(Open Data Protocol) .
Dados em Soluções do Office – contém links para tópicos que explicam como os dados
funcionam nas soluções do Office. Isso inclui informações sobre programação orientada
a esquema, cache de dados e acesso a dados do lado do servidor.
LINQ (Consulta Integrada à Linguagem)— descreve os recursos de consulta integrados

ao C# e ao Visual Basic e o modelo comum para consultar bancos de dados relacionais,
documentos XML, conjuntos de dados e coleções na memória.
Ferramentas XML no Visual Studio – discute o trabalho com dados XML, a depuração de
XSLT, os recursos do XML do .NET e a arquitetura da consulta XML.
documentos e dados XML— apresenta uma visão geral de um conjunto abrangente e

integrado de classes que trabalham com documentos e dados XML na plataforma .NET.
Comentários
Esta página foi útil?  Yes  No
Fornecer comentários sobre o produto | Pergunte à comunidade

Criar um aplicativo de dados simples
usando o ADO.NET
Artigo • 25/09/2024
７ Observação
Os conjuntos de dados e as classes relacionadas são tecnologias herdadas do .NET

Framework do início dos anos 2000 que permitem que os aplicativos trabalhem
com dados na memória enquanto os aplicativos estão desconectados do banco de
dados. As tecnologias são bastante úteis em aplicativos que permitem que os
usuários modifiquem dados e persistam as alterações no banco de dados. Embora
os conjuntos de dados tenham se mostrado uma tecnologia muito bem-sucedida,
é recomendado que os novos aplicativos .NET usem o Entity Framework Core. O
Entity Framework proporciona uma forma mais natural de trabalhar com dados
tabulares como modelos de objeto e conta com uma interface de programação
mais simples.
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 Windows Forms "formulários sobre dados"
usando 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 rapidamente obter dados de um banco
de dados. Se seu aplicativo precisar modificar os 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.
） Importante
Para manter o código simples, ele não inclui o tratamento de exceção pronto para
produção.
７ Observação
O código completo deste tutorial pode ser acessado no repositório GitHub de
documentos do Visual Studio em C# e Visual Basic .
Pré-requisitos
Para criar o aplicativo, você precisará de:
Visual Studio com as cargas de trabalho do desenvolvimento do .NET para

desktop e do armazenamento e processamento de dados instaladas. Para instalá-
las, abra Instalador do Visual Studio e escolha Modificar (ou Mais>Modificar) ao
lado da versão do Visual Studio que você deseja modificar.
LocalDB do SQL Server Express. Se você não tiver SQL Server Express LocalDB,
poderá instalá-lo na página de download do SQL Server .
Este tópico pressupõe que você esteja familiarizado com a funcionalidade básica do IDE
do Visual Studio e possa criar um aplicativo 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 conclua o tutorial Criar um aplicativo Windows Forms no Visual Studio
com o Visual Basic ou o tutorial Criar um aplicativo Windows Forms no Visual Studio
com 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 janela Gerenciador de Servidores.
2. Clique com o botão direito do mouse em Conexões de Dados e escolha Criar

Banco de Dados SQL Server.
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 escolha OK.
O banco de dados de Vendas 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 de Vendas e selecione

Nova Consulta.
Uma janela do editor de consultas vai se abrir.

6. Copie o script Transact-SQL de Vendas para a sua área de transferência.
7. Cole o script T-SQL no editor de consultas e escolha o botão Executar.
Após um curto período de tempo, a consulta termina de ser executada e os

objetos do banco de dados são criados. O banco de dados contém duas tabelas:
Cliente e Pedidos. Inicialmente, essas tabelas não contêm dados, mas você pode
adicionar dados ao executar o aplicativo que você criará. O banco de dados
também contém quatro procedimentos armazenados simples.
Criar os formulários e adicionar controles

1. Crie um projeto C# ou Visual Basic usando o modelo do Windows Forms App
(.NET Framework) e nomeie-o SimpleDataApp.
O Visual Studio cria o projeto e vários arquivos, incluindo um formulário vazio do

Windows chamado Form1.
2. Adicione dois formulários do Windows ao seu projeto para que ele tenha três
formulários e 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, defina as propriedades que
as tabelas descrevem.
７ Observação
A caixa de grupo e os controles de rótulo adicionam clareza, mas não são

usados no código.
Formulário Navegação
ﾉ Expandir a tabela
Controles para o formulário Navegação Propriedades
Botão Nome = btnGoToAdd
Botão Nome = btnGoToFillOrCancel
Botão Nome = btnExit
Formulário NewCustomer
Controles para o formulário NewCustomer Propriedades
TextBox Nome = txtCustomerName

Controles para o formulário NewCustomer Propriedades
TextBox Nome = txtCustomerID
ReadOnly = True
Botão Nome = btnCreateAccount
NumericUpdown DecimalPlaces = 0
Máximo = 5.000
Nome = numOrderAmount
DateTimePicker Formato = Curto
Nome = dtpOrderDate
Botão Nome = btnPlaceOrder
Botão Nome = btnAddAnotherAccount
Botão Nome = btnAddFinish
Formulário FillOrCancel
Controles para o formulário FillOrCancel Propriedades
TextBox Nome = txtOrderID

Controles para o formulário FillOrCancel Propriedades
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 de Vendas no Gerenciador de Servidores e escolhendo
Propriedades. Localize a propriedade ConnectionString e 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 Settings.settings. Se você estiver
usando o Visual Basic, no Gerenciador de Soluções, clique em Mostrar Todos os
Arquivos, expanda o nó Meu Projeto e abra o arquivo Settings.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.

Ｕ Cuidado
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. Para obter
a melhor segurança, use um método de autenticação que não dependa do
armazenamento de uma senha na cadeia de conexão, como a Autenticação do
Windows, para um banco de dados local do SQL Server. Consulte Salvar e editar
cadeias de conexão.
Escrever o código para os formulários

Esta seção contém breves visões gerais do que cada formulário faz. Ela também fornece
o código que define a lógica subjacente quando um botão no formulário é clicado.
Formulário Navegação
O formulário Navegação é aberto quando você executa 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 Navegação o formulário de inicialização

Se você estiver usando C#, no Gerenciador de Soluções, abra Program.cs e altere a
linha Application.Run para esta: Application.Run(new Navigation());
Se você estiver usando o Visual Basic, no Gerenciador de Soluções, abra a janela

Propriedades, selecione a guia Aplicativo e 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 Navegação para criar métodos vazios
do manipulador de eventos. Clicar duas vezes nos botões também adiciona o código
gerado automaticamente no arquivo de código do Designer que permite um clique de
botão para gerar um evento.
７ Observação
Se você ignorar a ação de clique duplo no designer e apenas copiar o código e

colá-lo em seus arquivos de código, não se esqueça de definir o manipulador de
eventos para o método correto. Você pode fazer isso na janela Propriedades.
Alterne para a guia Eventos (use o botão de raio da barra de ferramentas) e
procure o manipulador Clique.
Adicionar código para a lógica do formulário Navegação

Na página de código do formulário Navegação, conclua os corpos do método dos
manipuladores de eventos de clique de três botões, conforme mostrado no código a
seguir.
C#
/// <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();
}
７ Observação
O código deste tutorial está disponível em C# e Visual Basic. Para alternar o idioma
de código nesta página entre C# e Visual Basic, use o comutador de idioma de
código na parte superior de cada exemplo de código.
Formulário NewCustomer
Quando você insere um nome de cliente e seleciona o botão Criar Conta, o formulário
NewCustomer cria uma conta de cliente e o 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.

Crie um manipulador de eventos Clique 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 o código gerado automaticamente no arquivo de código
do Designer que permite um clique de botão para gerar um evento.
Adicionar código para a lógica do formulário NewCustomer

Para concluir a lógica do formulário NewCustomer, siga estas etapas.
1. Traga o namespace System.Data.SqlClient para o escopo para que você não

precise qualificar totalmente os nomes de seus membros.
C#
using System.Data.SqlClient;
2. Adicione algumas variáveis e métodos auxiliares à classe, conforme mostrado no

código a seguir.
C#
// 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;
}
3. Conclua os corpos do método para os quatro manipuladores de eventos de clique
com botão, conforme mostrado no código a seguir.
C#
/// <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;
// 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.

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 SqlCommand and identify it as a stored
procedure.
SqlCommand("Sales.uspPlaceNewOrder", connection))
{
// Add the @CustomerID input parameter, which was

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

SqlParameter("@OrderDate", SqlDbType.DateTime, 8));
sqlCommand.Parameters["@OrderDate"].Value =
dtpOrderDate.Value;
// Add the @Amount order amount input parameter.

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).
SqlParameter("@Status", SqlDbType.Char, 1));
sqlCommand.Parameters["@Status"].Value = "O";
// 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.

// 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();
}
Formulário FillOrCancel
O formulário FillOrCancel executa uma consulta para retornar um pedido quando você
insere um ID do pedido e seleciona o botão Localizar Pedido. A linha retornada aparece
em uma grade de dados somente leitura. Você pode 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 Preencher Pedido. Se você selecionar o botão Localizar Pedido
novamente, a linha atualizada será exibida.
Crie manipuladores de eventos Clique 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 o código gerado automaticamente no arquivo de código do Designer que
permite um clique de botão para gerar 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 precise
qualificar totalmente os nomes de seus membros.
C#
using System.Data.SqlClient;
using System.Text.RegularExpressions;
2. Adicione uma variável e um método auxiliar à classe, conforme mostrado no

código a seguir.
C#
// 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;
}
}
3. Conclua os corpos do método para os quatro manipuladores de eventos de clique

com botão, conforme mostrado no código a seguir.
C#
/// <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())
{
{
// 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.
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)
{
{
{
// Create the SqlCommand object and identify it as a
stored procedure.
SqlCommand("Sales.uspCancelOrder", connection))
{
// Add the order ID input parameter for the stored

procedure.
parsedOrderID;
try
{
// Open the connection.
connection.Open();
// Run the command to execute the stored

procedure.
}
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)
{
{
{
// Create command and identify it as a stored
procedure.
SqlCommand("Sales.uspFillOrder", connection))
{
// Add the order ID input parameter for the stored

procedure.
parsedOrderID;
// Add the filled date input parameter for the

stored procedure.
SqlParameter("@FilledDate", SqlDbType.DateTime, 8));
sqlCommand.Parameters["@FilledDate"].Value =
dtpFillDate.Value;
try
{
connection.Open();
// Execute the stored procedure.

}
catch
{
MessageBox.Show("The fill operation was not
completed.");
}
finally
{
// Close the connection.
connection.Close();
}
}
}
}
}
/// <summary>
/// Closes the form.
/// </summary>
private void btnFinishUpdates_Click(object sender, EventArgs e)
{
this.Close();
}
Teste seu aplicativo

Execute o aplicativo e tente criar alguns clientes e pedidos para verificar se tudo está
funcionando conforme esperado. Para verificar se o banco de dados foi atualizado com
suas alterações, abra o nó Tabelas no Gerenciador de Servidores, clique com o botão
direito do mouse nos nós Clientes e Pedidos e escolha Mostrar Dados da Tabela.
Ferramentas de dados do Visual Studio para .NET
Comentários
Criar um aplicativo de dados simples
com o WPF e o Entity Framework 6
Artigo • 04/02/2025
２ Aviso
Se você estiver usando o Visual Studio 2022, deverá usar o Visual Studio 2022
versão 17.3 Versão prévia 3 ou posterior para este tutorial.
Este passo a passo mostra como criar um aplicativo básico de "formulários sobre dados"
no Visual Studio. O aplicativo usa o SQL Server LocalDB, o banco de dados Northwind, o
Entity Framework 6 (não o Entity Framework Core) e o Windows Presentation
Foundation para .NET Framework (não .NET Core ou .NET 5 ou posterior). Ele mostra
como fazer a vinculação de dados básica com uma exibição de detalhes principais 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 final, Atualizar e Excluir.
Este artigo se concentra no uso de ferramentas de dados no Visual Studio e não tenta
explicar detalhadamente as tecnologias subjacentes. Ele pressupõe 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.
O código final deste tutorial pode ser encontrado no GitHub em Exemplos de Tutorial
do Visual Studio – EF6 .
Instalar e conectar-se ao Northwind

Este exemplo usa o SQL Server Express LocalDB e o banco de dados de exemplo
Northwind. Se o ADO.NET provedor de dados desse produto der suporte ao Entity
Framework, ele também deverá funcionar com outros produtos do banco de dados SQL.
1. Se você não tiver o SQL Server Express LocalDB, instale-o por meio do do
Instalador do Visual Studio. No Visual Studio Installer, 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 janela Pesquisador de Objetos do SQL Server. (O
Pesquisador de Objetos do SQL Server é instalado como parte da carga de
trabalho Armazenamento e processamento de dados no Visual Studio
Installer). Expanda o nó do SQL Server. Clique com o botão direito do mouse
na instância do LocalDB e selecione Nova Consulta.
Uma janela do editor de consultas é aberta.
b. Copie o script Transact-SQL da Northwind para sua área de transferência. Esse

script T-SQL cria o banco de dados Northwind do zero e o preenche com
dados.
c. Cole o script T-SQL no editor de consultas e, em seguida, escolha o botão

Executar.
Após um curto período de tempo, a consulta termina de ser executada e o

banco de dados Northwind é criado.
3. Adicionar novas conexões para Northwind.
Configurar o projeto
1. No Visual Studio, crie um novo projeto de aplicativo WPF de C# (.NET Framework).
2. Adicione o pacote NuGet para o Entity Framework 6. No Gerenciador de Soluções,

selecione o nó do projeto. No menu principal, escolha Projeto>Gerenciar Pacotes
NuGet.
3. No Gerenciador de Pacotes NuGet, clique no link Procurar. O Entity Framework

provavelmente é o principal pacote da 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 o Visual Studio para criar um modelo com base no banco de
dados Northwind.
Criar o modelo
1. No Gerenciador de Soluções, clique com o botão direito do mouse no nó do
projeto e escolha Adicionar>Novo Item. No painel esquerdo, no nó C#, escolha
Dados e, no painel central, escolha Modelo de Dados de Entidade ADO.NET.
2. Chame o modelo Northwind_model e escolha Adicionar. O Assistente do Modelo

de Dados de Entidade será aberto. Escolha Designer de EF no banco de dados e
selecione Avançar.
3. Na próxima tela, escolha sua conexão LocalDB Northwind (por exemplo,
(localdb)\MSSQLLocalDB), especifique o banco de dados Northwind e clique em
Avançar.
Se você não vir uma conexão, escolha Nova Conexão, e na caixa de diálogo
Escolher Fonte de Dados, escolha Microsoft SQL Server, escolha Continuar e na
caixa de diálogo Propriedades de Conexão, insira (localdb)\MSSQLLocalDB e em
Selecionar ou insira um nome de banco de dados, escolha Northwind, então
pressione OK.
4. Se solicitado, escolha a versão do Entity Framework que você está usando.

5. Na próxima página do assistente, escolha quais tabelas, procedimentos
armazenados e outros objetos de banco de dados incluir no modelo do Entity
Framework. 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.
6. O assistente gera as classes C# que representam o modelo do Entity Framework.

As classes são classes C# simples e convencionais e que vinculamos à interface do
usuário 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 no Gerenciador de Soluções sob o nó
Northwind_model.
captura de tela
A superfície do designer do arquivo .edmx permite que você modifique algumas

propriedades e relações no modelo. Não vamos usar o designer neste passo a
passo.
7. Os arquivos .tt são de uso geral e você precisa ajustar um deles para trabalhar
com a vinculação de dados do WPF, que requer ObservableCollections. Em
Gerenciador de Soluções, expanda o nó Northwind_model até encontrar
Northwind_model.tt. (Verifique se você não está no arquivo .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 ObservableCollection<T>

em torno da linha 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.
8. Pressione F5 ou ctrl+ F5 para compilar e executar o projeto. Quando o aplicativo é

executado pela primeira vez, as classes de modelo ficam 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.
Vincular dados do modelo à página XAML
É possível escrever seu próprio código de vinculação de dados, mas é muito mais fácil
permitir que o Visual Studio faça isso por você.
1. No menu principal, escolha Project>Adicionar nova fonte de dados para abrir o

assistente de configuração da fonte de dados . Escolha Object porque você está
associando às classes de modelo, não ao banco de dados:
2. Expanda o nó do seu projeto e selecione Cliente. (As fontes para pedidos são
geradas automaticamente a partir da propriedade de Navegação de pedidos no
Cliente.)
3. Clique em Finalizar.
4. Navegue até MainWindow.xaml no Modo de Exibição de Código. Estamos

mantendo o XAML simples para 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:
XAML
<Grid.RowDefinitions>
<RowDefinition Height="auto"/>
<RowDefinition Height="*"/>
</Grid.RowDefinitions>
5. Agora abra o arquivo MainWindow.xaml para visualizá-lo no designer. Assim, faz a

janela Fontes de Dados aparecer como uma opção na margem da janela do Visual
Studio ao lado da Caixa de Ferramentas. Clique na guia para abrir a janela ou
pressione Shift+Alt+D ou escolha Exibir>Outras Fontes de Dados do Windows>.
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 vá para a linha do meio. Se
você perder o nó, poderá especificar a linha manualmente depois no XAML
( Grid.Row="1" ). 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 Name em
cima, acima do endereço. O aplicativo de exemplo deste artigo reorganiza os
campos e os reorganiza em duas colunas.
Na visualização XAML, agora você pode ver um novo elemento Grid na primeira
linha (a linha intermediária) da grade principal. A grade pai tem um atributo
DataContext que se refere a um CollectionViewSource que foi adicionado ao
elemento Windows.Resources . Dado esse contexto de dados, quando a primeira

caixa de texto se associa a Endereço, esse nome é mapeado para a propriedade
Address no objeto atual Customer no CollectionViewSource .
XAML
<Grid DataContext="{StaticResource customerViewSource}">
6. Quando um cliente está 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 de detalhes mestre funcione
conforme o esperado, é importante que você associe à propriedade Pedidos na
classe Clientes, não ao nó Pedidos separado. Arraste a propriedade Pedidos da
classe Clientes para a metade inferior do formulário, para que o designer a
coloque na linha 2:
7. O 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 algum código para preencher o modelo. Primeiro,
navegue até MainWindow.xaml.cs e adicione um campo de dados à classe
MainWindow para o contexto de dados. Esse objeto, que foi gerado para você, age
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 associada ao construtor
MainWindow() existente. A parte superior da classe deve ter esta aparência:
C#
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;
}
Se ainda não estiver lá, adicione uma diretiva using para System.Data.Entity para
colocar o método de extensão Load no escopo:
C#
using System.Data.Entity;
Agora, role para baixo e localize o manipulador de eventos Window_Loaded .

Observe que o Visual Studio adicionou um objeto CollectionViewSource. Isso
representa o objeto NorthwindEntities que você selecionou ao criar o modelo.
Você já adicionou isso, então não precisa dele aqui. Vamos substituir o código em
Window_Loaded para que o método agora tenha esta aparência:
C#
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ê deve 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, então vamos corrigir isso. Você também pode criar uma
maneira de exibir os outros registros e fazer operações básicas de criação, leitura,
atualização e exclusão (CRUD).
Ajustar o design da página e adicionar grades

para novos clientes e pedidos
A disposição padrão produzida pelo 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 na verdade são Grades) para permitir que o usuário
adicione um novo cliente ou pedido. Para poder adicionar um novo cliente e pedido, é
necessário um conjunto separado de caixas de texto que não estejam associadas a
dados de CollectionViewSource . Você controlará a grade do usuário que visualiza 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 uma ordem individual.
Primeiro, adicione esses estilos ao elemento Windows.Resources em MainWindow.xaml:
XAML
<Style x:Key="Label" TargetType="{x:Type Label}" BasedOn="{x:Null}">

<Setter Property="HorizontalAlignment" Value="Left"/>
<Setter Property="VerticalAlignment" Value="Center"/>
<Setter Property="Margin" Value="3"/>
<Setter Property="Height" Value="23"/>
</Style>
<Style x:Key="CustTextBox" TargetType="{x:Type TextBox}" BasedOn="{x:Null}">
<Setter Property="HorizontalAlignment" Value="Right"/>
<Setter Property="VerticalAlignment" Value="Center"/>
<Setter Property="Margin" Value="3"/>
<Setter Property="Height" Value="26"/>
<Setter Property="Width" Value="120"/>
</Style>
Em seguida, substitua todo o Grid externo por este bloco de código:
XAML
<Grid>
<RowDefinition Height="*"/>
<Grid x:Name="existingCustomerGrid" Grid.Row="1"
HorizontalAlignment="Left" Margin="5" Visibility="Visible"
VerticalAlignment="Top" Background="AntiqueWhite" DataContext="
{StaticResource customerViewSource}">
<Grid.ColumnDefinitions>
<ColumnDefinition Width="Auto" MinWidth="233"/>
</Grid.ColumnDefinitions>
<RowDefinition Height="Auto"/>
<Label Content="Customer ID:" Grid.Row="0" Style="{StaticResource
Label}"/>
<TextBox x:Name="customerIDTextBox" Grid.Row="0" Style="
{StaticResource CustTextBox}"
Text="{Binding CustomerID, Mode=TwoWay,
NotifyOnValidationError=true, ValidatesOnExceptions=true}"/>
<Label Content="Company Name:" Grid.Row="1" Style="{StaticResource
Label}"/>
<TextBox x:Name="companyNameTextBox" Grid.Row="1" Style="
Text="{Binding CompanyName, Mode=TwoWay,
<Label Content="Contact Name:" Grid.Row="2" Style="{StaticResource
Label}"/>
<TextBox x:Name="contactNameTextBox" Grid.Row="2" Style="
Text="{Binding ContactName, Mode=TwoWay,
<Label Content="Contact title:" Grid.Row="3" Style="{StaticResource
Label}"/>
<TextBox x:Name="contactTitleTextBox" Grid.Row="3" Style="
Text="{Binding ContactTitle, Mode=TwoWay,
<Label Content="Address:" Grid.Row="4" Style="{StaticResource
Label}"/>
<TextBox x:Name="addressTextBox" Grid.Row="4" Style="
Text="{Binding Address, Mode=TwoWay,
<Label Content="City:" Grid.Column="1" Grid.Row="0" Style="
{StaticResource Label}"/>
<TextBox x:Name="cityTextBox" Grid.Column="1" Grid.Row="0" Style="
Text="{Binding City, Mode=TwoWay,
<Label Content="Country:" Grid.Column="1" Grid.Row="1" Style="
<TextBox x:Name="countryTextBox" Grid.Column="1" Grid.Row="1"
Style="{StaticResource CustTextBox}"
Text="{Binding Country, Mode=TwoWay,
<Label Content="Fax:" Grid.Column="1" Grid.Row="2" Style="
<TextBox x:Name="faxTextBox" Grid.Column="1" Grid.Row="2" Style="
Text="{Binding Fax, Mode=TwoWay,
<Label Content="Phone:" Grid.Column="1" Grid.Row="3" Style="
<TextBox x:Name="phoneTextBox" Grid.Column="1" Grid.Row="3" Style="
Text="{Binding Phone, Mode=TwoWay,
<Label Content="Postal Code:" Grid.Column="1" Grid.Row="4"
VerticalAlignment="Center" Style="{StaticResource Label}"/>
<TextBox x:Name="postalCodeTextBox" Grid.Column="1" Grid.Row="4"
Text="{Binding PostalCode, Mode=TwoWay,
<Label Content="Region:" Grid.Column="1" Grid.Row="5" Style="
<TextBox x:Name="regionTextBox" Grid.Column="1" Grid.Row="5"
Text="{Binding Region, Mode=TwoWay,
</Grid>
<Grid x:Name="newCustomerGrid" Grid.Row="1" HorizontalAlignment="Left"
VerticalAlignment="Top" Margin="5" DataContext="{Binding RelativeSource=
{RelativeSource FindAncestor, AncestorType={x:Type Window}},
Path=newCustomer, UpdateSourceTrigger=Explicit}" Visibility="Collapsed"
Background="CornflowerBlue">
<Label Content="Customer ID:" Grid.Row="0" Style="{StaticResource
Label}"/>
<TextBox x:Name="add_customerIDTextBox" Grid.Row="0" Style="
Text="{Binding CustomerID, Mode=TwoWay,
<Label Content="Company Name:" Grid.Row="1" Style="{StaticResource
Label}"/>
<TextBox x:Name="add_companyNameTextBox" Grid.Row="1" Style="
Text="{Binding CompanyName, Mode=TwoWay,
NotifyOnValidationError=true, ValidatesOnExceptions=true }"/>
<Label Content="Contact Name:" Grid.Row="2" Style="{StaticResource
Label}"/>
<TextBox x:Name="add_contactNameTextBox" Grid.Row="2" Style="
Text="{Binding ContactName, Mode=TwoWay,
<Label Content="Contact title:" Grid.Row="3" Style="{StaticResource
Label}"/>
<TextBox x:Name="add_contactTitleTextBox" Grid.Row="3" Style="
Text="{Binding ContactTitle, Mode=TwoWay,
<Label Content="Address:" Grid.Row="4" Style="{StaticResource
Label}"/>
<TextBox x:Name="add_addressTextBox" Grid.Row="4" Style="
Text="{Binding Address, Mode=TwoWay,
<Label Content="City:" Grid.Column="1" Grid.Row="0" Style="
<TextBox x:Name="add_cityTextBox" Grid.Column="1" Grid.Row="0"
Text="{Binding City, Mode=TwoWay,
<Label Content="Country:" Grid.Column="1" Grid.Row="1" Style="
<TextBox x:Name="add_countryTextBox" Grid.Column="1" Grid.Row="1"
Text="{Binding Country, Mode=TwoWay,
<Label Content="Fax:" Grid.Column="1" Grid.Row="2" Style="
<TextBox x:Name="add_faxTextBox" Grid.Column="1" Grid.Row="2"
Text="{Binding Fax, Mode=TwoWay,
<Label Content="Phone:" Grid.Column="1" Grid.Row="3" Style="
<TextBox x:Name="add_phoneTextBox" Grid.Column="1" Grid.Row="3"
Text="{Binding Phone, Mode=TwoWay,
<Label Content="Postal Code:" Grid.Column="1" Grid.Row="4"
VerticalAlignment="Center" Style="{StaticResource Label}"/>
<TextBox x:Name="add_postalCodeTextBox" Grid.Column="1"
Grid.Row="4" Style="{StaticResource CustTextBox}"
Text="{Binding PostalCode, Mode=TwoWay,
<Label Content="Region:" Grid.Column="1" Grid.Row="5" Style="
<TextBox x:Name="add_regionTextBox" Grid.Column="1" Grid.Row="5"
Text="{Binding Region, Mode=TwoWay,
</Grid>
<Grid x:Name="newOrderGrid" Grid.Row="1" HorizontalAlignment="Left"
VerticalAlignment="Top" Margin="5" DataContext="{Binding Path=newOrder,
Mode=TwoWay}" Visibility="Collapsed" Background="LightGreen">
<Label Content="New Order Form" FontWeight="Bold"/>
<Label Content="Employee ID:" Grid.Row="1" Style="{StaticResource
Label}"/>
<TextBox x:Name="add_employeeIDTextBox" Grid.Row="1" Style="
Text="{Binding EmployeeID, Mode=TwoWay,
<Label Content="Order Date:" Grid.Row="2" Style="{StaticResource
Label}"/>
<DatePicker x:Name="add_orderDatePicker" Grid.Row="2"
HorizontalAlignment="Right" Width="120"
SelectedDate="{Binding OrderDate, Mode=TwoWay,
NotifyOnValidationError=true, ValidatesOnExceptions=true,
UpdateSourceTrigger=PropertyChanged}"/>
<Label Content="Required Date:" Grid.Row="3" Style="{StaticResource
Label}"/>
<DatePicker x:Name="add_requiredDatePicker" Grid.Row="3"
SelectedDate="{Binding RequiredDate, Mode=TwoWay,
<Label Content="Shipped Date:" Grid.Row="4" Style="
<DatePicker x:Name="add_shippedDatePicker" Grid.Row="4"
SelectedDate="{Binding ShippedDate, Mode=TwoWay,
<Label Content="Ship Via:" Grid.Row="5" Style="{StaticResource
Label}"/>
<TextBox x:Name="add_ShipViaTextBox" Grid.Row="5" Style="
Text="{Binding ShipVia, Mode=TwoWay,
<Label Content="Freight" Grid.Row="6" Style="{StaticResource
Label}"/>
<TextBox x:Name="add_freightTextBox" Grid.Row="6" Style="
Text="{Binding Freight, Mode=TwoWay,
</Grid>
<DataGrid x:Name="ordersDataGrid" SelectionUnit="Cell"
SelectionMode="Single" AutoGenerateColumns="False" CanUserAddRows="false"
IsEnabled="True" EnableRowVirtualization="True" Width="auto" ItemsSource="
{Binding Source={StaticResource customerOrdersViewSource}}"
Margin="10,10,10,10" Grid.Row="2"
RowDetailsVisibilityMode="VisibleWhenSelected">
<DataGrid.Columns>
<DataGridTemplateColumn>
<DataGridTemplateColumn.CellTemplate>
<DataTemplate>
<Button Content="Delete" Command="{StaticResource
DeleteOrderCommand}" CommandParameter="{Binding}"/>
</DataTemplate>
</DataGridTemplateColumn.CellTemplate>
</DataGridTemplateColumn>
<DataGridTextColumn x:Name="customerIDColumn" Binding="{Binding
CustomerID}" Header="Customer ID" Width="SizeToHeader"/>
<DataGridTextColumn x:Name="employeeIDColumn" Binding="{Binding
EmployeeID}" Header="Employee ID" Width="SizeToHeader"/>
<DataGridTextColumn x:Name="freightColumn" Binding="{Binding
Freight}" Header="Freight" Width="SizeToHeader"/>
<DataGridTemplateColumn x:Name="orderDateColumn" Header="Order
Date" Width="SizeToHeader">
<DataTemplate>
<DatePicker SelectedDate="{Binding OrderDate,
Mode=TwoWay, NotifyOnValidationError=true, ValidatesOnExceptions=true,
</DataTemplate>
<DataGridTextColumn x:Name="orderIDColumn" Binding="{Binding
OrderID}" Header="Order ID" Width="SizeToHeader"/>
<DataGridTemplateColumn x:Name="requiredDateColumn"
Header="Required Date" Width="SizeToHeader">
<DataTemplate>
<DatePicker SelectedDate="{Binding RequiredDate,
</DataTemplate>
<DataGridTextColumn x:Name="shipAddressColumn" Binding="
{Binding ShipAddress}" Header="Ship Address" Width="SizeToHeader"/>
<DataGridTextColumn x:Name="shipCityColumn" Binding="{Binding
ShipCity}" Header="Ship City" Width="SizeToHeader"/>
<DataGridTextColumn x:Name="shipCountryColumn" Binding="
{Binding ShipCountry}" Header="Ship Country" Width="SizeToHeader"/>
<DataGridTextColumn x:Name="shipNameColumn" Binding="{Binding
ShipName}" Header="Ship Name" Width="SizeToHeader"/>
<DataGridTemplateColumn x:Name="shippedDateColumn"
Header="Shipped Date" Width="SizeToHeader">
<DataTemplate>
<DatePicker SelectedDate="{Binding ShippedDate,
</DataTemplate>
<DataGridTextColumn x:Name="shipPostalCodeColumn" Binding="
{Binding ShipPostalCode}" Header="Ship Postal Code" Width="SizeToHeader"/>
<DataGridTextColumn x:Name="shipRegionColumn" Binding="{Binding
ShipRegion}" Header="Ship Region" Width="SizeToHeader"/>
<DataGridTextColumn x:Name="shipViaColumn" Binding="{Binding
ShipVia}" Header="Ship Via" Width="SizeToHeader"/>
</DataGrid.Columns>
</DataGrid>
</Grid>
Adicionar botões para navegar, adicionar,
atualizar e excluir
Em aplicativos do Windows Forms, você obtém um objeto BindingNavigator com
botões para navegar por linhas em um banco de dados e fazer operações CRUD básicas.
O WPF não fornece um BindingNavigator, mas é fácil o suficiente para criar um. Você faz
isso com botões dentro de um StackPanel horizontal e associa os botões a comandos
associados a métodos no código atrás.
Há quatro partes na lógica de comando: (1) os comandos, (2) as associações, (3) os

botões e (4) os manipuladores de comando no code-behind.
Adicionar comandos, associações e botões no XAML

1. Primeiro, adicione os comandos no arquivo MainWindow.xaml dentro do elemento
Windows.Resources :
XAML
<RoutedUICommand x:Key="FirstCommand" Text="First"/>

<RoutedUICommand x:Key="LastCommand" Text="Last"/>
<RoutedUICommand x:Key="NextCommand" Text="Next"/>
<RoutedUICommand x:Key="PreviousCommand" Text="Previous"/>
<RoutedUICommand x:Key="DeleteCustomerCommand" Text="Delete Customer"/>
<RoutedUICommand x:Key="DeleteOrderCommand" Text="Delete Order"/>
<RoutedUICommand x:Key="UpdateCommand" Text="Update"/>
<RoutedUICommand x:Key="AddCommand" Text="Add"/>
<RoutedUICommand x:Key="CancelCommand" Text="Cancel"/>
2. Um CommandBinding mapeia um evento RoutedUICommand para um método no

código subjacente. Adicione esse elemento CommandBindings após a marca de
fechamento Windows.Resources :
XAML
<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, adição, exclusão e

atualização. Primeiro, adicione esse estilo a Windows.Resources :
XAML
<Style x:Key="NavButton" TargetType="{x:Type Button}" BasedOn="

{x:Null}">
<Setter Property="FontSize" Value="24"/>
<Setter Property="FontFamily" Value="Segoe UI Symbol"/>
<Setter Property="Margin" Value="2,2,2,0"/>
<Setter Property="Width" Value="40"/>
<Setter Property="Height" Value="auto"/>
</Style>
Em segundo lugar, cole esse código logo após o RowDefinitions do elemento

Grid externo, na parte superior da página XAML:
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 para os métodos adicionar e excluir. 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, temos que excluir o Order_Details associado a ele. O
UpdateCommandHandler 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 caixas de texto.
Adicione esses métodos de manipulador à classe MainWindow em MainWindow.xaml.cs.

Se o CollectionViewSource para a tabela Customers tiver um nome diferente, você
precisará ajustar o nome em cada um desses métodos:
C#
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();
}
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.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.
}
// 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;
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;
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);
// 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 Confirmar para adicionar um novo cliente ou pedido ao modelo
depois de inserir 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 gravadas no
modelo automaticamente.
documentação do Entity Framework
Comentários

Ferramentas de dados do Visual Studio
para C++
Artigo • 12/01/2024
Muitas vezes, o C++ nativo pode fornecer o desempenho mais rápido quando você
estiver acessando fontes de dados. No entanto, as ferramentas de dados de aplicativos
C++ no Visual Studio não são tão avançadas quanto as de 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++. Caso precise de uma camada relacional de
objeto, você precisará escrever uma própria ou usar um produto de terceiros. O mesmo
vale para a funcionalidade de associação de dados, ainda que 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, confira Acesso a dados no Visual
C++.
Para se conectar a bancos de dados SQL, os aplicativos C++ nativos podem usar os
drivers ODBC e OLE DB e o provedor do 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. O OLE DB é fornecido para compatibilidade com versões anteriores. Para
obter mais informações sobre essas tecnologias de dados, confira Windows Data Access
Components.
Para aproveitar a funcionalidade personalizada no SQL Server 2005 e versões

posteriores, use o cliente nativo do SQL Server. O cliente nativo também contém o
driver ODBC do SQL Server e o provedor OLE DB do SQL Server em uma DLL (biblioteca
de vínculo dinâmico) nativa. Eles dão suporte a aplicativos que usam APIs de código
nativo (ODBC, OLE DB e ADO) na conexão com o Microsoft SQL Server. O SQL Server
Native Client é instalado com o SQL Server Data Tools. O guia de programação está
aqui: programação de cliente nativo do SQL Server.
Para se conectar ao localDB por meio da ODBC

e do SQL Native Client a partir de um aplicativo
C++.
1. Instale o SQL Server Data Tools.
2. Se você precisar de um banco de dados SQL de exemplo ao qual se conectar,

baixe o banco de dados Northwind e descompacte-o em um novo local.
3. Use o SQL Server Management Studio para anexar o arquivo Northwind.mdf
descompactado ao localDB. Quando o SQL Server Management Studio for
iniciado, conecte-se a (localdb)\MSSQLLocalDB.
Depois, 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 da ODBC e descompacte-o em um novo

local. Esse exemplo mostra os comandos básicos da ODBC que são usados para se
conectar a um banco de dados e emitir consultas e comandos. Você pode obter
mais informações sobre essas funções na ODBC (Open Database Connectivity) da
Microsoft. Ao carregar a solução pela primeira vez (que 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 respectivo arquivo de cabeçalho e do

arquivo de biblioteca. Esses arquivos contêm funções e definições específicas para
o SQL Server, além das funções da ODBC definidas no sql.h. Em
Projeto>Propriedades>Diretórios VC++, adicione o seguinte diretório de
inclusão:
%ProgramFiles%\Microsoft SQL Server\110\SDK\Include
E este diretório de biblioteca:
%ProgramFiles%\Microsoft SQL Server\110\SDK\Lib
6. Adicione essas linhas no odbcsql.cpp. O texto #define impede que definições

irrelevantes da OLE DB sejam compiladas.
C++
#define _SQLNCLI_ODBC_
#include <sqlncli.h>
Observe que o exemplo não usa nenhuma das funcionalidades nativas do cliente
de verdade, portanto, as etapas anteriores não são necessárias para a compilação
e execução. Porém, agora o projeto está configurado para você usar essa
funcionalidade. Para obter mais informações, confira Programação do SQL Server
Native Client.
7. Especifique qual driver usar no subsistema da ODBC. O exemplo passa o atributo

de cadeia de conexão DRIVER como um argumento de linha de comando. Em
Projeto>Propriedades>Depuração, adicione este argumento de comando:
C++
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 solicitando a inserção de um banco de dados. Insira
(localdb)\MSSQLLocalDB e marque Usar Conexão Confiável. Pressione OK. Você
deverá ver um console com mensagens que indiquem uma conexão bem-
sucedida. Você também deve ver um prompt de comando no qual possa digitar
uma instrução SQL. A tela a seguir mostra um exemplo de consulta e seus
resultados:
Confira também
Acessando dados no Visual Studio
Passo a passo: criar classes LINQ to SQL
usando a herança de tabela única
(Designer Relacional de Objetos)
Artigo • 12/01/2024
As ferramentas de LINQ to SQL no Visual Studio dão suporte à herança de tabela única,
pois normalmente são implementadas em sistemas relacionais. Este passo a passo se
aprofunda nas etapas genéricas fornecidas no tópico Como configurar a herança
usando o Designer Relacional de Objetos e fornece alguns dados reais para demonstrar
o uso da herança no Designer Relacional de Objetos.
Nestas instruções passo a passo, as seguintes tarefas serão executadas:
Criar uma tabela de banco de dados e adicione dados a ela.
Criar um aplicativo do Windows Forms.
Adicionar um arquivo 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 a herança funciona, você criará uma pequena tabela Person , usará como
uma classe base e, em seguida, criará um objeto Employee que herda dela.
Para criar uma tabela base para demonstrar a herança

1. No Gerenciador de Servidores ou Gerenciador de Banco de Dados, clique com o
botão direito do mouse no nó Tabelas e clique em Adicionar Nova Tabela.
７ Observação
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:
Nome da coluna Tipo de Dados Permitir Nulos
ID int Falso
Tipo int Verdadeiro
Nome nvarchar(200) Falso
Sobrenome nvarchar(200) Falso
Gerente int Verdadeiro
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 Person no Gerenciador de Servidores ou Gerenciador de Banco
de Dados e clique em Mostrar Dados da Tabela.)
2. Copie os seguintes dados na tabela. (Você pode copiar e colar na tabela

selecionando a linha inteira no painel Resultados.)
ID Tipo Nome Sobrenome Gerente
1 1 Anne Wallace NULL
2 1 Carlos Grilo NULL

ID Tipo Nome Sobrenome Gerente
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 Martin 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 aplicativo do Windows Forms

1. No Visual Studio, no menu Arquivo, selecione Novo>Projeto.
2. Expanda Visual C# ou Visual Basic no painel esquerdo e selecione Área de

Trabalho do Windows.
3. No painel central, selecione o tipo de projeto Aplicativo Windows Forms.
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 Designer Relacional de Objetos é

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. No Gerenciador de Servidores 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 do Designer Relacional de

Objetos.
3. Arraste uma segunda tabela Person para o Designer Relacional de Objetos e

altere o nome dela 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 Designer Relacional de Objetos. A seta na linha
de herança irá apontar 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ê adicionará 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 :
C#
C#
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
empregados (os registros que têm um valor de 2 na coluna 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.)
Ferramentas do 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 com ADO.NET e o
.NET Framework
Artigo • 01/11/2023
Aplica-se a: Visual Studio Visual Studio para Mac Visual Studio Code
７ Observação

dados. Eles são bastante úteis em aplicativos que permitem que os usuários
modifiquem dados e persistam as alterações no banco de dados. Embora os
conjuntos de dados tenham se mostrado uma tecnologia muito bem-sucedida, é
recomendado que os novos aplicativos .NET usem o Entity Framework Core. O
mais simples.
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 dos 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 conjunto de dados e o código TableAdapter,

você cria um serviço Windows Communication Foundation Services e WCF Data Services
no Visual Studio para chamar a camada de acesso a dados. Finalmente, você cria um
aplicativo do Windows Forms como a camada de apresentação. Essa camada acessa
dados do serviço de dados.
Nestas instruções passo a passo, as seguintes etapas serão executadas:
Criar uma nova solução de N camadas que contenha 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.
Separar o TableAdapters gerado e o código do conjunto 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.
Pré-requisitos
Para concluir este passo a passo, você precisa das cargas de trabalho de
desenvolvimento em .NET para desktop e Armazenamento e processamento de dados
instaladas no Visual Studio. Para instalá-las, abra Instalador do Visual Studio e escolha
Modificar (ou Mais>Modificar) ao lado da versão do Visual Studio que você deseja
modificar. Confira Modificar o Visual Studio.
Este passo a passo usa o SQL Server Express LocalDB e o banco de dados de exemplo
da Northwind.
1. Se você não tiver SQL Server Express LocalDB, instale-o por meio da página de
download do SQL Server Express ou usando o 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 da Northwind seguindo estas etapas:

trabalho Armazenamento e processamento de dados no Instalador do Visual
Studio). Expanda o nó do SQL Server. Clique com o botão direito do mouse na
instância do LocalDB e selecione Nova Consulta.
Se você não vir a instância do LocalDB, use o botão de barra de ferramentas

Adicionar SQL Server. A caixa de diálogo aparecerá. Na caixa de diálogo,
expanda Local e escolha MSSQLLocalDB. Insira as credenciais apropriadas. Você
pode deixar a opção padrão para o banco de dados.
b. Escolha Conectar. Um nó é adicionado para LocalDB no Pesquisador de
Objetos do SQL Server.
c. Clique com o botão direito do mouse na instância do LocalDB e selecione Nova

Consulta.
d. Copie o script Transact-SQL da Northwind para sua área de transferência. Esse

script T-SQL cria o banco de dados da Northwind do zero e o preenche com
alguns dados.
e. 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 termina de ser executada e o banco de
dados da Northwind é criado.
Criar a solução de N camadas e a biblioteca de

classes para manter o conjunto 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 mantém o conjunto de dados (a classe
DataSet digitada gerada e DataTables, que manté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 conjunto de dados cria o conjunto de dados
inicial e separa automaticamente o código nas duas bibliotecas de classes.
７ Observação
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, crie um projeto usando o modelo de projeto do Windows Forms
(.NET Framework) para C# ou Visual Basic. Não há suporte para .NET Core, .NET 5
e posterior.
2. Nomeie o projeto como DataEntityTier.
3. Nomeie a solução como NTierWalkthrough e 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 os

TableAdapters (DataAccessTier)
A próxima etapa após a criação do projeto DataEntityTier é criar outro projeto de
biblioteca de classes. Esse projeto manté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 os

TableAdapters
1. Clique com o botão direito do mouse na solução no Gerenciador de Soluções e
escolha Adicionar>Novo Projeto.
2. Escolha o modelo de projeto Biblioteca de Classes (.NET Framework).
3. Nomeie o projeto como DataAccessTier e escolha OK.
O projeto DataAccessTier é criado e adicionado à solução NTierWalkthrough.
Criar o Conjunto de Dados

A próxima etapa é criar um conjunto de dados tipado. Os conjuntos de dados tipado
são criados com a classe do conjunto de dados (incluindo as classes DataTables ) e as
classes TableAdapter em um único projeto. (Todas as classes são geradas em um único
arquivo.) Quando você separa o conjunto de dados e os TableAdapters em projetos
diferentes, é a classe do conjunto de dados que é movida para o outro projeto,
mantendo as classes TableAdapter no projeto original. Portanto, crie o conjunto de
dados no projeto que conterá, por fim, os TableAdapters (o projeto DataAccessTier).
Você crie o conjunto de dados executando o Assistente de Configuração de Fonte de
Dados.
７ Observação
É 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 da Northwind, consulte Como instalar bancos de dados de exemplo.
Para criar o conjunto de dados

1. Selecione DataAccessTier em 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 de Fonte de Dados.
4. Na página Escolher um Tipo de Fonte de Dados, selecione Banco de Dados e

selecione Avançar.
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.
７ Observação
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 do banco de dados ao projeto.
7. Selecione Próximo na página Salvar a Cadeia de Conexão no Arquivo de

Configuração do Aplicativo.
8. Expanda o nó Tabelas na página Escolher Objetos do Banco de Dados.
9. Selecione as caixas de seleção das tabelas Clientes e Pedidos e, em seguida,

escolha Concluir.
NorthwindDataSet é adicionado ao projeto DataAccessTier e aparece na janela

Fontes de Dados.
Separar os TableAdapters do Conjunto de

Dados
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 NorthwindDataSet.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 Projeto do Conjunto de Dados, 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 continha originalmente todo o conjunto de
dados ( DataAccessTier ) contém agora somente os TableAdapters. O projeto
atribuído à propriedade Projeto do Conjunto de Dados ( DataEntityTier ) contém
o conjunto de dados tipado: NorthwindDataSet.Dataset.Designer.vb (ou
NorthwindDataSet.Dataset.Designer.cs).
７ Observação
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 passo a passo demonstra como acessar a camada de acesso a dados usando um
serviço WCF. Vamos criar um novo aplicativo de serviço WCF.
Para criar um novo aplicativo de Serviço WCF

2. Na caixa de diálogo Novo Projeto, no painel esquerdo, selecione WCF. No painel

do meio, selecione Biblioteca de Serviços do WCF.
3. Nomeie o projeto como DataService 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 de clientes e pedidos
O serviço de dados deve chamar dois métodos na camada de acesso a dados:
GetCustomers e GetOrders . Esses métodos retornam as tabelas Customers e Orders
Northwind. Crie os métodos GetCustomers e GetOrders no projeto DataAccessTier .
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 NorthwindDataset.xsd para
abrir o conjunto de dados.
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.
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 DataService 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.
７ Observação
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 DataService, clique duas vezes em IService1.vb ou IService1.cs.
2. Adicione o seguinte código no comentário Adicionar suas operações de serviço

aqui:
C#
C#
[OperationContract]
DataEntityTier.NorthwindDataSet.CustomersDataTable GetCustomers();
[OperationContract]
DataEntityTier.NorthwindDataSet.OrdersDataTable GetOrders();
７ Observação
O código deste tutorial está disponível em C# e Visual Basic. Para alternar a

linguagem de código nesta página entre C# e Visual Basic, use o comutador
de linguagem de código na parte superior da página à direita.
3. No projeto DataService, clique duas vezes em Service1.vb (ou Service1.cs).
4. Adicione o seguinte código à classe Service1:
C#
C#
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 a partir do serviço de dados
Agora que a solução contém o serviço de dados que possui métodos chamados na
camada de acesso a dados, crie outro projeto que será chamado no 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

2. Na caixa de diálogo Novo Projeto, no painel esquerdo, selecione Área de Trabalho

do Windows. No painel do meio, escolha Aplicativo Windows Forms.
3. Nomeie o projeto como PresentationTier e clique em OK.
O projeto PresentationTier é criado e adicionado à solução NTierWalkthrough.
Configurar o projeto PresentationTier como o

projeto de inicialização
Definiremos o projeto PresentationTier como o projeto de inicialização da solução, pois
é 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. O
código adicionado à classe do conjunto de dados parcial estará disponível na camada
de apresentação somente após você permitir o compartilhamento de tipos por meio do
serviço de dados. Como você geralmente 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 a partir do cliente.
Para adicionar uma referência à camada de apresentação

1. No 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
PresentationTier e selecione Adicionar Referência de Serviço.
2. Na caixa de diálogo Adicionar Referência de Serviço, selecione Descobrir.
3. Selecione Service1 e escolha OK.
７ Observação
Se você tiver vários serviços no computador atual, escolha o serviço criado

anteriormente neste passo a passo (o serviço que contém os métodos
GetCustomers e GetOrders ).
Adicionar 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 NorthwindDataSet 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 .
C#
C#
ServiceReference1.Service1Client DataSvc =
new ServiceReference1.Service1Client();
northwindDataSet.Customers.Merge(DataSvc.GetCustomers());
northwindDataSet.Orders.Merge(DataSvc.GetOrders());
Aumentar o tamanho máximo da mensagem

permitida pelo serviço
O valor padrão para maxReceivedMessageSize não é grande o suficiente para manter os
dados recuperados das tabelas Customers e Orders . 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.
７ Observação
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 maxReceivedMessageSize e altere o valor para

6553600 . Se você não vir a entrada basicHttpBinding , adicione uma como no
exemplo a seguir:
XML
<system.serviceModel>
<bindings>
<basicHttpBinding>
<binding maxBufferSize="6553600"
maxReceivedMessageSize="6553600" />
</basicHttpBinding>
</bindings>
</system.serviceModel>
Testar o aplicativo
Execute o aplicativo pressionando F5. Os dados das tabelas Customers e Orders são
recuperados a partir 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
Sistemas de banco de dados
compatíveis para Visual Studio
Artigo • 09/04/2024
Para desenvolver um aplicativo conectado a dados no Visual Studio, normalmente você

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 estiverem prontos. O Visual Studio instala SQL Server Express LocalDB em
seu computador como parte da carga de trabalho Armazenamento e processamento
de dados. Essa instância do LocalDB é útil para desenvolver aplicativos conectados a
dados de maneira rápida e fácil.
Para que um sistema de banco de dados possa ser acessado por aplicativos .NET e fique
visível nas janelas de ferramentas de dados do Visual Studio, ele deve ter um provedor
de dados ADO.NET. Um provedor deve dar suporte especificamente ao Entity
Framework se você planeja usar modelos de dados de entidade em seu aplicativo .NET.
Muitos provedores são oferecidos por meio do Gerenciador de Pacotes NuGet 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 cobranças 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 projetos do Visual Studio. A lista não é exaustiva. Para obter uma
lista de fornecedores extermps que oferecem provedores de dados ADO.NET que
permitem uma integração profunda com as ferramentas do Visual Studio, consulte
Provedores de Dados ADO.NET.
Microsoft SQL Server

O SQL Server é a principal oferta de banco de dados da Microsoft. O SQL Server 2016
oferece desempenho inovador, segurança avançada e relatórios e análises avançados e
integrados. Ele é fornecido em várias edições projetadas para diferentes usos: desde
análises de negócios altamente escalonáveis e de alto desempenho, até o uso em um
único computador. O SQL Server Express é uma edição completa do SQL Server
personalizada para redistribuição e inserção. O LocalDB é uma edição simplificada do
SQL Server Express que não requer nenhuma configuração e é executada no processo
do aplicativo. Você pode baixar um ou ambos os produtos na página de download do
SQL Server Express . Muitos dos exemplos de SQL nesta seção usam SQL Server
LocalDB. O SSMS (SQL Server Management Studio) é um aplicativo de gerenciamento
de banco de dados autônomo que tem mais funcionalidades do que o fornecido no
Pesquisador de Objetos do SQL Server do Visual Studio. Você pode obter o SSMS no
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 obter suporte em tempo de design para o Entity
Framework e TableAdapters, você precisará do Ferramentas para desenvolvedores
Oracle para Visual Studio . Outros produtos Oracle oficiais, incluindo o Oracle Instant
Client, estão disponíveis por meio do Gerenciador de Pacotes NuGet. 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 que é
amplamente usado em empresas e sites. Os downloads do MySQL, MySQL para Visual
Studio e produtos relacionados estão no MySQL no Windows . Terceiros oferecem
várias extensões do Visual Studio e aplicativos de gerenciamento autônomos para o
MySQL. Você pode procurar as ofertas no Gerenciador de Pacotes NuGet
(Ferramentas>Gerenciador de Pacotes NuGet>Gerenciar Pacotes NuGet para a
Solução).
PostgreSQL
O PostgreSQL é um sistema de banco de dados relacional de objetos gratuito e de
código aberto. Para instalá-lo no 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 da linguagem C. Muitos terceiros
fornecem pacotes NuGet para usar o PostgreSQL em aplicativos .NET. Você pode
procurar as ofertas no Gerenciador de Pacotes NuGet (Ferramentas>Gerenciador de
Pacotes NuGet>Gerenciar Pacotes NuGet para a Solução). Talvez o pacote mais
popular seja fornecido por npgsql.org .
SQLite
O SQLite é um Mecanismo de Banco de Dados SQL inserido que é executado no próprio
processo do aplicativo. Você pode baixá-lo na página de download do SQLite .
Também há muitos pacotes NuGet de terceiros para SQLite disponíveis. Você pode
procurar as ofertas no Gerenciador de Pacotes NuGet (Ferramentas>Gerenciador de
Pacotes NuGet>Gerenciar Pacotes NuGet para a Solução).
Firebird
O Firebird é um sistema de banco de dados SQL de código aberto. Você pode baixá-lo
na página de download do Firebird . Um provedor de dados ADO.NET está disponível
por meio do Gerenciador de Pacotes NuGet.
Como determinar a versão e a edição do SQL Server e seus componentes
Comentários
Ferramentas de dados do Visual Studio
para desenvolvimento .NET Framework
Artigo • 12/01/2024
O Visual Studio e o .NET juntos dão um amplo suporte a 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 funcionalidade de acesso a dados são
conhecidas como ADO.NET. O 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 provedores do ADO.NET.
７ Observação

mais simples.
O diagrama a seguir mostra uma exibição simplificada da arquitetura básica:

Instalação
Para usar as ferramentas de dados para . NET, você precisa das cargas de trabalho de
Desenvolvimento de área de trabalho do .NET e Armazenamento de dados e
processamento instaladas no Visual Studio. Para instalá-las, abra Instalador do Visual
Studio e escolha Modificar (ou Mais>Modificar) ao lado da versão do Visual Studio que
você deseja modificar. Confira Modificar o Visual Studio.
Fluxo de trabalho típico

O fluxo de trabalho típico é o seguinte:
1. Instale um banco de dados de desenvolvimento ou teste no seu computador local.

Confira Instalar sistemas, ferramentas e exemplos de banco de dados. Se 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 com o serviço ou com o arquivo local)
no Visual Studio. Confira Adicionar novas conexões.
3. (Opcional) Use as ferramentas para gerar e configurar um novo modelo. Os

modelos baseados no Entity Framework são a recomendação padrão para novos
aplicativos. O modelo, seja para qual for o uso, é a fonte de dados com a qual o
aplicativo interage. O modelo fica logicamente entre o banco de dados ou serviço
e o aplicativo. Confira Adicionar novas fontes de dados.
4. Arraste a fonte de dados da janela Fontes de Dados para uma superfície de design
do 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. Confira Associar controles a dados no Visual Studio.
5. Adicione um código personalizado para itens como regras de negócios, pesquisa e

validação de dados ou para aproveitar a funcionalidade personalizada exposta
pelo banco de dados subjacente.
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. Lembre-se que você ainda pode
usar o Assistente de Configuração da Fonte de Dados e designers para gerar códigos
de associação de dados ao preencher seus próprios objetos na memória e, em seguida,
associar dados de controles de interface do usuário a esses objetos.
Confira também
Acessar dados no Visual Studio
Ferramentas do Entity Framework no
Visual Studio
Artigo • 10/02/2025
O Entity Framework é uma tecnologia orm (mapeamento relacional de objeto) que

permite que os desenvolvedores do .NET trabalhem com dados relacionais usando
objetos específicos do domínio. Elimina a necessidade da maioria do código de acesso a
dados que os desenvolvedores geralmente precisam gravar. O Entity Framework é a
tecnologia de modelagem ORM (mapeamento relacional de objeto) recomendada para
novos aplicativos .NET.
As Ferramentas do Entity Framework foram projetadas para ajudá-lo a criar aplicativos

EF (Entity Framework). A documentação completa do Entity Framework está aqui: visão
geral – EF 6.
７ Observação
As Ferramentas do Entity Framework descritas nesta página são usadas para gerar
arquivos .edmx , que não têm suporte no EF Core. Para gerar um modelo 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
EF 6 e EF Core.
Com o Entity Framework Tools, você pode criar um modelo conceitual de um banco de
dados existente e, em seguida, visualizar e editar graficamente seu modelo conceitual.
Ou, você pode criar um modelo conceitual graficamente 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 for
alterado e gerar automaticamente o código de camada de objeto para seu aplicativo.
Geração de banco de dados e geração de código de camada de objeto são
personalizáveis.
As ferramentas do Entity Framework são instaladas como parte da carga de trabalho de

Armazenamento e processamento de dados no Visual Studio Installer. 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 as ferramentas do Entity Framework

no Visual Studio:
Você pode usar o Designer de Modelo de Dados de Entidade ADO.NET (Entity
Designer) para criar e modificar entidades, associações, mapeamentos e relações
de herança visualmente. O Designer de Entidade também gera código de camada
de objeto C# ou Visual Basic.
Você pode usar o Assistente de Modelo de Dados de Entidade para gerar um

modelo conceitual 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 Criar Banco de Dados para criar um modelo
conceitual primeiro e, em seguida, criar um banco de dados que dê suporte ao
modelo.
Você pode usar o Assistente de Modelo de Atualização para atualizar seu modelo
conceitual, modelo de armazenamento e mapeamentos quando forem feitas
alterações no banco de dados subjacente.
７ Observação
A partir do Visual Studio 2010, as ferramentas do Entity Framework não dão

suporte ao 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.
Entity Framework 6 Power Tools ajudam você a criar aplicativos que usam o Modelo
de Dados de Entidade. As ferramentas elétricas podem 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
contêm exibições geradas pelo modelo. Para obter informações detalhadas, confira
Exibições de Mapeamento Pré-geradas.
Título Descrição
Entity Framework do ADO.NET Descreve como usar as Ferramentas de Modelo de

Dados de Entidade, que o Entity Framework fornece,
para criar aplicativos.
Título Descrição
Modelo de Dados de Entidade Fornece links e informações para trabalhar com

dados 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 o Entity Framework.
ferramentas de dados do Visual Studio Fornece uma visão geral das ferramentas de dados
para o desenvolvimento com o .NET do .NET Framework no Visual Studio.
Framework
Comentários

Ferramentas de conjunto de dados do
Visual Studio para desenvolver
aplicativos do .NET Framework
Artigo • 12/01/2024
７ Observação

mais simples.
Um objeto DataSet é um objeto na memória que é, essencialmente, um minibanco de

dados. Ele contém objetos DataTable , DataColumn e DataRow nos quais você pode
armazenar e modificar dados de um ou mais bancos de dados sem precisar manter uma
conexão aberta. O conjunto de dados mantém informações sobre alterações em seus
próprios dados, de modo que as atualizações possam ser rastreadas e enviadas de volta
ao banco de dados quando o aplicativo for reconectado.
Conjuntos de dados e classes relacionadas são definidos no System.Data namespace na

API do .NET. Você pode criar e modificar conjuntos de dados dinamicamente no código
usando o ADO.NET. A documentação nesta seção mostra como trabalhar com conjuntos
de dados usando designers do Visual Studio. Os conjuntos de dados criados por meio
de designers usam objetos TableAdapter para interagir com o banco de dados. Os
conjuntos de dados criados programaticamente usam objetos DataAdapter. Para obter
informações sobre como criar conjuntos de dados programaticamente, confira
DataAdapters e DataReaders.
Se o aplicativo só precisar ler dados de um banco de dados e não executar atualizações,

adições ou exclusões, geralmente será possível obter um melhor desempenho usando
um objeto DataReader para recuperar dados em um objeto genérico List ou em outro
objeto de coleção. Se você estiver exibindo os dados, poderá associar dados da
interface do usuário à coleção.
Fluxo de trabalho do conjunto de dados

O Visual Studio oferece 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 conjunto de dados a partir 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 serão incluídas e quais colunas
de cada tabela. Escolha cuidadosamente para conservar a quantidade de memória
requerida pelo conjunto de dados. 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, confira Preencher conjuntos
de dados usando TableAdapters.
Use o Assistente de Configuração do TableAdapter para especificar a consulta ou

o procedimento armazenado que preenche o conjunto de dados, além de quais
operações de banco de dados (atualizar, excluir 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
Confira e pesquise os dados no conjunto de dados. Para obter mais informações,

confira Consultar conjunto de dados. O LINQ to DataSet habilita a LINQ (consulta
integrada à linguagem) sobre dados em um objeto DataSet. Para obter mais
informações, consulte LINQ to DataSet.
Use a janela Fontes de Dados para associar controles de interface do usuário ao

conjunto de dados ou a suas colunas individuais e para especificar quais colunas
pode ser editadas 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 informações sobre conjuntos de dados em aplicativos de N camadas, confira
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,
confira Ler dados XML em um conjunto de dados e Salvar um conjunto de dados como
XML.
Comparação entre conjuntos de dados
tipados e não tipados no .NET
Framework
Artigo • 12/01/2024
７ Observação

mais simples.
Um conjunto de dados tipado é um conjunto de dados que primeiro é derivado da

classe DataSet base e depois usa informações do Designer de Conjunto de Dados, que
é armazenado em um arquivo .xsd, para gerar uma nova classe de conjunto de dados
fortemente tipados. 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 objetos e propriedades de primeira classe. Como um conjunto de dados tipado
herda da classe DataSet base, a classe tipada pressupõe toda a funcionalidade da classe
DataSet e pode ser usada com métodos que assumem uma instância de uma classe
DataSet como um parâmetro.
Por outro lado, um conjunto de dados não tipados não tem nenhum esquema interno
correspondente. Como em um conjunto de dados tipados, um conjunto de dados não
tipados contém tabelas, colunas e assim por diante, mas são expostos apenas como
coleções. (No entanto, depois de criar manualmente as tabelas e outros elementos de
dados em um conjunto de dados não tipados, você pode exportar a estrutura do
conjunto de dados como um esquema usando o método WriteXmlSchema do conjunto
de dados.)
Contraste o acesso a dados em conjuntos de
dados tipados e não tipados
A classe de um conjunto de dados tipados tem um modelo de objeto no qual suas
propriedades assumem os nomes reais das tabelas e colunas. Por exemplo, se você
estiver trabalhando com um conjunto de dados tipados, poderá referenciar uma coluna
usando código como o seguinte:
C#
C#
// This accesses the CustomerID column in the first row of the Customers
table.
string customerIDValue = northwindDataSet.Customers[0].CustomerID;
Por outro lado, se você estiver trabalhando com um conjunto de dados não tipados, o
código equivalente será:
C#
C#
string customerIDValue = (string)

dataset1.Tables["Customers"].Rows[0]["CustomerID"];
O acesso tipado não é apenas mais fácil de ler, mas também é totalmente compatível
com o IntelliSense no Visual Studio Code Editor. Além de ser mais fácil de trabalhar, a
sintaxe do conjunto de dados tipados fornece verificação de tipo em tempo de
compilação, reduzindo consideravelmente a possibilidade de erros na atribuição de
valores aos membros do conjunto de dados. Se você alterar o nome de uma coluna em
sua classe DataSet e compilar o aplicativo, receberá um erro de build. Ao clicar duas
vezes no erro de build na Lista de Tarefas, você poderá ir diretamente para a linha ou as
linhas de código que fazem referência ao nome da coluna antiga. O acesso a tabelas e
colunas em um conjunto de dados tipados também é um pouco mais rápido no tempo
de execução porque o acesso é determinado no tempo de compilação, não por meio de
coleções em tempo de execução.
Embora os conjuntos de dados tipados tenham muitas vantagens, um conjunto de

dados não tipado é útil em uma variedade de circunstâncias. O cenário mais óbvio é
quando nenhum esquema está disponível para o conjunto de dados. Por exemplo, isso
poderá ocorrer se o aplicativo estiver interagindo com um componente que retorna um
conjunto de dados, mas você não sabe com antecedência qual é sua estrutura. Da
mesma forma, há momentos em que você está trabalhando com os dados que não têm
uma estrutura estática e previsível. Nesse caso, será impraticável usar um conjunto de
dados tipados, pois você teria que regenerar a classe de conjunto de dados tipados com
cada alteração na estrutura de dados.
Em geral, há muitas vezes em que você pode criar um conjunto de dados

dinamicamente sem ter um esquema disponível. Nesse caso, o conjunto 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 conjunto de dados, como a capacidade de serializar as
informações para passar para outro processo ou gravar um arquivo XML.
Ferramentas do conjunto de dados
Preencher conjuntos de dados usando
TableAdapters em aplicativos do .NET
Framework
Artigo • 01/11/2023
７ Observação
Os conjuntos de dados e classes relacionadas são tecnologias .NET Framework

herdadas 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 bastante úteis em aplicativos que permitem que os usuários modifiquem
dados e persistam as alterações no banco de dados. Embora os conjuntos de
dados tenham se mostrado uma tecnologia muito bem-sucedida, é recomendado
que os novos aplicativos .NET usem o Entity Framework Core. O Entity Framework
proporciona uma forma mais natural de trabalhar com dados tabulares como
modelos de objeto e conta com uma interface de programação mais simples.
Um componente TableAdapter preenche um conjunto de dados com dados do banco

de dados com base em uma ou mais consultas ou procedimentos armazenados
especificados. Os TableAdapters também podem executar adições, atualizações e
exclusões no banco de dados para persistir as alterações feitas no conjunto de dados.
Você também pode emitir comandos globais que não estão relacionados a tabelas
específicas.
７ Observação
Os TableAdapters são gerados por designers do Visual Studio. Se você estiver

criando conjuntos de dados programaticamente, use o 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ópico Descrição
Criar e configurar TableAdapters Como usar os designers para criar e configurar

Tópico Descrição
TableAdapters
Criar consultas TableAdapter Como permitir que os usuários forneçam argumentos

parametrizadas para procedimentos ou consultas do TableAdapter
Acessar o banco de dados Como usar os métodos Dbdirect do TableAdapters

diretamente com um TableAdapter
Desabilitar restrições ao preencher Como trabalhar com restrições de chave estrangeira ao

um conjunto de dados atualizar dados
Como estender a funcionalidade de Como adicionar código personalizado a TableAdapters

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

dados
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 o
DataTable com os dados retornados. Os TableAdapters também enviam dados
atualizados de seu aplicativo de volta para o banco de dados. Você pode executar
quantas consultas desejar em um TableAdapter, desde que retornem dados em
conformidade com o esquema da tabela à 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 TableAdapter não são geradas como classes aninhadas do DataSet. Eles estão
localizados em namespaces separados específicos para cada conjunto de dados. Por
exemplo, se você tiver um conjunto de dados chamado NorthwindDataSet , os
TableAdapters associados a DataTables no NorthwindDataSet estarão no namespace
NorthwindDataSetTableAdapters . Para acessar um TableAdapter específico
programaticamente, você deve declarar uma nova instância do TableAdapter. Por

exemplo:
C#
C#
NorthwindDataSet northwindDataSet = new NorthwindDataSet();
NorthwindDataSetTableAdapters.CustomersTableAdapter
customersTableAdapter =
new NorthwindDataSetTableAdapters.CustomersTableAdapter();
customersTableAdapter.Fill(northwindDataSet.Customers);
Esquema do DataTable associado

Ao criar um TableAdapter, você usa a consulta inicial ou o procedimento armazenado
para definir o esquema do DataTable associado do TableAdapter. Você executa essa
consulta inicial ou procedimento armazenado chamando o método Fill do
TableAdapter (que preenche o DataTable associado do TableAdapter). Todas 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 outras consultas no
TableAdapter usarem instruções SQL 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 do TableAdapter. Por
exemplo, os TableAdapters 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 para o banco de
dados subjacente. No entanto, você pode configurar os comandos INSERT , UPDATE e
DELETE manualmente na janela Propriedades.
consultas TableAdapter
Os TableAdapters pode conter várias consultas para preencher suas tabelas de dados
associadas. Você pode definir quantas consultas forem necessárias para um
TableAdapter, desde que cada consulta retorne dados em conformidade com o mesmo
esquema que a tabela de dados associada. Essa funcionalidade permite que um
TableAdapter carregue resultados diferentes com base em critérios diferentes.
Por exemplo, se o 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
determinada letra e outra que preencha a tabela com todos os clientes localizados no
mesmo estado. Para preencher uma tabela Customers com clientes em determinado
estado, você pode criar uma consulta FillByState que usa um parâmetro para o valor
de estado da seguinte maneira: SELECT * FROM Customers WHERE State = @State . Execute
a consulta chamando o método FillByState 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 clientes ( SELECT
Count(*) From Customers ) é válida para um CustomersTableAdapter, , mesmo que os
dados retornados não estejam em conformidade com o esquema da tabela.

Propriedade ClearBeforeFill
Por padrão, sempre que você executa uma consulta para preencher a tabela de dados
de um TableAdapter, os dados existentes são limpos e apenas os resultados da consulta
são carregados na tabela. Defina a propriedade ClearBeforeFill do TableAdapter como
false se você quiser adicionar ou mesclar os dados retornados de uma consulta aos
dados existentes em uma tabela de dados. Independentemente de você limpar os

dados, você precisa enviar explicitamente as atualizações para o banco de dados, se
quiser mantê-las. Portanto, lembre-se de salvar as alterações nos dados na tabela, antes
de executar outra consulta que preencha a tabela. Para obter mais informações, confira
Atualizar dados usando um TableAdapter.
Herança do TableAdapter
Os TableAdapters estendem a funcionalidade dos adaptadores de dados padrão
encapsulando uma classe DataAdapter configurada. Por padrão, o TableAdapter herda
da classe Component e não pode ser convertido na classe DataAdapter. Converter um
TableAdapter na classe DataAdapter resulta em um erro InvalidCastException. Para
alterar a classe base de um TableAdapter, você pode especificar uma classe derivada do
Component na propriedade 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 pesquisar na
documentação ou no Navegador de Objetos. Ela é criada 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 é chamado de
OrdersTableAdapter . O nome de classe do TableAdapter pode ser alterado usando a
propriedade Name no Designer de Conjunto de Dados.
Veja a seguir os métodos e as propriedades normalmente usados do TableAdapters:
Membro DESCRIÇÃO
TableAdapter.Fill Preenche a tabela de dados associada do TableAdapter com os

resultados do comando SELECT do TableAdapter.
Membro DESCRIÇÃO
TableAdapter.Update Envia as alterações para o banco de dados e retorna um inteiro

que representa o número de linhas afetadas pela atualização.
Para obter mais informações, confira Atualizar dados usando um
TableAdapter.
TableAdapter.GetData Retorna um novo DataTable cheio de dados.
TableAdapter.Insert Cria uma nova linha na tabela de dados. Para obter mais
informações, confira Inserir novos registros em um banco de
dados.
TableAdapter.ClearBeforeFill Determina se uma tabela de dados é esvaziada, antes de chamar

um dos métodos Fill .
Método de atualização do TableAdapter

Os TableAdapters usam comandos de dados para ler e gravar no banco de dados. Use a
consulta inicial (principal) Fill do TableAdapter como base para criar o esquema da
tabela de dados associada, bem como os comandos InsertCommand , UpdateCommand e
DeleteCommand associados ao método TableAdapter.Update . Chamar um método Update
do TableAdapter executa as instruções que foram criadas quando o TableAdapter foi

configurado originalmente, 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 normalmente você executaria. Por exemplo, quando você chama o
método Fill do adaptador, o adaptador executa o comando de dados na propriedade
SelectCommand 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

método Update do adaptador, ele executa o comando apropriado (nas propriedades
UpdateCommand , InsertCommand e DeleteCommand ) para cada registro alterado na tabela de
dados.
７ Observação
Se houver informações suficientes na consulta principal, os comandos

InsertCommand , UpdateCommand e DeleteCommand serão criados por padrão quando o
TableAdapter for gerado. Se a consulta principal do TableAdapter for mais do que

uma única instrução SELECT da tabela, é possível que o designer não seja capaz de
gerar InsertCommand , UpdateCommand e DeleteCommand . Se esses comandos não
forem gerados, você poderá receber um erro ao executar o método
TableAdapter.Update .
TableAdapter GenerateDbDirectMethods
Além de InsertCommand , UpdateCommand e DeleteCommand , os 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 dados. Isso
significa que você pode chamar esses métodos individuais do código, em vez de chamar
TableAdapter.Update para lidar com as inserções, atualizações e exclusões 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).
Outras consultas que são adicionadas ao TableAdapter são consultas autônomas. Elas
não geram esses métodos.
Suporte do TableAdapter para tipos que

permitem valor nulo
Os TableAdapters dão suporte a tipos que permitem valor nulo Nullable(Of T) 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 permitem valor nulo no C#, confira Usar tipos que permitem valor nulo.
Referência de TableAdapterManager
Por padrão, uma classe TableAdapterManager é gerada quando você cria um conjunto
de dados que contém tabelas relacionadas. Para impedir que a classe seja gerada, altere
o valor da propriedade Hierarchical Update do conjunto de dados para false. Quando
você arrasta uma tabela que tem uma relação para a superfície de design de uma
página do Windows Form ou WPF, o Visual Studio declara uma variável de membro da
classe. Se você não usa a vinculação de dados, precisa declarar a variável manualmente.
A classe TableAdapterManager não é um tipo .NET. Portanto, você não pode pesquisá-la
na documentação. Ela é criada em tempo de design como parte do processo de criação
do conjunto de dados.
Estes são os métodos e as propriedades da classe TableAdapterManager usados com
frequência:
Membro Descrição
Método UpdateAll Salva todos os dados de todas as tabelas de dados.
Propriedade Determina se é necessário criar uma cópia de backup do conjunto

BackUpDataSetBeforeUpdate de dados antes de executar o método booliano
TableAdapterManager.UpdateAll .
Propriedade Representa um TableAdapter. O TableAdapterManager gerado

tableName TableAdapter contém uma propriedade para cada TableAdapter que ele
gerencia. Por exemplo, um conjunto de dados com uma tabela de
Clientes e Pedidos é gerado com um TableAdapterManager que
contém as propriedades CustomersTableAdapter e
OrdersTableAdapter .
Propriedade UpdateOrder Controla a ordem dos comandos de inserção, atualização e

exclusão individuais. Defina como um dos valores na enumeração
TableAdapterManager.UpdateOrderOption .
Por padrão, o UpdateOrder é definido como InsertUpdateDelete.

Isso significa que inserções, atualizações e exclusões são
executadas para todas as tabelas no conjunto de dados.
Segurança
Ao usar comandos de dados com a propriedade CommandType 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 de usuário para um banco de dados, sempre
verifique se as informações são válidas. A melhor prática é sempre usar consultas
parametrizadas ou procedimentos armazenados, quando possível.
Confira também
Ferramentas do conjunto de dados
Trabalhar com conjuntos de dados em
aplicativos de n camadas
Artigo • 12/01/2024
７ Observação

mais simples.
Os aplicativos de dados de N camadas são aplicativos centrados em dados que são

separados em várias camadas lógicas (ou apenas 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 dos 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 para N camadas em conjuntos de dados tipados permite o desenvolvimento

iterativo da arquitetura do aplicativo para um design de N camadas. Ele também elimina
a necessidade de separar manualmente o código em mais de um projeto. Comece a
projetar 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>
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
Ferramentas de conjunto de dados no Visual Studio
Criar e configurar TableAdapters
Aplicativos de N camadas e remotos com o LINQ to SQL
Projetos de banco de dados e
aplicativos da camada de dados (.NET
Framework)
Artigo • 12/01/2024
７ Observação

mais simples.
Você pode usar projetos de banco de dados para criar bancos de dados, DACs
(aplicativos de camada de dados) e atualizar bancos de dados e aplicativos da camada
de dados existentes. Os projetos de banco de dados e os projetos de DAC permitem
aplicar técnicas de controle de versão e gerenciamento de projetos aos esforços de
desenvolvimento de banco de dados da mesma forma que você 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, compilar e testar alterações em um ambiente de desenvolvimento
isolado ou em uma área restrita, antes de compartilhá-los 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 preparo antes de
implantar as alterações em produção.
Para obter uma lista dos recursos de banco de dados compatíveis com aplicativos da
camada de dados, confira Suporte de DAC para objetos do SQL Server. Se você usar
recursos em seu banco de dados incompatíveis com 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
Tarefa de alto nível Conteúdo de suporte
Iniciar o desenvolvimento de um aplicativo da camada de dados: o - Aplicativos da

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

desenvolvedores podem fazer check-out de partes do projeto e banco de dados offline
atualizá-las em um ambiente de desenvolvimento isolado. Usando esse orientado a projetos
tipo de ambiente, você pode testar suas alterações sem afetar outros (SQL Server Data
membros da equipe. Após a conclusão das alterações, você verifica os Tools)
arquivos novamente no controle de versão, onde outros membros da - Depurador Transact-
equipe podem obter suas alterações, compilá-las e implantá-las em um SQL (SQL Server
servidor de teste. Management Studio)
Prototipagem, verificação de resultados de teste e modificação de - Editores de consulta

scripts e objetos de banco de dados: você pode usar o editor Transact- e texto (SQL Server
SQL para executar qualquer uma dessas tarefas comuns. Management Studio)
Visão geral de aplicativos de dados de N
camadas
Artigo • 04/05/2023
７ Observação
Os conjuntos de dados e classes relacionadas são tecnologias .NET herdadas 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
bastante úteis em aplicativos que permitem que os usuários modifiquem dados e
persistam as alterações no banco de dados. Embora os conjuntos de dados tenham
se mostrado uma tecnologia muito bem-sucedida, é recomendado que os novos
aplicativos .NET usem o Entity Framework Core. O Entity Framework proporciona
uma forma mais natural de trabalhar com dados tabulares como modelos de
objeto e conta com uma interface de programação mais simples.
Aplicativos de dados de N camadas são aplicativos de dados separados em várias

camadas. Também conhecidos como "aplicativos distribuídos" e "aplicativos
multicamadas", os aplicativos de N camada separam o processamento em camadas
discretas distribuídas entre o cliente e o servidor. Ao desenvolver aplicativos que
acessam dados, você deve fazer 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 do Windows Forms, enquanto que a lógica de acesso aos 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 aos 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. Isso é feito pela adoção com mais facilidade de novas
tecnologias que podem ser aplicadas a uma única camada, sem a necessidade de
reprojetar toda a solução. 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 uma propriedade Projeto de Conjunto de Dados

que permite separar conjunto de dados (camada de entidade de dados) e
TableAdapters (camada de acesso a dados) em projetos discretos.
As ferramentas do LINQ to SQL no Visual Studio fornecem configurações para

gerar as classes DataContext e data em namespaces separados. Isso permite a
separação lógica das camadas de entidade de dados e acesso a dados.
O LINQ to SQL fornece o método Attach que permite reunir o DataContext de

diferentes camadas em um aplicativo. Para obter mais informações, consulte
aplicativos remotos e de N Camadas com o LINQ to SQL.
Camada de apresentação
A camada de apresentação é a camada na qual os usuários interagem com um
aplicativo. Geralmente, ela também contém lógica adicional do aplicativo. Os
componentes típicos da camada de apresentação incluem o seguinte:
Componentes da associação de dados, como BindingSource e BindingNavigator.
Representações de objeto de dados, como classes de entidade do LINQ to SQL

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 aplicativo de Serviços do Windows
Communication Foundation e WCF Data Services no 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. Os componentes típicos da camada intermediária
incluem o seguinte:
Lógica de negócios, como regras de negócios e validação de dados.
Componentes e lógica de acesso a dados, como o seguinte:

TableAdapters e DataAdapters e DataReaders.
Representações de objeto de dados, como classes de entidade do LINQ to SQL.
Serviços de aplicativos comuns, como autenticação, autorização e

personalização.
A ilustração a seguir mostra recursos e tecnologias que estão disponíveis no Visual

Studio e como eles podem se ajustar à camada intermediária de um aplicativo de N
camadas.
Camada intermediária
A camada intermediária normalmente se conecta à camada de dados usando uma

conexão de dados. Geralmente, essa conexão de dados é 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 recursos e tecnologias que estão disponíveis no Visual

Studio e como eles podem se ajustar à camada de dados de um aplicativo de N
camadas.
Camada de dados
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 trazem informações sobre como trabalhar com aplicativos de N
camadas:
Conjuntos de dados e TableAdapters separados m diferentes projetos
Aplicativos de N camadas e remotos com o LINQ to SQL
Confira também
Criar um banco de dados e adicionar
tabelas em aplicativos do .NET
Framework usando o Visual Studio
Artigo • 03/02/2025
７ Observação

mais simples.
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 Pesquisador de Objetos
do SQL Server no Visual Studio. Neste tópico, você cria um arquivo .mdf e adiciona
tabelas e chaves usando o Designer de Tabela.
Pré-requisitos
desenvolvimento em .NET para desktop e Armazenamento e processamento de dados
instaladas no Visual Studio. Para instalá-las, abra Instalador do Visual Studio e escolha
Modificar (ou Mais>Modificar) ao lado da versão do Visual Studio que você deseja
modificar. Confira Modificar o Visual Studio.
７ Observação
Os procedimentos neste artigo se aplicam somente a projetos do Windows Forms

do .NET Framework, não a projetos do Windows Forms do .NET Core.
Criar um projeto e um arquivo de banco de
dados local
1. Crie um novo projeto Windows Forms App (.NET Framework) e nomeie-o como
SampleDatabaseWalkthrough.
2. Na barra de menus, escolha Projeto>Adicionar Novo Item. Se você vir uma caixa
de diálogo pequena com uma caixa para um nome de arquivo, escolha Mostrar
Todos os Modelos.
3. Na lista de modelos de item, role para baixo e selecione Banco de Dados baseado
em serviço.
4. Chame o banco de dados de SampleDatabase.mdf e selecione 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>Outras Janelas>Fontes de Dados na barra de menus.
2. Na janela Fontes de Dados, clique em Adicionar Nova Fonte de Dados.

O Assistente de Configuração de Fonte de Dados é aberto.
3. Na página Escolher um Tipo de Fonte de Dados, escolha Banco de dados e, em

seguida, escolha Avançar.
4. Na página Escolher um Modelo de Banco de Dados, escolha Avançar para aceitar

o padrão (Conjunto de dados).
5. Na página Escolher Sua Conexão de Dados, selecione o arquivo

SampleDatabase.mdf na lista suspensa e escolha Avançar.
6. Na página Salvar a Cadeia de Conexão no Arquivo de Configuração do

Aplicativo, escolha Avançar.
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.
Ｕ Cuidado
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. Para obter
a melhor segurança, use um método de autenticação que não dependa do
armazenamento de uma senha na cadeia de conexão, como a Autenticação do
Windows, para um banco de dados local do SQL Server. Consulte Salvar e editar
cadeias de conexão.
Exibir propriedades da conexão de dados
Você pode exibir algumas das propriedades do arquivo SampleDatabase.mdf abrindo a
janela Propriedades da conexão de dados:
Selecione Exibir>Pesquisador de Objetos do SQL Server (ou Ctrl+\, Ctrl+S) para

abrir a janela Pesquisador de Objetos do SQL Server. Expanda
(localdb)\MSSQLLocalDB>Bancos de Dados e clique com o botão direito em
SampleDatabase.mdf (ele pode estar listado como um caminho completo) e
selecione Propriedades.
Como alternativa, você pode selecionar Exibir>Gerenciador de Servidores, 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 em SampleDatabase.mdf e
selecionando Propriedades.
 Dica
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 Conectar-se ao
Banco de Dados na barra de ferramentas de Gerenciador de Servidores. Na
caixa de diálogo Adicionar Conexão, verifique se o Arquivo de Banco de
Dados do Microsoft SQL Server está selecionado em Fonte de dados e, em
seguida, navegue e selecione o arquivo SampleDatabase.mdf. Conclua a
adição da conexão selecionando OK.
Para exibir a cadeia de conexão, você pode abrir o arquivo App.config no Gerenciador de
Soluções. Você deve ver uma entrada sob o elemento connectionStrings semelhante ao
seguinte código:
XML
<connectionStrings>
<add
name="SampleDatabaseWalkthrough.Properties.Settings.SampleDatabaseConnection
String"
connectionString="Data Source=
(LocalDB)\MSSQLLocalDB;AttachDbFilename=|DataDirectory|\SampleDatabase.mdf;I
ntegrated Security=True"
providerName="System.Data.SqlClient" />
</connectionStrings>
Criar tabelas e chaves usando o Designer de
Tabela
Nesta seção, você criará algumas 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 podem corresponder aos registros na outra tabela.
Criar a tabela Clientes

1. No Gerenciador de Servidores ou Navegador de Objetos do SQL Server, expanda
o nó Conexões de Dados e, em seguida, expanda o nó SampleDatabase.mdf.
2. Clique com o botão direito 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:
Nome da coluna Tipo de dados Permitir nulos
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 na linha CustomerID e selecione Definir Chave

Primária.
5. Clique com o botão direito 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:
SQL
CREATE TABLE [dbo].[Customers]

7. Adicione uma restrição de índice à tabela Clientes. Adicione uma vírgula no final
da linha Phone e adicione o seguinte exemplo antes do parêntese de fechamento:
SQL
CONSTRAINT [PK_Customers] PRIMARY KEY ([CustomerID])
Você deverá ver algo como:
8. No canto superior esquerdo do Designer de Tabela, selecione Atualizar ou

pressione Shift+Alt+U.
9. 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 Pedidos

1. Adicione outra tabela e uma linha para cada entrada na seguinte tabela:
OrderID int Falso (desmarcado)
CustomerID nchar(5) Falso (desmarcado)

OrderDate datetime Verdadeiro (marcado)
OrderQuantity int Verdadeiro (marcado)
2. Defina OrderID como a chave primária e, em seguida, exclua a linha padrão.
3. Nomeie a tabela Orders atualizando a primeira linha no painel de script de acordo

com o seguinte exemplo:
SQL
CREATE TABLE [dbo].[Orders]
4. Adicione uma restrição de índice à tabela Clientes. Adicione uma vírgula no final
da linha OrderQuantity e adicione o seguinte exemplo antes do parêntese de
fechamento:
SQL
CONSTRAINT [PK_Orders] PRIMARY KEY ([OrderId])
5. No canto superior esquerdo do Designer de Tabela, selecione Atualizar ou

pressione Shift+Alt+U.

A tabela Pedidos é criada no arquivo de banco de dados local. Se você expandir o

nó Tabelas no Gerenciador de Servidores, verá as duas tabelas:
Se você não o vir, pressione o botão Atualizar da barra de ferramentas.
Criar uma chave estrangeira

1. No painel de contexto no lado direito da grade Designer de Tabela da 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 de acordo com o seguinte exemplo:

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

[Customers]([CustomerID])
4. No canto superior esquerdo do Designer de Tabela, selecione Atualizar

(Shift+Alt+U).

A chave estrangeira é criada.
Preencher as tabelas com dados

1. No Gerenciador de Servidores ou no Pesquisador de Objetos do SQL Server,
expanda o nó do banco de dados de exemplo.
2. Abra o menu de atalho do nó Tables, selecione Atualizar e, em seguida, expanda o

nó Tables.
3. Abra o menu de atalho da tabela Cientes e, em seguida selecione Mostrar Dados

da Tabela ou Exibir Dados.
4. Adicione os dados desejados 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, em seguida, escolha Mostrar Dados

da Tabela ou Exibir Dados.
6. Adicione dados para alguns pedidos. À medida que você insere cada linha, ela é
salva no banco de dados.
） Importante
Verifique se todas as IDs e as quantidades de pedido são inteiros e se cada ID

do cliente corresponde a um valor especificado na coluna CustomerID da
tabela Clientes.
Parabéns! Agora você sabe como criar tabelas, vinculá-las a uma chave estrangeira e
adicionar dados.
Comentários

Conectar-se a um banco de dados no
Visual Studio
Artigo • 14/11/2024
As etapas neste artigo mostram como se conectar a uma fonte de dados no IDE do
Visual Studio. A fonte de dados pode ser um banco de dados local, um serviço de dados
online ou um banco de dados aberto de um .mdf arquivo. Você pode trabalhar
diretamente com seus dados no Visual Studio. Você pode executar consultas, editar
dados, criar e editar tabelas e outras propriedades de esquema, editar funções e
procedimentos armazenados, gatilhos e assim por diante. Essas funções são
independentes da linguagem de programação ou da versão do .NET que você está
usando.
Se estiver trabalhando com um banco de dados do Access (arquivo .accdb ), consulte

Conectar-se a um banco de dados do Access em aplicativos do NET Framework.
Gerenciador de Servidores e Pesquisador de

Objetos do SQL Server
Você pode abrir uma conexão com um banco de dados ou serviço, ou um banco de
dados LocalDB aberto de um arquivo .mdf e exibir e editar tabelas e linhas de dados
usando o Gerenciador de Servidores ou o Pesquisador de Objetos do SQL Server. A
funcionalidade dessas janelas se sobrepõe até certo ponto. As diferenças básicas são:
Gerenciador de Servidores
Ela é instalada por padrão no Visual Studio. Pode ser usada para testar conexões e
exibir bancos de dados do SQL Server, quaisquer outros bancos de dados que
tenham um provedor 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 provedor
ADO.NET, ela não aparecerá aqui, mas você ainda poderá usá-la no Visual Studio
conectando-se programaticamente.
Pesquisador de Objetos do SQL Server
Instalada com SQL Server Data Tools e visível no menu Exibir. Se não estiver lá,
acesse Programas e Recursos no Painel de Controle, localize o Visual Studio e
selecione Alterar para executar novamente o instalador depois de marcar a caixa
de seleção para SQL Server Data Tools. Use o Pesquisador de Objetos do SQL
Server para exibir bancos de dados SQL (se eles tiverem um provedor de
ADO.NET), criar novos bancos de dados, modificar esquemas, criar procedimentos
armazenados, recuperar cadeias de conexão, exibir os dados e muito mais. Os
bancos de dados SQL que não têm provedor ADO.NET instalado não aparecerão
aqui, mas você ainda pode se conectar a eles programaticamente.
Adicionar uma conexão ao Gerenciador de

Servidores
Para criar uma conexão com o banco de dados, clique no ícone Conectar a um banco
de dados no Gerenciador de Servidores ou clique com o botão direito do mouse no
Gerenciador 1de Servidores no nó Conexões de Dados e selecione Adicionar Conexão.
Aqui, você pode abrir uma conexão com um banco de dados LocalDB aberto em um
arquivo .mdf , conectar-se a um banco de dados em outro servidor, um serviço do
SharePoint ou um serviço do Azure.
Isso abre a caixa de diálogo Adicionar Conexão. Aqui, inserimos o nome da instância
SQL Server LocalDB, (localdb)\MSSqlLocalDB , que geralmente é instalada com o Visual
Studio.
Se você não tiver acesso a outro banco de dados e não vir o LocalDB instalado, poderá
instalar o LocalDB por meio do Instalador do Visual Studio, como parte da carga de
trabalho Armazenamento e processamento de dados, a carga de trabalho
Desenvolvimento da ASP.NET e da Web ou como um componente individual. Consulte
Modificar o Visual Studio.
No Visual Studio 2022 versão 17.8 e posterior, a caixa de diálogo inclui duas novas
opções (Criptografar and Certificado do Servidor Confiável) que entram na cadeia de
conexão e afetam as configurações de segurança usadas para sua conexão. Essas
opções dão suporte aos recursos de segurança mais rigorosos do driver de banco de
dados Microsoft.Data.SqlClient 4.0. Confira Alterações no comportamento de validação
de certificado e criptografia.
A prática de segurança recomendada é usar criptografia e instalar um certificado no

servidor para ele. Confira Criptografia e validação de certificado. Para recusar essa
segurança aprimorada, defina Criptografar como Opcional (Falso).
Se você não definir Criptografar como opcional com o Visual Studio 17.8 ou posterior,
que usa a versão 4.0 do Microsoft.Data.SqlClient, a criptografia usa obrigatório como
padrão. Essa é uma alteração significativa do comportamento em versões anteriores. Se
você não tiver um certificado válido ou não escolher o Certificado de Servidor
Confiável, você receberá a seguinte mensagem de erro:
A criptografia foi habilitada nessa conexão, revise sua configuração de SSL e

certificado para o SQL Server de destino ou ative "Confiar no certificado do
servidor" na caixa de diálogo de conexão.
Informações adicionais
Uma conexão com o servidor foi estabelecida com êxito, mas ocorreu um erro
durante o processo de logon. (provedor: provedor SSL, erro: 0 – a cadeia de
certificados foi emitida por uma autoridade que não é confiável.) (Microsoft SQL
Server)
Tipos de autenticação
Você pode escolher entre uma variedade de tipos de autenticação que abrangem uma
ampla gama de cenários. Para obter detalhes, confira os tipos de autenticação.
No Visual Studio 17.8 e posterior, os nomes das opções de autenticação para conexões
SQL foram atualizados para refletir a alteração de nome do Active Directory para o
Microsoft Entra.
Abrir um arquivo de banco de dados MDF
O arquivo .mdf significa Arquivo de Banco de Dados Mestre e é um banco de dados
SQL empacotado em um arquivo. Esses arquivos têm um .ldf (Arquivo de Banco de
Dados de Log) associado que contém os logs desse banco de dados. Você pode criar
bancos de dados armazenados em arquivos .mdf adicionando um item de Banco de
Dados baseado em serviço ao projeto. Confira Criar um banco de dados e adicionar
tabelas.
Se você já tiver um arquivo .mdf no projeto, clique duas vezes ou clique com o botão
direito do mouse e escolha Abrir para abri-lo no Gerenciador de Servidores.
Para abrir um arquivo .mdf que não está em seu projeto no Gerenciador de Servidores
do Visual Studio, siga estas etapas:
1. Na caixa de diálogo Adicionar conexão, em Fonte de Dados, escolha Arquivo de

Banco de Dados do Microsoft SQL Server (SqlClient).
2. Use o botão Procurar para localizar e selecionar o arquivo de banco de dados

mestre (arquivo .mdf ) ou insira o caminho na caixa Nome do arquivo de banco de
dados.
3. Escolha um método de autenticação.
4. Teste a conexão e, se for bem-sucedida, escolha OK. Um nó do banco de dados é

aberto no Gerenciador de Servidores.
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 ou um novo provedor de dados ADO.NET. O novo provedor
pode solicitar suas credenciais, dependendo de como você o configurou.
７ Observação
Se você estiver usando o Visual Studio 2022 para se conectar a provedores de
dados OLEDB ou ODBC, precisará estar ciente de que o Visual Studio 2022 agora é
um processo de 64 bits.
Isso significa que algumas das ferramentas de dados do Visual Studio não 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 você precisar manter aplicativos de 32 bits que se conectam ao OLEDB ou ao

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 Conjunto de Dados, você 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
foi um processo de 32 bits foi o Visual Studio 2019.
Se você planeja converter o projeto para que seja de 64 bits, precisará atualizar as
conexões de dados OLEDB e ODBC para usar provedores de dados de 64 bits.
Se 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 ACE (Mecanismo de
Banco de Dados do Access). Confira Provedor OLE DB para Jet e Driver ODBC são
versões exclusivas de 32 bits para obter mais informações.
Se você estiver usando um provedor de dados de terceiros, recomendamos entrar

em contato com seu fornecedor para ver se ele poder oferecer 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 ela não for bem-
sucedida, você precisará solucionar os 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 do Visual Studio que realmente significa um modelo de dados baseado no
banco de dados ou serviço subjacente.
Conectar-se usando o Pesquisador de Objetos

do SQL Server
A experiência poderá ser mais fácil se você usar Pesquisador de Objetos do SQL Server,
pois verá uma caixa de diálogo que fornece mais ajuda para localizar bancos de dados
disponíveis localmente, na rede local e em suas assinaturas do Azure, fornecendo um
histórico de opções usadas recentemente.
Para acessar a caixa de diálogo conectar a partir do Pesquisador de Objetos do SQL

Server, clique no botão da barra de ferramentas Adicionar SQL Server.
A caixa de diálogo conectar é exibida. Escolha seu servidor local, de rede ou do SQL do
Azure, selecione um banco de dados, forneça credenciais e escolha Conectar.
Se você precisar definir outras configurações na cadeia de conexão, poderá usar o link
Avançado, que mostra todas as configurações. Por exemplo, para se conectar a um
banco de dados LocalDB baseado em um arquivo MDF, escolha Avançado e defina a
propriedade AttachDbFilename.
Depois que você terminar de configurar a conexão, o servidor e o banco de dados serão
mostrados na janela Pesquisador de Objetos do SQL Server.
A partir daí, você pode navegar no banco de dados, gravar e executar consultas, editar
dados, procedimentos e funções armazenados e executar outras ações diretamente no
Visual Studio.
Próximas etapas
Se você estiver usando o .NET Framework (não .NET Core, .NET 5 ou posterior) e o
Windows Forms ou WPF, poderá usar a janela Fontes de Dados, por exemplo, para
configurar a associação de dados para os controles nos aplicativos Windows Forms e
WPF. Confira Adicionar novas fontes de dados. Essas ferramentas foram projetadas para
permitir que você crie rapidamente aplicativos do Windows que precisam permitir que
os usuários insiram, exibam e manipulem dados.
Se você estiver usando o .NET 5 ou posterior, o .NET Core ou o ASP.NET Core, poderá
conectar seu aplicativo ao banco de dados usando os Serviços Conectados. Usando os
serviços conectados, você pode usar facilmente um banco de dados de
desenvolvimento local, hospedado pelo SQL LocalDB, o SQL Server em execução em um
contêiner ou uma instância local do SQL Server e, em seguida, fazer a transição para o
Banco de Dados SQL do Azure quando estiver pronto para implantar na nuvem. Com o
.NET 5 ou posterior, o .NET Core e o ASP.NET Core, você deve considerar o uso do Entity
Framework Core como sua estrutura de banco de dados.
Comentários

Salvar e editar cadeias de conexão de
banco de dados para aplicativos do .NET
Framework
Artigo • 12/01/2024
７ Observação

mais simples.
７ Observação
Este artigo fornece diretrizes para lidar com cadeias de conexão em aplicativos
Windows. No caso de aplicativos Web e de nuvem, há técnicas mais seguras
disponíveis. É possível usar os Serviços Conectados a fim de adicionar o suporte a
Secrets.json para o desenvolvimento local e, ao realizar a implantação no Azure,
migrar para o Azure Key Vault a fim de obter o armazenamento de segredos.
Confira Proteger segredos durante o desenvolvimento.
É necessário ter cuidado para lidar corretamente com a cadeia de conexão em um

aplicativo do Visual Studio, a fim de evitar a possibilidade de riscos de segurança.
Frequentemente, as cadeias de conexão em aplicativos do Visual Studio são salvas no
arquivo de configuração de aplicativo (também conhecido como configurações de
aplicativo) ou são codificadas diretamente no aplicativo. Não é recomendado realizar a
codificação diretamente no aplicativo, pois as informações confidenciais na cadeia de
conexão, como as credenciais do banco de dados, podem ser lidas diretamente dos
binários não criptografados. 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. As 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.
No caso dos bancos de dados que oferecem esse suporte, 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 sua 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
compilar sua cadeia de conexão.
Editar cadeias de conexão armazenadas nas

configurações de 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 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 sua conexão com a caixa de diálogo Propriedades da
Conexão.
Editar cadeias de conexão para conjuntos de

dados
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 conjunto de dados
1. No Gerenciador de Soluções, clique duas vezes no conjunto de dados (arquivo
.xsd ) que possui a conexão que deseja editar.
2. Selecione o TableAdapter ou a consulta que possui a conexão que 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 Connection 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.
Adicionando conexões
Conectar-se a um banco de dados do
Access em aplicativos do .NET
Framework
Artigo • 04/02/2025
７ Observação
Conjuntos de dados e classes relacionadas são tecnologias herdadas do .NET

com dados na memória enquanto os aplicativos são desconectados do banco de
dados. As tecnologias são especialmente úteis para aplicativos que permitem que
os usuários modifiquem dados e persistam as alterações no banco de dados.
Embora os conjuntos de dados tenham se mostrado uma tecnologia muito bem-
sucedida, recomendamos que novos aplicativos .NET usem Entity Framework Core.
O Entity Framework fornece uma maneira mais natural de trabalhar com dados
tabulares como modelos de objeto e tem uma interface de programação mais
simples.
Você pode se conectar a um banco de dados do Access (um arquivo .mdb ou um

arquivo .accdb ) usando o Visual Studio. Depois de definir a conexão, os dados serão
exibidos na janela Fontes de Dados. A partir daí, você pode arrastar tabelas ou exibições
para sua superfície de design.
７ Observação
Se você estiver usando o Visual Studio para se conectar aos bancos de dados do
Access, 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 2019 e anteriores só poderão se conectar
aos bancos de dados do Access usando provedores de dados de 32 bits.
Se você estiver usando o Visual Studio 2022 para se conectar aos bancos de dados
do Access, precisará estar ciente de que o 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 aos bancos de dados do Access usando provedores de
dados de 32 bits.
Se você precisar manter aplicativos de 32 bits que se conectam aos bancos de
dados do Access, 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 Conjunto de Dados, 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 foi um processo de 32 bits foi o 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 ACE (Mecanismo de Conectividade de Acesso). Confira
Provedor OLE DB para Jet e Driver ODBC são versões exclusivas de 32 bits para
obter mais informações.
Pré-requisitos
Para usar esses procedimentos, você precisa:
Visual Studio
Um projeto do Windows Forms ou do WPF
Um banco de dados do Access (arquivo .accdb ) ou um banco de dados do Access
2000-2003 (arquivo .mdb ). Siga o procedimento que corresponde ao tipo de
arquivo.
Criar um conjunto de dados para um arquivo

.accdb
Conecte-se a bancos de dados criados com o Microsoft 365, Access 2016, Access 2013,
Access 2010 ou Access 2007 usando o procedimento a seguir.
1. Abra um projeto de aplicativo do Windows Forms ou do 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 do Windows>. Ou, no teclado, pressione Shift+Alt+D.

Captura de tela
4. Selecione Banco de Dados na página Escolher um Tipo de Fonte de Dados e

selecione Avançar.
5. Selecione Conjunto de dados na página Escolher um Modelo de Banco de Dados

e, em seguida, selecione Avançar.
6. Na página Escolher 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 Dados do
Microsoft Access , clique no 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. A opção provedor de
dados do .NET Framework para o OLE DB já está pré-selecionada. Escolha OK.
8. Selecione Procurar ao lado de Nome do arquivo de banco de dados, navegue até
o arquivo .accdb e selecione Abrir.
７ Observação
Se o número de bit (32 ou 64 bits) do Microsoft Office e do Visual Studio não

corresponder, você verá um erro ao se conectar a um banco de dados do
Access. No Visual Studio 2019, você receberá um erro de que o provedor de
banco de dados não está registrado. No Visual Studio 2022, você verá um
erro que não pode se conectar a um provedor de dados de 32 bits. Para
resolver esse erro, verifique se você está usando uma versão de 32 bits do
Office, está usando o Visual Studio 2019 ou anterior; para uma versão de 64
bits do Office, você precisa do Visual Studio 2022 ou posterior.
9. Insira um nome de usuário e senha (se necessário) e escolha OK.
10. Selecione Avançar na página Escolher a Conexão de Dados.
Você pode obter uma caixa de diálogo informando que o arquivo de dados não
está em seu projeto atual. Selecione Sim ou Sem.
11. Selecione Avançar na página Salvar cadeia de conexão no arquivo de
Configuração de Aplicativo.

13. Selecione as tabelas ou visualizações que você deseja incluir no conjunto de dados
e, em seguida, selecione Concluir.
O conjunto de dados é adicionado ao seu projeto, e as tabelas e visualizações

aparecem na janela Fontes de Dados.
14. Em computadores de 64 bits com o mecanismo de banco de dados do Access de

64 bits, você precisa garantir que o aplicativo seja executado como um aplicativo
de 64 bits. Abra as propriedades do projeto (pressione Alt+Enter ou clique com o
botão direito do mouse no nó do projeto e selecione Propriedades). Na guia Criar,
desmarque a caixa de seleção Preferir 32 bits.
A cadeia de conexão é armazenada em app.confige no arquivo Settings.settings em

Properties no Gerenciador de Soluções.
Criar um conjunto de dados para um arquivo

.mdb
Conecte-se aos bancos de dados criados com o Access 2000-2003 usando o
procedimento a seguir.
1. Abra um projeto de aplicativo do Windows Forms ou do WPF no Visual Studio.
2. No menu Exibir, selecione Outras Fontes de Dados do Windows>.
3. Na janela de Fontes de Dados, clique em Adicionar Nova Fonte de Dados.

selecione Avançar.
5. Selecione Conjunto de dados na página Escolher um Modelo de Banco de Dados

e, em seguida, selecione Avançar.
6. Na página Escolher 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 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 do Banco de Dados, especifique o caminho e o nome do

arquivo .mdb ao qual você deseja se conectar e, em seguida, selecione OK.
9. Selecione Avançar na página Escolher a Conexão de Dados.
10. Selecione Avançar na página Salvar cadeia de conexão no arquivo de

Configuração de Aplicativo.
12. Selecione quais tabelas ou exibições deseja ter no conjunto de dados e selecione
Concluir.
O conjunto de dados é adicionado ao seu projeto, e as tabelas e exibições
aparecem na janela de Fontes de Dados .
Exibir o código gerado

As ferramentas de dados são configuradas para gerar muito código automaticamente
quando você executa determinadas operações no Designer de Formulários. Por
exemplo, quando você arrasta e solta uma tabela no formulário, um DataGridView é
adicionado e o código é criado para conectar os dados com o controle. Você pode
exibir esse código no arquivo *.Designer.cs . O código gerado pode ser diferente
dependendo da sua versão do Visual Studio.
Parabéns! Com uma pequena ajuda do Visual Studio, você criou uma experiência de
edição baseada em formulário para uma tabela de dados do Access.
Próximas etapas
O conjunto de dados que você acabou de criar está disponível na janela de Fontes de
Dados. Agora você pode executar qualquer uma das seguintes tarefas:
Selecione itens na janela Fontes de Dados e arraste-os para sua superfície de

design ou formulário (confira Associar controles do Windows Forms a dados no
Visual Studio ou Visão geral da associação de dados do WPF).
Abra a fonte de dados no designer de conjunto de dados para adicionar ou editar

os objetos que compõem o conjunto de dados.
Adicione lógica de validação ao evento ColumnChanging ou RowChanging das

tabelas de dados no conjunto de dados (consulte Validar dados em conjuntos de
dados).
Adicionar conexões
visão geral da associação de dados do WPF
Associação de dados do Windows Forms
Comentários

Adicionar fontes de dados em
aplicativos ADO.NET (.NET Framework)
Artigo • 04/09/2024
Ao trabalhar com ferramentas de dados .NET no Visual Studio, você pode adicionar
fontes de dados (objetos .NET) para conectar seu aplicativo .NET a informações em
armazenamentos de dados. Os designers do Visual Studio podem consumir a saída da
fonte de dados de modo a gerar o código clichê que associa os dados aos formulários
quando você arrasta e remove objetos de banco de dados da janela Fontes de Dados.
Exemplos de fontes de dados incluem:
Uma classe em um modelo do Entity Framework associado a algum tipo de banco

de dados
Um conjunto de dados associado a algum tipo de banco de dados
Uma classe que representa um serviço de rede, como serviço de dados WCF
(Windows Communication Foundation) ou um serviço REST
Uma classe que representa um serviço do SharePoint
Uma classe ou coleção em sua solução
７ Observação

mais simples.
Pré-requisitos
Um aplicativo que implementa objetos Windows Forms ou Windows Presentation
Format (WPF) segmentados ao .NET Framework. Você pode criar esse tipo de
aplicativo com um modelo no Visual Studio quando sua instalação incluir a carga
de trabalho de desenvolvimento do .NET Desktop. Para obter mais informações,
confira Modificar cargas de trabalho, componentes e pacotes de idiomas do Visual
Studio.
） Importante
Os recursos descritos neste artigo não têm suporte para o desenvolvimento

do .NET Core para WPF ou Windows Forms.
O aplicativo deve usar recursos de associação de dados: conjuntos de dados, o

Entity Framework, o LINQ (Language Integrated Query) para SQL, serviço Dados
WCF ou SharePoint.
 Dica
Quando o aplicativo não usa um ou mais destes componentes, o conceito de

"fonte de dados" não se aplica. Nestes cenários, você pode se conectar
diretamente ao banco de dados usando objetos de classe SqlCommand.
Trabalhar com fontes de dados e os formulários

do Windows
Você cria e edita fontes de dados para o .NET Framework usando o Assistente de
Configuração da Fonte de Dados em um aplicativo Windows Forms ou Windows
Presentation Foundation. Você pode criar uma fonte de dados a partir de um banco de
dados, serviço, objeto ou uma lista do SharePoint:
Depois de criar fontes de dados, elas ficam visíveis na janela Fontes de Dados. Quando
seu projeto estiver aberto no Visual Studio, você poderá acessar essa janela
selecionando Exibir>Outras janelas>Fontes de dados. Você também pode usar o atalho
de teclado Shift+Alt+D.
Em um projeto de Windows Forms direcionado à .NET Framework (não .NET Core ou

.NET 5 ou posterior), você pode arrastar uma fonte de dados da janela Fontes de Dados
para uma superfície ou controle de design de formulário do Windows. Alguns exemplos
de como você pode conectar uma fonte de dados a um formulário são estas:
Arraste uma tabela para obter um BindingNavigator e um DataGridView para a

tabela.
Arraste uma coluna específica para obter um BindingNavigator com um Rótulo e

TextBox para a coluna.
Arraste todas as colunas da tabela para obter um formulário de exibição de dados

completo para a tabela.
Essas ações acionam o Visual Studio para gerar um código clichê que mostra os dados
do armazenamento de dados. O exemplo a seguir apresenta um conjunto de dados
solto em um formulário do Windows. Se você selecionar F5 no aplicativo, os dados do
banco de dados subjacente serão exibidos nos controles do formulário.
Criar fonte de dados de banco de dados ou
arquivo de banco de dados
Você pode criar um conjunto de dados ou um modelo do Entity Framework para usar
como fonte de dados para um banco de dados ou arquivo de banco de dados com o
Assistente de Configuração de Fonte de Dados. Se sua configuração usar o Entity
Framework, primeiro crie suas Classes de entidade e, depois, use o assistente para criar
fontes de dados.
Criar conjuntos de dados como fontes de dados

O Assistente de Configuração de Fonte de Dados fornece a opção de criar uma fonte
de dados conectando-se a um banco de dados. Você pode escolher os objetos de
banco de dados a usar como o conjunto de dados para o seu aplicativo.
Siga estes passos para criar um conjunto de dados como fonte de dados:
1. No Visual Studio, selecione Projeto>Adicionar Nova Fonte de Dados para abrir o

Assistente de Configuração de Fonte de Dados.
2. Para o tipo de fonte de dados, selecione o Banco de dados.
3. Para o modelo de banco de dados, selecione o Conjunto de dados.
4. Siga os prompts para especificar uma nova ou existente conexão de banco de

dados ou um arquivo de banco de dados.
5. Selecione os objetos de banco de dados a incluir no conjunto de dados e conclua

o assistente.
Para instruções detalhadas sobre como concluir o assistente, consulte Criar e configurar
conjuntos de dados no .NET Framework com o Visual Studio.
Criar modelo do Entity Framework como uma fonte de

dados
Quando sua configuração usa o Entity Framework, você cria primeiro suas classes de
Entidade e, depois, usa o Assistente de Configuração de Fonte de Dados para criar a
fonte de dados.
Siga estas etapas para criar um modelo do Entity Framework como uma fonte de dados
com o Assistente de Modelo de Dados de Entidade:
1. Selecione Projeto>Adicionar novo item. A caixa de diálogo Adicionar Novo Item

é aberta.
2. Na caixa de diálogo, selecione Modelo de Dados de Entidade ADO.NET, insira um

nome para a instância do modelo e selecione Adicionar:
O Assistente do Modelo de Dados de Entidade será aberto.
3. No assistente, selecione o método para gerar o modelo do Entity Framework:
EF Designer no banco de dados: cria um modelo no Entity Framework

Designer com base em um banco de dados existente. Você pode escolher a
conexão com o banco de dados, as configurações do modelo e os objetos de
banco de dados a incluir no modelo. As classes com as quais seu aplicativo
interage são geradas do modelo.
Modelo vazio do EF Designer: cria um modelo vazio no Entity Framework

Designer como ponto de partida para criar visualmente seu modelo. Depois,
você pode gerar um banco de dados a partir do modelo. As classes com as
quais seu aplicativo interage são geradas do modelo.
Modelo vazio do Code First: cria um modelo vazio do Code First como
ponto de partida para criar seu modelo usando código. Depois, você pode
gerar um banco de dados a partir do modelo.
Code First do banco de dados: cria um modelo Code First com base em um
banco de dados existente. Você pode escolher a conexão com o banco de
dados, as configurações do modelo e os objetos de banco de dados a incluir
no modelo.
Depois de escolher, selecione Avançar para continuar no assistente.
4. Adicione o modelo como a fonte de dados para o seu aplicativo e conclua o

assistente.
Para instruções detalhadas sobre como concluir o assistente, consulte Criar classes
de modelo com o Entity Framework (C#).
5. Depois de gerar classes para o modelo, você pode criar uma fonte de dados com
base em um objeto com o Assistente de Configuração de Fonte de Dados.
Selecione as tabelas (ou colunas individuais), procedimentos armazenados,

funções e exibições do modelo para usar no conjunto de dados.
Para instruções detalhadas, consulte Criar fonte de dados a partir do objeto.

Criar fonte de dados a partir do serviço
O Assistente de Configuração de Fonte de Dados dá suporte à criação de uma fonte de
dados a partir de um serviço. Nesta abordagem, o Visual Studio adiciona uma referência
de serviço ao projeto e cria objetos proxy que correspondam aos objetos retornados
pelo serviço. Quando um serviço retorna um conjunto de dados, o serviço é
representado no projeto como um conjunto de dados. Se o serviço retornar um tipo
específico, o serviço será representado no projeto como o tipo retornado.
Você pode criar uma fonte de dados dos seguintes tipos de serviços:
WCF Data Services
Serviços WCF
Serviços da Web
７ Observação
Os itens na janela Fontes de Dados são dependentes dos dados retornados pelo
serviço. Alguns serviços podem não fornecer informações suficientes para o
Assistente de Configuração de Fonte de Dados criar objetos associáveis. Depois
de concluir o assistente, se o serviço retornar um conjunto de dados se tipo,
nenhum item aparecerá na janela Fontes de dados. Conjuntos de dados sem tipo
não fornecem um esquema. Portanto, o assistente não tem informações suficientes
para criar a fonte de dados.
Siga estes passos para criar uma fonte de dados de um serviço:

2. Para o tipo de fonte de dados, selecione o Serviço.
A caixa de diálogo Adicionar referência do serviço será aberta. Você também

pode acessar essa caixa de diálogo clicando com o botão direito do mouse em seu
projeto no Gerenciador de soluções e selecionando Adicionar referência de
serviço.
Criar uma fonte de dados a partir de um objeto

O Assistente de Configuração de Fonte de Dados também permite criar uma fonte de
dados a partir de qualquer objeto que exponha uma ou mais propriedades públicas.
Todas as propriedades públicas de um objeto são visíveis na janela Fontes de Dados. Se

você estiver usando o Entity Framework com um modelo gerado, esta janela
apresentará as classes de entidade que são as fontes de dados para seu aplicativo.
７ Observação
Para dar suporte à associação de dados de arrastar e soltar, os objetos que

implementam a interface ITypedList ou IListSource devem ter um construtor
padrão. Caso contrário, o Visual Studio não poderá instanciar o objeto de fonte de
dados e ele mostrará um erro quando você arrastar o item para a superfície de
design.
Siga estes passos para criar uma fonte de dados de um objeto:

2. Para o tipo de fonte de dados, selecione o Objeto.
3. Na página Selecionar objetos de dados, expanda os nós na exibição de árvore

para localizar os objetos aos quais você deseja associar.
A exibição de árvore contém nós para seu projeto e para assemblies e outros
projetos referenciados pelo seu projeto.
a. Para vincular a um objeto em um assembly ou projeto que não aparece na

exibição em árvore, selecione Adicionar referência.
b. Use a caixa de diálogo Gerenciador de referências para adicionar uma

referência à assembly ou projeto. Depois de adicionar a referência, o Visual
Studio adiciona o assembly ou projeto à exibição de árvore.
７ Observação
Talvez seja necessário criar o projeto que contém seus objetos antes que os
objetos apareçam no modo de exibição de árvore.
Criar fonte de dados a partir de uma lista do
SharePoint
Você também pode usar o Assistente de Configuração de Fonte de Dados para criar
uma fonte de dados de uma lista do SharePoint. O SharePoint expõe dados por meio de
WCF Data Services, portanto, criar uma fonte de dados do SharePoint é o mesmo que
criar uma fonte de dados de um serviço.
７ Observação
Essa abordagem requer o SDK do SharePoint.
Siga estes passos para criar uma fonte de dados de uma lista do SharePoint:

2. Para o tipo de fonte de dados, selecione o SharePoint.
3. Use a caixa de diálogo Adicionar Referência de Serviço para se conectar ao

serviço de dados do SharePoint apontando ao SharePoint Server.
Explore ferramentas de dados do Visual Studio para .NET
Criar e configurar conjuntos de dados no .NET Framework com o Visual Studio
Comentários
Ferramentas do LINQ to SQL no Visual
Studio
Artigo • 10/02/2025
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 em desenvolvimento ativo. Use LINQ to SQL ao manter um
aplicativo herdado que já o está usando ou em aplicativos simples que usam o SQL
Server e não exigem mapeamento de várias tabelas. Em geral, novos aplicativos devem
usar o Entity Framework quando uma camada de mapeamento relacional de objeto é
necessária.
Instalar as ferramentas do LINQ to SQL

No Visual Studio, você cria classes do LINQ to SQL que representam tabelas SQL usando
o Designer Relacional de Objetos (Object Relational Designer). O designer relacional
de objetos é a interface do usuário para edição de arquivos .dbml . Editar arquivos
.dbml com uma superfície de designer requer as ferramentas 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 LINQ para SQL, inicie o instalador do Visual Studio, escolha
Modificar, selecione a guia Componentes Individuais, e depois selecione Ferramentas
LINQ para SQL na categoria Ferramentas de Código.
O que é o Designer O/R

O Designer O/R tem duas áreas distintas em sua superfície de design: o painel
entidades à esquerda e o painel métodos à direita. O painel entidades é a superfície de
design principal que exibe as classes de entidade, 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 Designer Relacional de Objetos fornece uma superfície de design visual para criar
associações (relações) e classes de entidade do LINQ to SQL baseadas em objetos em
um banco de dados. Em outras palavras, o designer O/R cria um modelo de objeto em
um aplicativo que se relaciona com objetos presentes em um banco de dados. Ele
também gera um DataContext fortemente tipado que envia e recebe dados entre as
classes de entidade e o banco de dados. O Designer Relacional de Objetos também
fornece funcionalidade para mapear procedimentos armazenados e funções para
métodos DataContext para retornar dados e preencher classes de entidade. Por fim, o
Designer Relacional de Objetos permite criar relações de herança entre classes de
entidade.
Abrir o designer relacional de objetos

Para adicionar um modelo de entidade LINQ ao SQL ao seu projeto, escolha
Project>Adicionar Novo Iteme selecione LINQ para Classes SQL na lista de itens de
projeto:
O 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 , o Visual Studio exibe a superfície do Designer
O/R, que permite criar visualmente o modelo. A ilustração a seguir mostra o designer
após as tabelas Northwind Customers e Orders terem sido arrastadas do Explorador de
Servidores . Observe a relação entre as tabelas.
） Importante
O designer O/R é um mapeador 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 1:1 com uma tabela ou exibição de
banco de dados. Não há suporte para mapeamento complexo, como mapeamento
de 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 apenas as alterações feitas na superfície do
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 . 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 do Designer O/R, consulte Como: estender o
código gerado pelo designer O/R.
Criar e configurar o DataContext

Após você adicionar um item de Classes do LINQ to SQL a um projeto e abrir o
Designer Relacional de Objetos, a superfície de design vazia representa um
DataContext vazio 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
classe DataContext, confira Métodos DataContext (Designer Relacional de Objetos).
Criar classes de entidade que mapeiam para
tabelas de banco de dados e exibições
Você pode criar classes de entidade mapeadas para tabelas e views arrastando tabelas e
views de banco de dados do Server Explorer ou do Database Explorer para o Designer
O/R. Conforme indicado na seção anterior, o DataContext é configurado com
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
do Designer O/R, você poderá alterar a conexão para o DataContext. Para saber mais,
confira Como criar classes do LINQ to SQL mapeadas para tabelas e exibições (Designer
Relacional de Objetos).
Criar métodos DataContext que chamam

funções e procedimentos armazenados
Você pode criar métodos DataContext que chamam (são mapeados para) funções e
procedimentos armazenados arrastando-os do Gerenciador de Servidores ou do
Gerenciador de Banco de Dados para o Designer Relacional de Objetos.
Procedimentos e funções armazenados são adicionados ao designer O/R como
métodos do DataContext.
７ Observação
Quando você arrasta procedimentos armazenados e funções do Explorador de

Servidores ou do Explorador de Banco de Dados para o Designer O/R , o tipo de
retorno do método DataContext gerado difere dependendo de onde você
descartar o item. Para obter mais informações, confira métodos DataContext
(Object Relational Designer).
Configurar um DataContext para usar

procedimentos armazenados para 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 de tempo
de execução padrão do LINQ to SQL, 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 (Designer O/R).
Herança e Designer Relacional de Objetos

Assim como outros objetos, as classes LINQ to SQL podem usar herança e ser derivadas
de outras classes. Em um banco de dados, as relações de herança são criadas de várias
maneiras. O Designer Relacional de Objetos dá suporte ao conceito de herança de
tabela única, pois geralmente é implementado em sistemas relacionais. Para obter mais
informações, consulte Como configurar a herança usando o designer O/R.
Consultas do LINQ to SQL

As classes de entidade criadas pelo Designer Relacional de Objetos foram projetadas
para uso com LINQ (consulta integrada à linguagem). Para obter mais informações,
consulte Como consultar informações.
Separe o código gerado do DataContext e da

classe de entidade em namespaces diferentes.
O Designer Relacional de Objetos fornece as propriedades de Namespace do Contexto
e Namespace da Entidade no DataContext. Essas propriedades determinam em qual
namespace o DataContext e o código da classe de entidade são gerados. Por padrão,
essas propriedades estão vazias e as classes DataContext e entidade são geradas no
namespace do aplicativo. Para gerar o código em um namespace diferente do
namespace do aplicativo, insira um valor nas propriedades Namespace de Contexto
e/ou Namespace de Entidade.
Conteúdo de referência
System.Linq
System.Data.Linq
Consulte também
LINQ to SQL (.NET Framework)
Perguntas frequentes (.NET Framework)
Comentários

Alterar o tipo de retorno de um método
DataContext (Designer Relacional de
Objetos)
Artigo • 12/01/2024
O tipo de retorno de um método DataContext (criado de acordo com uma função ou

um procedimento armazenado) difere dependendo de onde você ignora a função ou o
procedimento armazenado no O/R Designer. 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 O/R Designer, um método
DataContext que retorna um tipo 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.
７ Observação
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 de
DataContext para retornar um tipo gerado automaticamente, você deve arraste o
objeto de banco de dados original no Designer Relacional de Objetos novamente.
７ Observação
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 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 essa classe ou crie-a no O/R Designer 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 método de DataContext no painel Métodos e exclua-o.
2. Arraste o objeto de banco de dados do Gerenciador de Servidores ou do

Gerenciador de Banco de Dados para uma área vazia do O/R Designer.
3. Salve o arquivo .dbml .
LINQ to SQL
Métodos DataContext (Designer Relacional de Objetos)
Como criar métodos DataContext mapeados para procedimentos armazenados e
funções (Designer Relacional de Objetos)
Criar métodos DataContext mapeados
para procedimentos armazenados e
funções (Designer Relacional de
Objetos)
Artigo • 12/01/2024
Você pode adicionar procedimentos armazenados e funções ao Designer de O/R como

métodos DataContext. 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 métodos DataContext, confira Métodos DataContext (Designer
７ Observação
Os procedimentos armazenados também podem ser usados para substituir o

comportamento padrão em tempo de execução de LINQ to SQL, que executa
inserções, atualizações e exclusões quando alterações são salvas de classes de
entidade para um banco de dados. Para obter mais informações, confira Como
atribuir procedimentos armazenados para executar atualizações, inserções e
exclusões (Designer Relacional de Objetos).
Criar métodos DataContext

Você pode criar métodos DataContext arrastando procedimentos ou funções
armazenadas do Gerenciador de Servidores ou **Gerenciador de Banco de Dados para
o Designer Relacional de Objetos.
７ Observação
O tipo de retorno do método DataContext gerado varia de acordo com o local

onde você solta o procedimento armazenado ou a função no Designer Relacional
de Objetos. 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 Designer Relacional de Objetos cria um método DataContext
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, confira Como alterar o tipo de retorno de um método DataContext
(Designer Relacional de Objetos).
７ Observação
Para criar métodos DataContext que retornam tipos

gerados automaticamente
1. No Gerenciador de Servidores ou no 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

Designer Relacional de Objetos.
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. No Gerenciador de Servidores ou no 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 Designer Relacional de Objetos.
O método DataContext é criado com o tipo de retorno da classe de entidade

selecionada e aparece no painel Métodos.
７ Observação
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).
Passo a passo: criando classes LINQ to SQL
LINQ to SQL
Introdução a LINQ no Visual Basic
LINQ em C#
Configurar a herança usando o Designer
Relacional de Objetos
Artigo • 09/04/2024
O Designer Relacional de Objetos (Designer de O/R) dá suporte ao conceito de

herança de tabela única, pois geralmente é o implementado nos sistemas relacionais.
Na herança de tabela única, há uma tabela de banco de dados individual que contém
campos para informações pai e filho. Com os dados relacionais, uma coluna de
discriminador contém o valor que determina qual classe qualquer registro pertence.
Por exemplo, pense em uma tabela Persons que contém todos os empregados por uma
empresa. Algumas pessoas são funcionários e algumas pessoas são gerentes. A tabela
Persons contém uma coluna chamada EmployeeType que tenha um valor de 1 para
gerentes e um valor de 2 para funcionários; esta é a coluna de discriminador. 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 Relacional de Objetos. Seguir etapas genéricas
sem se referir a uma tabela existente e colunas pode ser difícil, desse modo, é fornecido
um passo a passo que usa dados. 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 Relacional de Objetos adicionando um item Classes LINQ to SQL
a um projeto existente do Visual Basic ou C#.
2. Arraste a tabela que você deseja usar como a classe base no Designer Relacional
de Objetos.
3. Arraste uma segunda cópia da tabela no Designer Relacional de Objetos 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.
７ Observação
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: The property <property
name> cannot be deleted because it is participating in the association
<association name>.
７ Observação
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 das colunas na classe derivada definindo o modificador de herança na
propriedade na classe base. Para obter mais informações, confira Noções
básicas de herança (Visual Basic).
6. Selecione a linha de herança no Designer Relacional de Objetos.
7. Na janela Propriedades, defina a Propriedade Discriminatória como 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 que é
armazenado na coluna discriminatória e é usado para designar a classe herdada.)
9. Defina a propriedade Base Class Discriminator Value como o valor que designa o
registro como um tipo base. (Esse é o valor que é armazenado na coluna
discriminatória 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 discriminatória que não
corresponda ao valor nas propriedades Derived Class Discriminator Value ou Base
Class Discriminator Value, o registro será carregado no tipo designado como o
Padrão de Herança.
LINQ to SQL
Passo a passo: criando classes LINQ to SQL usando a herança de tabela única
Noções básicas de herança (Visual Basic)
Herança
Comentários
Criar classes LINQ to SQL mapeadas
para tabelas e exibições (Designer
Relacional de Objetos)
Artigo • 09/04/2024
As classes LINQ to SQL mapeadas para tabelas de banco de dados e exibições são
chamadas de classes de entidade. A classe de entidade mapeia para um registro,
enquanto as propriedades individuais de uma classe de entidade mapeiam para as
colunas individuais que compõem um registro. Criar classes de entidade baseadas em
tabelas de banco de dados ou exibições arrastando tabelas ou exibições do
Gerenciador de Servidores ou do Gerenciador de Banco de Dados para as ferramentas
LINQ to SQL no Visual Studio. O Designer Relacional de Objetos gera as classes e aplica
os atributos específicos do LINQ to SQL para ativar a funcionalidade do LINQ to SQL (os
recursos de comunicação e edição de dados do DataContext). Para obter informações
detalhadas sobre classes LINQ to SQL, consulte o Modelo de objeto LINQ to SQL.
７ Observação
O Designer O/R é um mapeador de objeto relacional simples porque somente dá

suporte a relações de mapeamento de 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 do Gerenciador de Servidores ou do Gerenciador de
Banco de Dados no Designer O/R cria classes de entidade além dos métodos
DataContext usados para realizar atualizações.
Por padrão, o runtime do LINQ to SQL cria a lógica para salvar as 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 os
procedimentos armazenados para executar inserções, atualizações e exclusões, em vez
de usar o comportamento padrão de runtime do LINQ to SQL. Para obter mais
informações, confira Como atribuir procedimentos armazenados para executar
atualizações, inserções e exclusões (Designer Relacional de Objetos).
７ Observação
Para criar classes LINQ to SQL que são mapeadas para

tabelas ou exibições de banco de dados
1. No Servidor/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 exibição para o Designer Relacional de Objetos.
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 Relacional de Objetos, você
pode criar uma fonte de dados de objeto e preencher a janela Fonte 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, selecione Mostrar Fontes 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.
７ Observação
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.
Modelo de objeto LINQ to SQL
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
Comentários
Estender o código gerado pelo Designer
Relacional de Objetos
Artigo • 30/07/2024
O código gerado por O/R Designer é regenerado quando alterações são feitas a classes
de entidade e outros objetos ocorrem no 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 O/R Designer fornece a
capacidade de gerar os arquivos parciais da classe em que você pode adicionar código
que não é substituído. Um exemplo de adicionar seu próprio código para o código
gerado pelo O/R Designer está adicionando validação de dados para as classes LINQ to
SQL (entidade). Para obter mais informações, consulte Como adicionar validação a
classes de entidade.
７ Observação
Adicionando código a uma classe de entidad
Para criar uma classe parcial e adicione o código para

1. Abra ou crie um novo arquivo de classes de LINQ to SQL (arquivo .dbml ) no
Designer Relacional de Objetos. (Clique duas vezes no arquivo .dbml no
Gerenciador de soluções ou no 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 selecione 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 para um DataContext
Para criar uma classe parcial e adicione o código a um

DataContext
Gerenciador de soluções ou no Gerenciador de banco de dados.)
2. No Designer Relacional de Objetos, clique com o botão direito do mouse em uma

área vazia no designer e selecione 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
Comentários
Criar uma associação entre as classes
LINQ to SQL (Designer Relacional de
Objetos)
Artigo • 12/01/2024
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 as classes de entidade fossem criadas que mapeiam para as
tabelas Northwind Customers e Orders , a classe Customer seria a classe pai e a classe
Order seria a classe filho.
７ Observação
Quando você arrasta tabelas do Gerenciador de Servidores ou Gerenciador de

Banco de Dados no O/R Designer (Object Relational Designer), as associações são
criadas automaticamente de acordo com as 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.
Propriedade Descrição
Cardinalidade Controla se a associação é de um-para-muitos ou um-para-um.
Propriedade Especifica se deve ser criada uma propriedade no pai que é uma coleção ou
Filho referência para os registros filho na parte da chave estrangeira da associação.
Por exemplo, na associação entre Customer e Order , se a Propriedade Filho
for definida como True, uma propriedade chamada Orders será criada na
classe pai.
Propriedade A propriedade na classe filho que referencia a classe pai associada. Por
Parent exemplo, na associação entre Customer e Order , uma propriedade chamada
Customer que referencia o cliente associado para um pedido é criada na classe
Order .
Propriedades Exibe as propriedades de associação e fornece um botão de reticências (...)

participantes 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 de Customers e Orders , as Propriedades de Associação
são CustomerID para cada classe.
5. Clique em OK para criar a associação.
Instruções passo a passo: criar classes LINQ to SQL
LINQ to SQL
Como representar chaves primárias
Adicionar validação a classes de
entidade
Artigo • 12/01/2024
７ Observação

mais simples.
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 fornecem os 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 durante e após as
alterações da coluna individual.
７ Observação
Este tópico fornece as etapas básicas para adicionar validação a classes de entidade
usando o O/R Designer. Como pode ser difícil seguir essas etapas genéricas sem se
referir a uma classe específica de entidade, um explicação passo a passo que usa os
dados reais é fornecida.
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.
７ Observação
Para validar dados durante o valor de uma coluna alterar

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 à qual você

deseja adicionar 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:
VB
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 automaticamente os manipuladores de eventos,

você pode usar o IntelliSense para criar métodos parciais de alteração de colunas.
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 seguinte código lembra o código que é gerado quando você seleciona um
método parcial de alteração de colunas:
C#
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.
７ Observação
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
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 UpdateENTITYCLASSNAME.
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:
VB
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 automaticamente os manipuladores de eventos,

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 de atualização para a classe no qual você deseja adicionar validação. O

seguinte código lembra o código gerado quando você seleciona um método
parcial UpdateCLASSNAME :
C#
partial void UpdateCLASSNAME(CLASSNAME instance)

{
if ((instance.COLUMNNAME == x) && (instance.COLUMNNAME = y))
{
string ErrorMessage = "Invalid data!";
throw new System.Exception(ErrorMessage);
}
}
Validando dados
Passo a passo: personalizar a inserção, a
atualização e o comportamento de
Artigo • 04/05/2023
７ Observação

As ferramentas LINQ to SQL no Visual Studio fornecem uma superfície de design visual
para criar e editar classes LINQ to SQL (classes de entidade) baseadas em objetos em
um banco de dados. Usando LINQ to SQL, você pode usar a tecnologia LINQ para
acessar bancos de dados SQL. Para saber mais, confira LINQ (consulta integrada à
linguagem).
Por padrão, a lógica para executar atualizações é fornecida pelo runtime do LINQ to
SQL. O runtime cria instruções padrão Insert , Update e Delete com base no esquema
da tabela (as definições de coluna e as informações da 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.
７ Observação
Essa explicação passo a passo exige a disponibilidade dos procedimentos
armazenados InsertCustomer, UpdateCustomer e DeleteCustomer para o banco
de dados Northwind.
Essa explicação passo a passo fornece as etapas que você deve seguir para substituir o
comportamento padrão de runtime LINQ to SQL para salvar dados de volta para um
banco de dados usando procedimentos armazenados.
Durante essa explicação passo a passo, é ensinado como realizar as seguintes tarefas:
Crie um novo aplicativo do Windows Forms e adicione um arquivo LINQ to SQL a

ele.
Crie uma classe de entidade que está mapeada para a tabela Customers
Northwind.
Crie uma fonte de dados de objeto que referencia a classe Customer LINQ to SQL.
Crie um Windows Form que contém um DataGridView que está associado à classe
Customer .
Implemente a funcionalidade de salvar para o formulário.
Crie métodos de DataContext adicionando procedimentos armazenados ao O/R

Designer.
Configure a classe Customer para usar procedimentos armazenados para executar

inserções, atualizações e exclusões.
Pré-requisitos
da Northwind.
como parte da carga de trabalho Armazenamento e processamento de dados ou

Studio.) Expanda o nó do SQL Server. Clique com o botão direito do mouse na

alguns dados.

Executar.

Criando um aplicativo e adicionando classes

LINQ to SQL
Como você está trabalhando com classes LINQ to SQL e exibindo os dados em um
Windows Form, crie um novo aplicativo do Windows Forms e adicione um arquivo de
classes LINQ to SQL.
７ Observação
Para criar um novo projeto de aplicativo Windows Forms

que contém classes LINQ to SQL

3. No painel central, selecione o tipo de projeto Aplicativo do Windows Forms.
4. Dê ao projeto o nome UpdatingWithSProcsWalkthrough, em seguida, escolha OK.

O projeto de UpdatingWithSProcsWalkthrough é criado e adicionado ao
Gerenciador de Soluções.
6. Clique no modelo Classes LINQ to SQL e digite Northwind.dbml na caixa Nome.
7. Clique em Adicionar.
Um arquivo de classes LINQ to SQL vazio (Northwind.dbml) é adicionado ao

projeto, e o Object Relational Designer é aberto.
Criando a classe entidade de Cliente e o objeto

de fonte de dados
Crie classes LINQ to SQL que são mapeadas para tabelas de banco de dados arrastando
tabelas do Gerenciador de Servidores ou Database Explorer para o Object Relational
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. No Gerenciador de Servidores ou Database Explorer, localize a tabela Customer
na versão do SQL Server do banco de dados de exemplo Northwind.
2. Arraste o nó Customers do Gerenciador de Servidores ou Database Explorer para

a superfície do *Object Relational 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.
７ Observação
Esse comportamento de renomeação é chamado de pluralização. Ela pode ser

ativada ou desativada na caixa de diálogo Opções. Para obter mais
informações, consulte Como ativar e desativar a pluralização (Object
Relational Designer).
3. No menu Compilar, clique em Compilar UpdatingwithSProcsWalkthrough para
criar o projeto.
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.
７ Observação
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.
Criando um DataGridView para exibir os dados

do cliente em um Windows Form
Crie controles que estão associados a classes de entidade arrastando os itens de fonte
de dados do LINQ to SQL da janela Fontes de Dados para um Windows Form.
Para adicionar controles que estão associados às classes

de entidade
1. Abra Form1 no modo de exibição de Design.
2. Da janela Fontes de Dados, arraste o nó Customer para o Form1.
７ Observação
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 para o formulário, fora de

qualquer método específico, mas dentro da classe Form1 :
C#
C#
private NorthwindDataContext northwindDataContext1

= new NorthwindDataContext();
5. Crie um manipulador de eventos para o evento Form_Load e adicione o seguinte

código ao manipulador:
C#
C#
customerBindingSource.DataSource
= northwindDataContext1.Customers;
Implementar a funcionalidade de salvar

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. Essa seção explica como habilitar o botão de
salvar e implementar a funcionalidade de salvar para objetos LINQ to SQL.
Para implementar a funcionalidade de salvar

1. Abra 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:
C#
C#
northwindDataContext1.SubmitChanges();
Substituindo o comportamento padrão para

realizar 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 O/R Designer. (Clique duas vezes no
arquivo Northwind.dbml no Gerenciador de Soluções.)
2. Em Gerenciador de Servidores/Gerenciador de Banco de Dados, expanda o nó

Procedimentos Armazenados de bancos de dados Northwind e localize os
procedimentos armazenados InsertCustomers, UpdateCustomers e
DeleteCustomers.
3. Arraste os três procedimentos armazenados para o Object Relational Designer.
Os procedimentos armazenados são adicionados ao painel dos métodos como

métodos DataContext. Para obter mais informações, confira métodos DataContext
(Object Relational Designer).
4. Selecione a classe de entidade Customer no Object Relational Designer.
5. Na janela Propriedades, selecione a propriedade Insert.
6. Clique nas reticências (…) ao lado de Usar runtime para abrir a caixa de diálogo
Configurar Comportamento.
7. Selecione Personalizar.
8. Selecione o método InsertCustomers na lista Personalizar.
9. Clique em Aplicar para salvar a configuração para a Classe e o Comportamento

selecionados.
７ Observação
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 com uma oportunidade de aplicar as
alterações será exibida.
10. Selecione Atualizar na lista Comportamento.
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).
７ Observação
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
modificados e não corresponderem entre a tabela e a classe de entidade,
poderá ser preciso selecionar a propriedade da classe equivalente para a qual
mapear se o Designer Relacional de Objetos 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 Comportamento.
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.
７ Observação
Embora isso não seja um problema para essa explicação passo a passo específica,
vale observar que o LINQ to SQL manipula automaticamente os valores gerados
por banco de dados para as colunas identidade (incremento automático),
rowguidcol (GUID gerado por banco de dados) e 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 IsDbGenerated manualmente
como true e AutoSync como um dos seguintes: AutoSync.Always,
AutoSync.OnInsert ou 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 inserido recentemente

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.
７ Observação
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 seus requisitos do aplicativo, há várias etapas que você pode querer
realizar depois de criar as classes de entidade do LINQ to SQL. Entre algumas das
melhorias que você pode fazer neste aplicativo estão:
Implementar verificação de simultaneidade durante atualizações. Para obter

informações, confira Simultaneidade otimista: visão geral.
Adicionar consultas LINQ para filtrar dados. Para obter informações, consulte
Introdução a consultas de LINQ (C#).
Confira também
Métodos DataContext
exclusões
LINQ to SQL
Consultas do LINQ to SQL
Como atribuir procedimentos
armazenados para executar
atualizações, inserções e exclusões
Artigo • 09/03/2023
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 em tempo de execução do LINQ to
SQL que executa inserções, atualizações e exclusões quando alterações são salvas de
classes de entidade em um banco de dados (por exemplo, ao chamar o método
SubmitChanges).
７ Observação
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 em substituir o comportamento padrão.
７ Observação
O LINQ to SQL manipula automaticamente valores gerados por banco de dados

para colunas de identidade (incremento automático), rowguidcol (GUID gerado por
banco de dados) e 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 por banco de dados, você deve definir manualmente
IsDbGenerated como true e AutoSync como um dos seguintes: AutoSync.Always,
AutoSync.OnInsert ou AutoSync.OnUpdate.
Configurar o comportamento de atualização de
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 nos dados em classes de entidade LINQ to
SQL, é fornecida pelo runtime do LINQ to SQL. 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 é o desejado, você pode
configurar o comportamento de atualização atribuindo procedimentos armazenados
específicos para executar as inserções, as atualizações e as 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.
７ Observação
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
2. Em Gerenciador de Servidores 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, confira Métodos DataContext
(Designer Relacional de Objetos).
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 (Insert, Update ou
Delete).
6. Clique nas reticências (...) ao lado das palavras Usar Runtime para abrir a caixa de
diálogo Configurar Comportamento.
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 originais do método
( Original_<ArgumentName> ) para as propriedades originais ( <PropertyName>
(Original) ) para os comandos Update e Delete .
７ Observação
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.
７ Observação
Você poderá continuar configurando o comportamento de cada combinação

de classe e comportamento desde que 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 com uma oportunidade de aplicar as
alterações será exibida.
Para voltar a usar a lógica padrão em runtime para atualizações, clique nas reticências
ao lado do comando Insert, Update ou Delete, na janela Propriedades, e selecione Usar
runtime na caixa de diálogo Configurar Comportamento.
Confira também
Métodos DataContext
Operações de inserção, atualização e exclusão (.NET Framework)
Ligar e desligar a pluralização (Designer
Artigo • 12/01/2024
Por padrão, quando você arrasta os objetos de base de dados que têm nomes que
terminam em s ou em ies de Gerenciador de Servidores ou Gerenciador de Banco de
Dados em Ferramentas de LINQ to SQL no Visual Studio, os nomes das classes de
entidade gerados 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, adicione uma tabela Customers para os resultados de
Designer Relacional de Objetos em uma classe de entidade chamada Customer porque
a classe conterá dados para apenas um cliente.
７ Observação
Pluralization está ativada por padrão somente na versão de língua inglesa do Visual
Studio.
７ Observação
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.
７ Observação
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 = Falso para definir o Designer
Relacional de Objetos de modo que não modifique os nomes de classe.
5. Defina Pluralização de nomes como Habilitado = Verdadeiro para aplicar regras

de pluralização aos nomes de classe de objetos adicionados ao Designer
Relacional de Objetos.
LINQ to SQL
Criar e configurar conjuntos de dados
no .NET Framework usando o Visual
Studio
Artigo • 04/02/2025
７ Observação

simples.
Um conjunto de dados é um conjunto de objetos que armazenam dados de um banco

de dados na memória e dão suporte ao controle de alterações para habilitar operações
CRUD (criar, ler, atualizar e excluir) nesses dados sem a necessidade de estar sempre
conectado ao banco de dados. Conjuntos de dados foram projetados para aplicativos
de negócios simples do tipo formulários sobre dados. Para novos aplicativos, considere
usar o 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 do tipo DataSet no Visual Studio em tempo de
desenvolvimento usando o Assistente de Configuração da Fonte de Dados . Para obter
informações sobre como criar conjuntos de dados programaticamente, consulte Criando
um conjunto de dados (ADO.NET).
Pré-requisitos
um projeto do .NET Framework (não .NET Core ou .NET 5 ou posterior)
Visual Studio com as cargas de trabalho do Desenvolvimento do .NET para

desktop e do Armazenamento e processamento de dados instaladas. Para instalá-
los, abra do Instalador do Visual Studio e escolha Modificar (ou Mais>Modificar)
ao lado da versão do Visual Studio que você deseja modificar.
SQL Server Express LocalDB. Se você não tiver o SQL Server Express LocalDB,
poderá instalá-lo na página de download do SQL Server .
Criar um novo conjunto de dados usando o

Assistente de Configuração da 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 à qual você se conectará.
3. Escolha DataSet na lista de opções.

4. Escolha o banco de dados ou os bancos de dados que serão a fonte de dados do
conjunto de dados.
5. Escolha se deseja salvar a cadeia de conexão em app.config.

6. Escolha as tabelas (ou colunas individuais), procedimentos armazenados, funções e
exibições do banco de dados que você deseja representar no conjunto de dados.
7. Clique em Finalizar.
O conjunto de dados aparece como um nó no Gerenciador de Soluções.
8. Clique no nó do conjunto de dados no Gerenciador de Soluções para abrir o

conjunto de dados no Designer de DataSet. Cada tabela no conjunto de dados
tem um objeto TableAdapter associado, que é representado na parte inferior. O
adaptador de tabela é usado para preencher o conjunto de dados e,
opcionalmente, para enviar comandos para o banco de dados.
9. 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 de chave
estrangeira em um banco de dados são representadas apenas como uma relação,
com as regras de atualização e exclusão definidas como nenhuma. Normalmente,
é isso que você quer. No entanto, você pode clicar nas linhas para abrir a caixa de
diálogo Relação, na qual você pode alterar o comportamento das atualizações
hierárquicas. Para obter mais informações, consulte Relações nos conjuntos de
dados e Atualização hierárquica.
10. Clique em uma tabela, um adaptador de tabela ou um nome de coluna em uma
tabela para ver as respectivas propriedades na janela Propriedades. Você pode
modificar alguns dos valores aqui. Lembre-se apenas de que você está
modificando o conjunto de dados, não o banco de dados de origem.
11. Você pode adicionar novas tabelas ou adaptadores de tabela ao conjunto de
dados, 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 é exibida quando o Designer de DataSet está em foco.
Em seguida, talvez você queira especificar como preencher o conjunto de dados com
dados. Para isso, use o Assistente de Configuração de 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
usado para criar primeiro o conjunto de dados.
1. Clique no nó do conjunto de dados no Gerenciador de Soluções para colocar o

Designer de DataSet em foco.
2. Clique na guia Fontes de Dados na margem esquerda do 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

Configurar Fonte de Dados com Assistente.
4. Use o assistente para especificar quais tabelas adicionais, procedimentos

armazenados ou outros objetos de banco de dados adicionar ao conjunto de
dados.
Adicionar uma tabela de dados autônoma a um

conjunto de dados
1. Abra seu conjunto de dados no Designer de Conjunto de Dados .
2. Arraste uma classe DataTable da guia Conjunto de Dados da Caixa de

Ferramentas para 0 Designer de Conjunto de Dados.
3. Adicione colunas para definir sua 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.
As tabelas independentes precisam implementar a lógica Fill para poder preenchê-las

com dados. Para obter informações sobre como preencher tabelas de dados, consulte
Populando um Conjunto de Dados de um DataAdapter.
relações em conjuntos de dados
preencha conjuntos de dados usando TableAdapters
Comentários

Criar relações entre conjuntos de dados
Artigo • 04/05/2023
７ Observação

Os conjuntos de dados que contêm tabelas de dados relacionadas usam objetos

DataRelation para representar uma relação pai/filho entre as tabelas e para retornar
registros relacionados entre si. A adição de tabelas relacionadas a conjuntos de dados
usando o Assistente de Configuração da Fonte de Dados ou o Designer de Conjunto
de Dados cria e configura o objeto DataRelation para você.
O objeto DataRelation executa duas funções:
Ele pode disponibilizar os registros relacionados a um registro com o qual você

está trabalhando. Ele fornece registros filho se você estiver em um registro pai
(GetChildRows) e um registro pai se você estiver trabalhando com um registro filho
(GetParentRow).
Ele pode impor restrições para 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

objeto DataRelation. Em uma junção verdadeira, os registros são obtidos de tabelas pai
e filho e colocados em um único conjunto de registros simples. Quando você usa um
objeto DataRelation, nenhum novo conjunto de registros é criado. Em vez disso, o
DataRelation controla a relação entre tabelas e mantém os registros pai e filho em
sincronia.
Objetos e restrições do DataRelation
Um objeto DataRelation também é usado para criar e impor as seguintes restrições:
Uma restrição exclusiva, que garante que uma coluna na tabela não contenha
duplicatas.
Uma restrição de chave estrangeira, que pode ser usada para manter a integridade
referencial entre uma tabela pai e filho em um conjunto de dados.
As restrições especificadas em um objeto DataRelation são implementadas criando

automaticamente objetos apropriados ou definindo propriedades. Se você criar uma
restrição de chave estrangeira usando o objeto DataRelation, instâncias da classe
ForeignKeyConstraint serão adicionadas à propriedade DataRelation do objeto
ChildKeyConstraint.
Uma restrição exclusiva é implementada simplesmente definindo a propriedade Unique

de uma coluna de dados como true ou adicionando uma instância da classe
UniqueConstraint à propriedade DataRelation 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 de dados.
Regras de integridade referencial

Como parte da restrição de chave estrangeira, você pode especificar regras de
integridade referencial 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 possíveis estão especificadas na enumeração Rule e listadas na tabela a seguir.
Regra de Ação
restrição
de chave
estrangeira
Cascade A alteração (atualização ou exclusão) feita no registro pai também é feita em

registros relacionados na tabela filho.
Regra de Ação
restrição
de chave
estrangeira
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, eles não têm relação com os registros pai.
Observaçã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 DefaultValue da coluna).
None Nenhuma alteração é feita nos 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 conjunto de dados,

consulte Salvar dados novamente no banco de dados.
Relações somente restrição

Ao criar um objeto DataRelation, você tem a opção de especificar que a relação seja
usada apenas 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 dados 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 registros relacionados.
Por exemplo, uma relação somente restrição impede que você exclua um registro pai
que ainda tenha registros filho e você não pode acessar os registros filho por meio do
pai.
Criar 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 puderem ser
coletadas da fonte de seus dados. Se você adicionar manualmente tabelas de dados da
guia Conjunto de Dados da Caixa de Ferramentas, talvez seja necessário criar a relação
manualmente. Para obter informações sobre como criar objetos DataRelation
programaticamente, consulte Adicionando DataRelations.
As relações entre tabelas de dados aparecem como linhas no Designer de Conjunto de

Dados, com um glifo de infinito e chave representando o aspecto um para muitos da
relação. Por padrão, o nome da relação não aparece na superfície de design.
７ Observação
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, confira Passo a passo: criar 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 para a qual você arrastou o objeto Relation.
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. Esse é o nome do objeto DataRelation real no código.
6. Selecione as colunas que ingressam nas tabelas nas listas Colunas de Chave e
Colunas de Chave Estrangeira.
7. Selecione se deseja criar uma relação, restrição ou ambos.
8. Selecione ou desmarque a caixa Relação Aninhada. A seleção dessa opção define

a propriedade Nested como true e faz com que as linhas filho da relação sejam
aninhadas dentro da coluna pai quando essas linhas são gravadas como dados
XML ou sincronizadas com XmlDataDocument. Para obter mais informações,
consulte Nesting DataRelations.
9. Defina as regras a serem impostas quando você estiver fazendo alterações nos
registros nessas tabelas. Para obter mais informações, consulte Rule.
10. Clique em OK para criar a relação. Uma linha da relação aparece no designer entre
as duas tabelas.
Para exibir um nome da relação no Designer de Conjunto de Dados

Conjunto de Dados.
2. No menu Dados, selecione o comando Mostrar Rótulos da Relação para exibir o

nome da relação. Desmarque esse comando para ocultar o nome da relação.
Confira também
Criar e configurar conjuntos de dados no Visual Studio
Passo a passo: criar um conjunto de
dados para aplicativos do .NET
Framework usando o Designer de
Conjunto de Dados
Artigo • 22/04/2024
７ Observação

mais simples.
Neste passo a passo, você criará um conjunto de dados usando o Designer de Conjunto
de Dados. O artigo leva você pelo processo de criação de um novo projeto e a adição
de um novo item Conjunto de Dados a ele. Você aprenderá a criar tabelas com base em
tabelas em um banco de dados sem usar um assistente.
Pré-requisitos
Para concluir este tutorial, você precisa da carga de trabalho de Desenvolvimento de
área de trabalho do .NET (para a janela Fontes de dados) e da carga de trabalho
Armazenamento e processamento de dados instaladas no Visual Studio. Para instalá-
las, abra Instalador do Visual Studio e escolha Modificar (ou Mais>Modificar) ao lado
da versão do Visual Studio que você deseja modificar. Confira Modificar o Visual Studio.
da Northwind.
Instalador do Visual Studio, o SQL Server Express LocalDB pode ser instalado como
parte da carga de trabalho Armazenamento e processamento de dados ou como
um componente individual.


alguns dados.
c. Cole o script T-SQL no editor de consultas e escolha o botão Executar.
Após um curto período de tempo, a consulta termina de ser executada e o

banco de dados Northwind é criado.
Criar um novo projeto de aplicativo do

Windows Forms
1. No Visual Studio, crie um projeto do Aplicativo do Windows Forms (.NET
Framework) e nomeie-o DatasetDesignerWalkthrough.
O Visual Studio adiciona o projeto ao Gerenciador de Soluções e exibe um novo

formulário no designer.
Adicionar um novo Conjunto de Dados 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 Conjunto de Dados no painel central.
3. Nomeie o Conjunto de Dados como NorthwindDataset e escolha Adicionar.

O Visual Studio adiciona um arquivo chamado NorthwindDataset.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 Servidores.
2. No Gerenciador de Servidores, clique no botão Conectar ao Banco de Dados.
3. Criar uma conexão ao banco de dados de exemplo Northwind.
Criar as tabelas no conjunto de dados

Esta seção explica como adicionar tabelas ao conjunto de dados.
Para criar a tabela Customers

1. Expanda a conexão de dados que você criou no Gerenciador de Servidores e
expanda o nó Tabelas.
2. Arraste a tabela Clientes do Gerenciador de Servidores para o Designer de

Conjunto de Dados.
Tabelas de dados Clientes e CustomersTableAdapter são adicionadas ao conjunto

de dados.
Para criar a tabela Orders

Arraste a tabela Pedidos do Gerenciador de Servidores para o Designer de
Conjunto de Dados.
Uma tabela de dados Pedidos, OrdersTableAdapter e a relação de dados entre as

tabelas Clientes e Pedidos são adicionadas ao conjunto de dados.
Para criar a tabela Detalhes do Pedido

Arraste a tabela Detalhes do Pedido do Gerenciador de Servidores para o
Designer de Conjunto de Dados.
Uma tabela de dados Detalhes do Pedido, OrderDetailsTableAdapter e uma
relação de dados entre as tabelas Pedidos e Detalhes do Pedido são adicionadas
ao conjunto de dados.
Salvar o conjunto de dados

O conjunto de dados recém-criado está disponível na janela Fontes de Dados. Se não
estiver vendo a janela Fontes de dados, verifique se a carga de trabalho
Armazenamento e processamento de dados está instalada conforme mencionado nos
Pré-requisitos.
Agora é possível realizar qualquer uma das seguintes tarefas:
Salve o conjunto de dados.
Selecione itens na janela Fontes de Dados e os arraste para um formulário. Para

obter mais informações, confira Associar controles do Windows Forms a dados no
Visual Studio.
Adicione mais consultas ao TableAdapters.
Adicione a lógica de validação aos eventos ColumnChanging ou RowChanging das

tabelas de dados no conjunto de dados. Para obter mais informações, confira
Validar dados em conjuntos de dados.
Associar controles do Windows Forms a dados no Visual Studio
Associar controles a dados no Visual Studio
Validar os dados
Comentários
Passo a passo: criar uma DataTable para
aplicativos do .NET Framework usando
o Designer de Conjunto de Dados
Artigo • 05/11/2024
７ Observação

mais simples.
Este passo a passo 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, confira Criar e configurar TableAdapters.
Pré-requisitos
Criar um novo Aplicativo do Windows Forms

1. No Visual Studio, crie um projeto de Aplicativo do Windows Forms (.NET
Framework) e nomeie-o DataTableWalkthrough.
O projeto DataTableWalkthrough é criado e adicionado ao Gerenciador de

Soluções.
Adicionar um novo Conjunto de Dados ao
aplicativo
A caixa de diálogo Adicionar Novo Item aparecerá.
2. No painel esquerdo, selecione Dados e Conjunto de Dados no painel central.
3. Escolha Adicionar.
O Visual Studio adiciona um arquivo chamado DataSet1.xsd ao projeto e o abre no

Adicionar um novo DataTable ao conjunto de

dados
1. Arraste um DataTable da guia Conjunto de Dados da Caixa de Ferramentas para o
Uma tabela chamada DataTable1 é adicionada ao conjunto de dados.
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
selecione Coluna.
2. Nomeie a coluna SongID .
3. Na janela Propriedades, defina a propriedade DataType 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
selecione Definir Chave Primária. Um ícone de chave aparece ao lado da coluna
SongID.
Salvar o projeto
Para salvar o projeto DataTableWalkthrough, no menu Arquivo, selecione Salvar Tudo.
Validando dados
Comentários

Criar e configurar TableAdapters em
aplicativos .NET Framework
Artigo • 15/12/2023
７ Observação

mais simples.
TableAdapters fornecem comunicação entre seu aplicativo e um banco de dados. Eles se

conectam ao banco de dados, executam consultas ou procedimentos armazenados e
retornam uma nova tabela de dados ou preenchem uma DataTable existente com os
dados retornados. TableAdapters também podem 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:
Arrastar objetos de banco de dados do Gerenciador de Servidores para o

Execute o Assistente de Configuração da Fonte de Dados e selecione o tipo de

fonte de dados Banco de Dados ou Serviç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 do Designer de Conjunto de Dados.
Para obter uma introdução ao TableAdapters, confira Preencher conjuntos de dados

usando TableAdapters.
７ Observação
Usar o Assistente de Configuração do

TableAdapter
Execute o Assistente de Configuração do TableAdapter para criar ou editar
TableAdapters e as DataTables associadas. Você pode configurar um TableAdapter
existente clicando com o botão direito 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: instruções SQL ou procedimentos armazenados. (Você não verá essa
tela se estiver configurando um TableAdapter que já esteja associado a uma fonte de
dados.)
Você terá 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 opção não estará disponível.
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 Atualizar, por exemplo, é
executado quando o método TableAdapter.Update() é 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 @CompanyName que é passado para a coluna CompanyName
na tabela, defina a Coluna de Origem do parâmetro @CompanyName como CompanyName .
７ Observação
O procedimento armazenado atribuído ao comando SELECT é executado

chamando o método do TableAdapter nomeado na próxima etapa do assistente. O
método padrão é Fill , então o código normalmente usado para executar o
procedimento SELECT é TableAdapter.Fill(tableName) . Se você substituir o nome
padrão de Fill , substitua Fill pelo nome atribuído e substitua "TableAdapter"
pelo nome real do 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 GenerateDBDirectMethods
como true. A opção não está disponível quando a instrução SQL original não
fornece informações suficientes ou a consulta não é uma consulta atualizável. Essa
situação pode ocorrer, por exemplo, em consultas JOIN e consultas que retornam
um valor único (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 instruções SQL
Usar simultaneidade otimista
Especifique se deseja atualizar a tabela de dados depois que as instruções INSERT
e UPDATE forem executadas
Configurar o método de preenchimento de

TableAdapter
Às vezes, convém alterar o esquema da tabela do TableAdapter. Para fazer isso,
modifique o método primário Fill do TableAdapter. TableAdapters são criados com um
método primário Fill que define o esquema da tabela de dados associada. O método
primário Fill se baseia na consulta ou no procedimento armazenado inserido quando
você configurou originalmente o TableAdapter. É o primeiro método (superior) na tabela
de dados no Designer de Conjunto de Dados.
Todas as alterações feitas no método principal Fill do TableAdapter são refletidas no
esquema da tabela de dados associada. Por exemplo, remover uma coluna da consulta
no método principal Fill também remove a coluna da tabela de dados associada. Além
disso, remover a coluna do método principal Fill remove a coluna de quaisquer
consultas adicionais para esse TableAdapter.
Você pode usar o Assistente de Configuração de Consulta do 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ê especifica.
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 do

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
Conjunto de Dados da Caixa de Ferramentas para um DataTable ou selecione
Adicionar Consulta no menu de atalho do TableAdapter. Você também pode
arrastar um objeto Query 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á.
７ Observação
Essa tela só aparece quando o designer não pode determinar a conexão

adequada a ser usada ou quando não há conexões disponíveis.
4. Na tela Escolha um Tipo de Comando, selecione a partir dos seguintes métodos

de coleta de dados do banco de dados:
Usar instruções SQL permite digitar uma instrução SQL para selecionar os
dados do banco de dados.
Criar novo procedimento armazenado permite a criação de um novo

procedimento armazenado (no banco de dados) com base na instrução
SELECT especificada.
Usar procedimentos armazenados existentes permite executar um

procedimento armazenado existente ao executar a consulta.
Para iniciar o Assistente de Configuração de Consulta do

TableAdapter em uma consulta existente
Se você estiver editando uma consulta de TableAdapter existente, clique com o
botão direito na consulta e escolha Configurar no menu de atalho.
７ Observação
Clicar com o botão direito na consulta principal de um TableAdapter

reconfigura o TableAdapter e o esquema de DataTable. No entanto, clicar
com o botão direito em uma consulta adicional em um TableAdapter
configurará apenas a consulta selecionada. O Assistente de Configuração do
TableAdapter reconfigura a definição de TableAdapter, enquanto o Assistente
de Configuração de Consultas do TableAdapter reconfigura apenas a
consulta selecionada.
Para adicionar uma consulta global a um TableAdapter

Consultas globais são consultas SQL 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. Elas 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.
Você adiciona consultas globais arrastando um objeto Query da guia DataSet da

Caixa de Ferramentas para uma área vazia do Designer de Conjunto de Dados.
Forneça uma consulta que execute a tarefa desejada, por exemplo, SELECT
COUNT(*) AS CustomerCount FROM Customers .
７ Observação
Arrastar um objeto Query 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.
Criar consultas parametrizadas do
TableAdapter em aplicativos do .NET
Framework
Artigo • 08/08/2024
７ Observação

mais simples.
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.
Crie consultas TableAdapter parametrizadas no Designer de Conjunto de Dados. Você

também pode criá-las em um aplicativos do 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 dos parâmetros e executar a
consulta.
７ Observação
Ao construir uma consulta parametrizada, use a notação de parâmetro específica

do banco de dados em que você está codificando. Por exemplo, as fontes de dados
do Access e 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 à instrução SQL uma cláusula WHERE com
os parâmetros desejados. Para obter mais informações, consulte Criar e configurar
TableAdapters.
or
Adicione uma consulta a um TableAdapter existente, adicionando à instrução SQL

uma cláusula WHERE com os parâmetros desejados.
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, confira Associar controles do Windows Forms
a dados no Visual Studio.
2. No menu Dados, selecione Adicionar Consulta.
3. Preencha a caixa de diálogo Pesquisar Construtor de critérios, adicionando à

instrução SQL uma cláusula WHERE com os parâmetros desejados.
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 Consulta ou Marcas Inteligentes de Dados.
７ Observação
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 deseja
adicionar a parametrização.
4. Digite um nome na caixa Nome da nova consulta ao criar uma nova consulta.
or
Selecione uma consulta na caixa Nome da consulta existente.
5. Na caixa Texto da Consulta, digite uma consulta que usa 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

Parâmetros TableAdapter podem receber valores nulos quando você deseja consultar
registros que não têm valor atual. Por exemplo, considere a seguinte consulta que tem
um parâmetro ShippedDate na cláusula WHERE :
SQL
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:
C#
C#
ordersTableAdapter.FillByShippedDate(northwindDataSet.Orders, null);
Para habilitar uma consulta a aceitar valores nulos:
1. No Designer de Conjunto de Dados, selecione a consulta TableAdapter que

precisa aceitar valores de parâmetro nulos.
2. Na janela Propriedades, selecione Parâmetros e, em seguida, selecione o 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 .
Comentários
Acessar diretamente o banco de dados
com um TableAdapter em aplicativos do
.NET Framework
Artigo • 12/01/2024
７ Observação

mais simples.
Além dos InsertCommand , UpdateCommand e DeleteCommand , TableAdapters 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 dados.
Se você não quiser criar esses métodos diretos, defina a propriedade TableAdapter
GenerateDbDirectMethods como false na janela Propriedades. Se alguma consulta for
adicionada a um TableAdapter além da consulta principal do TableAdapter, elas serão

consultas autônomas que não geram esses métodos DbDirect .
Enviar comandos diretamente para um banco

de dados
Chame o método TableAdapter DbDirect que executa a tarefa que você está tentando
realizar.
Para inserir novos registros diretamente em um banco de

dados
Chame o método Insert do TableAdapter, passando os valores de cada coluna
como parâmetros. O procedimento a seguir usa a tabela Region no banco de
dados Northwind como exemplo.
７ Observação
Se você não tiver uma instância disponível, crie uma instância do

TableAdapter que deseja usar.
C#
C#
NorthwindDataSetTableAdapters.RegionTableAdapter regionTableAdapter
=
new NorthwindDataSetTableAdapters.RegionTableAdapter();
regionTableAdapter.Insert(5, "NorthWestern");
Para atualizar registros diretamente em um banco de

dados
Chame o método Update do TableAdapter, passando os valores novos e originais
de cada coluna como parâmetros.
７ Observação

C#
C#
=
regionTableAdapter.Update(1, "East", 1, "Eastern");

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

C#
C#
=
regionTableAdapter.Delete(5, "NorthWestern");
Desativar restrições ao preencher um
conjunto de dados em aplicativos do
.NET Framework
Artigo • 05/11/2024
７ Observação

mais simples.
Se um conjunto de dados contiver restrições (como restrições de chave estrangeira),

elas poderão gerar erros relacionados à ordem de operações executadas no conjunto de
dados. Por exemplo, carregar registros filho antes de carregar registros pai relacionados
pode violar uma restrição e causar um erro. Assim que você carrega um registro filho, a
restrição verifica o registro pai relacionado e gera um erro.
Se não houvesse mecanismo para permitir a suspensão temporária da restrição, um erro

seria gerado sempre que você tentasse carregar um registro na tabela filho. Outra
maneira de suspender todas as restrições em um conjunto de dados é com as
propriedades BeginEdit e EndEdit.
７ Observação
Os eventos de validação (por exemplo, ColumnChanging e RowChanging) não

serão gerados quando as restrições forem desativadas.
Para suspender as restrições de atualização

programaticamente
O exemplo a seguir mostra como desativar temporariamente a verificação de
restrição em um conjunto de dados:
C#
dataSet1.EnforceConstraints = false;
// Perform some operations on the dataset
dataSet1.EnforceConstraints = true;
Para suspender as restrições de atualização

usando o Designer de Conjunto de Dados
informações, consulte Instruções passo a passo: criar um conjunto de dados no
2. Na janela Propriedades, defina a propriedade EnforceConstraints como false .
Relacionamentos em conjuntos de dados
Comentários

Estender a funcionalidade de um
TableAdapter em aplicativos do .NET
Framework
Artigo • 12/01/2024
７ Observação

mais simples.
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 alguma alteração é feita no

TableAdapter no Designer de Conjunto de Dados ou quando um assistente modifica a
configuração de um TableAdapter. Para impedir que o código seja excluído durante a
regeneração de TableAdapter, adicione código ao arquivo de classe parcial de
TableAdapter.
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, confira Parcial ou partial (tipo).
Localizar TableAdapters no código

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

esteja em um projeto com NorthwindDataSet .
Para criar uma classe parcial para um TableAdapter

1. Adicione uma nova classe ao projeto acessando 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 do

projeto da seguinte maneira:
C#
namespace NorthwindDataSetTableAdapters
{
public partial class CustomersTableAdapter
{
// Add user code here. For example:
public override string ToString()
{
return "Overridden in the partial class.";
}
}
}
Ler dados XML em um conjunto de
dados em aplicativos .NET Framework
Artigo • 19/03/2024
７ Observação

mais simples.
O ADO.NET fornece métodos simples para trabalhar com dados XML. Neste passo a
passo, você cria um aplicativo do Windows que carrega dados XML em um conjunto de
dados. Em seguida, o conjunto de dados é exibido em um controle DataGridView. Por
fim, um esquema XML baseado no conteúdo do arquivo XML é exibido em uma caixa
de texto.
Pré-requisitos
Para concluir este tutorial, você precisa do Visual Studio com as seguintes cargas de
trabalho instaladas:
Desenvolvimento para área de trabalho com .NET

Armazenamento de dados e processamento
Para instalá-las, abra Instalador do Visual Studio e escolha Modificar (ou

Mais>Modificar) ao lado da versão do Visual Studio que você deseja modificar. Confira

Crie um projeto de Aplicativo do Windows Forms para C# ou Visual Basic. Dê ao
projeto o nome ReadingXML.
Gerar o arquivo XML a ser lido no conjunto de

dados
Como este passo a passo se concentra na leitura de dados XML em um conjunto de
dados, o conteúdo de um arquivo XML é fornecido.
2. Selecione Arquivo XML, dê ao arquivo o nome authors.xmle selecione Adicionar.
O arquivo XML é carregado no designer e está pronto para edição.
3. Cole os seguintes dados XML no editor abaixo da declaração XML:
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>
</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>
</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>
</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>
</authors>
</Authors_Table>
4. No menu Arquivo, selecione Salvar authors.xml.
Criar a interface do usuário

A interface do usuário do aplicativo é composta pelo seguinte:
Um controle DataGridView que exibe o conteúdo do arquivo XML como dados.
Um controle TextBox que exibe o esquema XML para o arquivo XML.
Dois controles Button.
Um botão lê o arquivo XML no conjunto de dados e o exibe no controle

DataGridView.
Um segundo botão extrai o esquema do conjunto de dados e, por meio de um

StringWriter, o exibe no controle TextBox.
Para adicionar controles ao formulário

1. Abra Form1 no modo de exibição de design.
2. Na Caixa de Ferramentas, arraste os seguintes controles para o formulário:
Um controle DataGridView
Um controle TextBox
Dois controles Button
3. Defina as seguintes propriedades:
Control Propriedade Configuração
TextBox1 Multilinha true
ScrollBars Vertical
Button1 Nome ReadXmlButton
Texto Read XML
Button2 Nome ShowSchemaButton
Texto Show Schema
Criar o conjunto de dados que recebe os dados

XML
Nesta etapa, você cria um conjunto de dados chamado authors . Para obter mais
informações sobre conjuntos de dados, consulte Ferramentas de conjunto de dados no
Visual Studio.
1. No Gerenciador de Soluções, selecione o arquivo de origem para Form1 e, em

seguida, o botão Designer de Exibição na barra de ferramentas do Gerenciador de
Soluções.
2. Na Caixa de Ferramentas, guia Dados, arraste um Conjunto de Dados para Form1.
3. Na caixa de diálogo Adicionar Conjunto de Dados, selecione Conjunto de dados

sem tipo e selecione OK.
DataSet1 é adicionado à bandeja de componentes.
4. Na janela Propriedades, defina o Nome e as propriedades DataSetName para

AuthorsDataSet .
Criar o manipulador de eventos para ler o
arquivo XML no conjunto de dados
O botão Ler XML lê o arquivo XML no conjunto de dados. Em seguida, define
propriedades no controle DataGridView que o associam ao conjunto de dados.
1. No Gerenciador de Soluções, selecione Form1 e, em seguida, o botão Designer de

Exibição na barra de ferramentas do Gerenciador de Soluções.
2. Clique duas vezes no botão Ler XML.
O Editor de Código é aberto no manipulador de eventos ReadXmlButton_Click .
3. Digite o seguinte código no manipulador de eventos ReadXmlButton_Click :
C#
C#
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";
}
4. No código do manipulador de eventos ReadXMLButton_Click , altere a entrada

filepath = 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 StringWriter que é preenchido com o
esquema e exibido no controle TextBox.
1. No Gerenciador de Soluções, selecione Form1 e, em seguida, o botão Designer de

Exibição.
2. Clique duas vezes no botão Mostrar esquema.

O Editor de Código é aberto no manipulador de eventos ShowSchemaButton_Click .
3. Cole o código a seguir no manipulador de eventos ShowSchemaButton_Click .
C#
C#
private void ShowSchemaButton_Click(object sender, EventArgs e)

{
System.IO.StringWriter swXML = new System.IO.StringWriter();
AuthorsDataSet.WriteXmlSchema(swXML);
textBox1.Text = swXML.ToString();
}
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.
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
conjunto de dados, bem como da criação de um esquema baseado no conteúdo do
arquivo XML. Estas são algumas tarefas que você pode realizar em seguida:
Editar os dados no conjunto de dados e escrevê-los novamente como XML. Para

obter mais informações, consulte WriteXml.
Edite os dados no conjunto de dados e escreva-os em um banco de dados.
Acessar dados no Visual Studio
Ferramentas XML no Visual Studio
Comentários
Editar dados em conjuntos de dados
Artigo • 04/05/2023
７ Observação

Você edita dados em tabelas de dados da mesma maneira que edita dados em uma
tabela em qualquer banco de dados. O processo pode incluir a inserção, a atualização e
a exclusão de registros na tabela. Em um formulário associado a dados, você pode
especificar quais campos podem ser editados pelo usuário. Nesses casos, a
infraestrutura de associação de dados cuida de todo o controle de alterações para que
as alterações possam ser enviadas de volta para o banco de dados posteriormente. Se
você faz edições nos dados programaticamente e pretende enviar essas alterações de
volta para o banco de dados, use 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 de dados específicas. 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 dados

Para editar uma linha existente em um DataTable, você precisa localizar o DataRow que
deseja editar e atribuir os valores atualizados às colunas desejadas.
Se você não souber o índice da linha que deseja editar, use o método FindBy para
pesquisar pela chave primária:
C#
C#
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 linhas da seguinte maneira:
C#
C#
northwindDataSet1.Customers[4].CompanyName = "Updated Company Name";

northwindDataSet1.Customers[4].City = "Seattle";
Para inserir novas linhas em um conjunto de

dados
Aplicativos que usam controles associados a dados normalmente adicionam novos
registros por meio do botão Adicionar Novo em um controle BindingNavigator.
Para adicionar manualmente novos registros a um conjunto de dados, crie uma linha de
dados chamando o método em DataTable. Em seguida, adicione a linha à coleção
DataRow (Rows) do DataTable:
C#
C#
NorthwindDataSet.CustomersRow newCustomersRow =
northwindDataSet1.Customers.NewCustomersRow();
newCustomersRow.CustomerID = "ALFKI";
newCustomersRow.CompanyName = "Alfreds Futterkiste";
northwindDataSet1.Customers.Rows.Add(newCustomersRow);
Para manter as informações necessárias para que o conjunto de dados envie
atualizações para a fonte de dados, use o método Delete para remover linhas em uma
tabela de dados. Por exemplo, se o aplicativo usa um TableAdapter (ou DataAdapter), o
método Update do TableAdapter exclui linhas no banco de dados que têm um RowState
de Deleted.
Se o aplicativo não precisa enviar atualizações de volta para uma fonte de dados, é
possível remover registros acessando diretamente a coleção de linhas de dados
(Remove).
Para excluir registros de uma tabela de dados

Chame o método Delete de um DataRow.
Esse método não remove o registro fisicamente. Em vez disso, ele marca o registro
para exclusão.
７ Observação
Se você receber a propriedade de contagem de um DataRowCollection, a

contagem resultante incluirá 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 propriedade
RowState de cada registro. (Registros marcados para exclusão têm um
RowState de Deleted.) Como alternativa, você pode criar uma exibição de
dados de um conjunto de dados que é filtrado com base no estado da linha e
obter a propriedade de contagem dessa forma.
O exemplo a seguir mostra como chamar o método Delete para marcar a primeira linha
na tabela Customers como excluída:
C#
C#
northwindDataSet1.Customers.Rows[0].Delete();
Determinar se há linhas alteradas

Quando são feitas alterações em registros em um conjunto de dados, as informações
sobre essas alterações são armazenadas até que você as confirme. Você confirma as
alterações chamando o método AcceptChanges de um conjunto de dados ou tabela de
dados chamando o método Update 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 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). No
período em que uma alteração está pendente (o período em que você pode
responder ao evento RowChanging), uma terceira versão — a versão proposta —
também fica disponível.
O método HasChanges de um conjunto de dados retornará true se forem feitas

alterações no conjunto de dados. Depois de determinar que as linhas alteradas existem,
você pode chamar o método GetChanges de um DataSet ou DataTable para retornar um
conjunto de linhas alteradas.
Para determinar se foram feitas alterações em qualquer linha

Chame o método HasChanges de um conjunto de dados para verificar se há linhas
alteradas.
O exemplo a seguir mostra como verificar o valor retornado do método HasChanges

para detectar se há linhas alteradas em um conjunto de dados chamado
NorthwindDataset1 :
C#
C#
if (northwindDataSet1.HasChanges())
{
// Changed rows were detected, add appropriate code.
}
else
{
// No changed rows were detected, add appropriate code.
}
Determinar o tipo de alterações
Você também pode verificar quais tipo de alterações foram feitas em um conjunto de
dados passando um valor da enumeração DataRowState para o método HasChanges.
Para determinar quais tipo de alterações foram feitas em uma linha

Passe um valor DataRowState para o método HasChanges.
O exemplo a seguir mostra como verificar um conjunto de dados chamado

NorthwindDataset1 para determinar se novas linhas foram adicionadas a ele:
C#
C#
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.
}
Para localizar linhas com erros

Ao trabalhar com colunas e linhas de dados individuais, você pode encontrar erros. Você
pode verificar a propriedade HasErrors para determinar se há erros em um DataSet,
DataTable ou DataRow.
1. Verifique a propriedade HasErrors para ver se há erros no conjunto de dados.
2. Se a propriedade HasErrors for true , itere pelas coleções de tabelas e, em

seguida, pelas linhas para localizar a linha com o erro.
C#
C#
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.
}
}
}
}
}
}
Confira também
Validar dados em conjuntos de dados
Artigo • 04/05/2023
７ Observação

Validar dados é o processo de confirmar que os valores inseridos em objetos de dados

estão em conformidade com as restrições dentro do esquema de um conjunto de
dados. 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 dados
antes de enviar atualizações para o banco de dados subjacente. Isso reduz os erros e 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 conjunto de dados
são válidos criando verificações de validação no próprio conjunto de dados. O conjunto
de dados 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
aplicativo (ao contrário do back-end do banco de dados), é um local lógico para
compilar a validação específica do aplicativo.
O melhor lugar para adicionar validação ao seu aplicativo é no arquivo de classe parcial
do conjunto de dados. 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 abre o arquivo de código, no qual você pode criar um manipulador de
eventos ColumnChanging ou RowChanging.
C#
C#
private static void OnColumnChanging(object sender,

DataColumnChangeEventArgs e)
{
Validar os dados
A validação em um conjunto de dados é realizada das seguintes maneiras:
Criando sua 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,
confira Como validar dados durante alterações de coluna.
Criando sua validação específica do aplicativo que pode verificar dados em valores
enquanto uma linha de dados inteira está sendo alterada. Para obter mais
informações, confira 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 objeto DataColumn, como MaxLength, AllowDBNull

e Unique.
Vários eventos são gerados pelo objeto DataTable quando uma alteração está
ocorrendo em um registro:
Os eventos ColumnChanging e ColumnChanged são gerados durante e após cada

alteração para uma coluna individual. O evento ColumnChanging é útil quando
você deseja validar alterações em colunas específicas. Informações sobre a
alteração proposta são passadas como um argumento com o evento.
Os eventos RowChanging e RowChanged são gerados durante e após qualquer
alteração em uma linha. O evento RowChanging é mais geral. Indica que uma
alteração está ocorrendo em algum lugar da linha, mas você não sabe qual coluna
foi alterada.
Por padrão, cada alteração em uma coluna gera quatro eventos. O primeiro são os
eventos ColumnChanging e ColumnChanged para a coluna específica que está sendo
alterada. A seguir estão os eventos RowChanging e RowChanged. Se várias alterações
estiverem sendo feitas na linha, os eventos serão gerados para cada alteração.
７ Observação
O método BeginEdit da linha de dados desativa os eventos RowChanging e

RowChanged após cada alteração de coluna individual. Nesse caso, o evento não é
gerado até que o método EndEdit tenha sido chamado, quando os eventos
RowChanging e RowChanged são acionados apenas uma vez. Para obter mais
informações, confira Desativar restrições ao preencher um conjunto de dados.
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 evento ColumnChanging. Caso contrário, use o evento
RowChanging, que pode resultar na captura de vários erros ao mesmo tempo. Além
disso, se os dados estiverem estruturados para que o valor de uma coluna seja validado
com base no conteúdo de outra coluna, execute a validação durante o evento
RowChanging.
Quando os registros são atualizados, o objeto DataTable gera eventos aos quais você
pode responder à medida que as alterações estão ocorrendo e depois que as alterações
são feitas.
Se o aplicativo usar um conjunto de dados tipados, você poderá criar manipuladores de

eventos fortemente tipados. 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

Evento Descriçã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.
Evento Descrição
RowChanging As alterações feitas em um objeto DataRow estão prestes a ser confirmadas

novamente no conjunto de dados. Se você não tiver chamado o método
BeginEdit, o evento RowChanging será gerado para cada alteração em uma
coluna imediatamente após o evento ColumnChanging ter sido gerado. Se
você tiver chamado BeginEdit antes de fazer alterações, o evento
RowChanging será gerado somente quando você chamar o método EndEdit.
O evento passa a linha para você, juntamente 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ê, juntamente 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ê, juntamente
com um valor que indica que tipo de ação (excluir) está sendo executado.
RowDeleted Uma linha foi excluída. O evento passa a linha para você, juntamente com um
valor que indica que tipo de ação (excluir) está sendo executado.
Os eventos ColumnChanging, RowChanging 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 processo durante esses
eventos, você pode cancelar lançando uma exceção, o que impede que a atualização
seja concluída.
Os eventos ColumnChanged, RowChanged e RowDeleted são eventos de notificação

gerados quando a atualização é concluída com êxito. Esses eventos são úteis quando
você deseja executar outras ações com base em uma atualização bem-sucedida.
Validar dados durante alterações da coluna
７ Observação
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 dados. O conjunto de dados
gerado pelo designer não exclui nem altera nenhum código na classe parcial.
Você pode validar dados quando o valor em uma coluna de dados for alterado
respondendo ao evento ColumnChanging. 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ê poderá:
Aceitar o valor proposto sem fazer nada.
Rejeitar o valor proposto definindo o erro da coluna (SetColumnError) de dentro

do manipulador de eventos de alteração da coluna.
Opcionalmente, usar um controle ErrorProvider 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 evento RowChanging.
Validar dados durante alterações de linha

Você pode escrever código para verificar se cada coluna que deseja validar contém
dados que atendam aos requisitos do 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 coluna Quantity é de 0 ou menos. Os
manipuladores de eventos de alteração de linha devem ser semelhantes aos exemplos a
seguir.
Para validar dados quando uma linha é alterada (Visual

Basic)
Conjunto de Dados.
2. Clique duas vezes na barra de título da tabela que você deseja validar. Essa ação
cria automaticamente o manipulador de eventos RowChanging do DataTable no
arquivo de classe parcial do conjunto de dados.
 Dica
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.
VB
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#)

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.
７ Observação
O Designer de Conjunto de Dados não cria automaticamente um

manipulador de eventos para o evento RowChanging. Você precisa criar um
método para manipular o evento RowChanging e executar o código para
conectar o evento no método de inicialização da tabela.
3. Copie o seguinte código na classe parcial:
C#
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 propriedade RowState que mantém o
controle do estado atual dessa linha usando os valores na enumeração DataRowState.
Você pode retornar linhas alteradas de um conjunto de dados ou tabela de dados
chamando o método GetChanges de um DataSet ou DataTable. Você pode verificar se há
alterações antes de chamar GetChanges chamando o método HasChanges de um
conjunto de dados.
７ Observação
Depois de confirmar alterações em um conjunto de dados ou tabela de dados

(chamando o método AcceptChanges), o método GetChanges não retorna dados.
Se o aplicativo precisar processar linhas alteradas, você deverá processar as
alterações antes de chamar o método AcceptChanges .
Chamar o método GetChanges de um conjunto de dados ou tabela de dados retorna

um novo conjunto de dados ou tabela de dados que contém apenas registros que
foram alterados. Se você quiser obter registros específicos, por exemplo, apenas
registros novos ou apenas registros modificados, poderá passar um valor da
enumeração DataRowState como um parâmetro para o método GetChanges .
Use a enumeração DataRowVersion 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 dados
Chame o método GetChanges de um conjunto de dados.
O exemplo a seguir cria um novo conjunto de dados chamado changedRecords e o

preenche com todos os registros alterados de outro conjunto de dados chamado
dataSet1 .
C#
C#
DataSet changedRecords = dataSet1.GetChanges();
Para obter todos os registros alterados de uma tabela de

dados
Chame o método GetChanges de uma Tabela de Dados.
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 .
C#
C#
DataTable changedRecordsTable = dataTable1.GetChanges();
Para obter todos os registros que têm um estado de linha

específico
Chame o método GetChanges de um conjunto de dados ou tabela de dados e
passe um valor de enumeração DataRowState como um argumento.
O exemplo a seguir mostra como criar um novo conjunto de dados chamado

addedRecords e preencher somente com registros que foram adicionados ao
conjunto de dados dataSet1 .
C#
C#
DataSet addedRecords = dataSet1.GetChanges(DataRowState.Added);
O seguinte exemplo mostra como retornar todos os registros que foram

adicionados recentemente à tabela Customers :
C#
C#
private NorthwindDataSet.CustomersDataTable GetNewRecords()

{
return (NorthwindDataSet.CustomersDataTable)
northwindDataSet1.Customers.GetChanges(DataRowState.Added);
}
Acessar a versão original de uma Linha de

Dados
Quando são feitas alterações em linhas de dados, o conjunto de dados retém as versões
original (Original) e nova (Current) da linha. Por exemplo, antes de chamar o método
AcceptChanges , seu aplicativo pode acessar as diferentes versões de um registro
(conforme definido na enumeração DataRowVersion) e processar as alterações
adequadamente.
７ Observação
Versões diferentes de uma linha aparecerão somente depois que ela for editada e
antes de o método AcceptChanges ser chamado. Depois que o método
AcceptChanges tiver sido chamado, as versões atuais e originais serão as mesmas.
Passar o valor DataRowVersion junto com o índice de coluna (ou nome da coluna como
uma cadeia de caracteres) retorna o valor da versão de linha específica dessa coluna. A
coluna alterada é identificada durante os eventos ColumnChanging e ColumnChanged.
Este é 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 programaticamente quais colunas foram
alteradas. Você pode fazer isso iterando pela coleção Columns e comparando os
diferentes valores DataRowVersion.
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 seguinte exemplo mostra como usar um valor DataRowVersion para obter o

valor original de um campo CompanyName em um DataRow:
C#
C#
string originalCompanyName;
originalCompanyName = northwindDataSet1.Customers[0]
["CompanyName", DataRowVersion.Original].ToString();
Acessar a versão atual de uma Linha de Dados
Para obter a versão atual de um registro

Acesse o valor de uma coluna e adicione um parâmetro ao índice que indica qual
versão de uma linha você deseja retornar.
O seguinte exemplo mostra como usar um valor DataRowVersion para obter o

valor atual de um campo CompanyName em um DataRow:
C#
C#
string currentCompanyName;
currentCompanyName = northwindDataSet1.Customers[0]
["CompanyName", DataRowVersion.Current].ToString();
Confira também
Como validar dados no controle DataGridView do Windows Forms
Como exibir ícones de erro para validação de formulário com o componente
ErrorProvider do Windows Forms
Salvar dados de volta no banco de
dados em aplicativos do .NET
Framework
Artigo • 01/11/2023
７ Observação
Os conjuntos de dados e classes relacionadas são tecnologias .NET Framework

herdadas 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 bastante úteis em aplicativos que permitem que os usuários modifiquem
dados e persistam as alterações no banco de dados. Embora os conjuntos de
dados tenham se mostrado uma tecnologia muito bem-sucedida, é recomendado
que os novos aplicativos .NET usem o Entity Framework Core. O Entity Framework
proporciona uma forma mais natural de trabalhar com dados tabulares como
modelos de objeto e conta com uma interface de programação mais simples.
O conjunto de dados é uma cópia de dados carregados na memória. Se você modificar

esses dados, uma boa prática é salvar essas alterações 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 métodos DBDirect do TableAdapter
Chamando o método UpdateAll no TableAdapterManager gerado pelo Visual

Studio, quando o conjunto de dados contém tabelas relacionadas a outras tabelas
no conjunto de dados
Quando você associa as tabelas de conjunto de dados aos controles em uma página do
Windows Form ou XAML, a arquitetura de associação de dados faz todo o trabalho.
Se você estiver familiarizado com o TableAdapters, poderá ir diretamente para um

destes tópicos:
Tópico Descrição
Inserir novos registros em um Como executar atualizações e inserções usando os objetos do

banco de dados TableAdapters ou Command
Atualizar dados usando um Como executar atualizações com o TableAdapters

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

ou mais tabelas relacionadas
Tratar uma exceção de Como lidar com exceções quando dois usuários tentam alterar
simultaneidade os mesmos dados em um banco de dados ao mesmo tempo
Como salvar dados usando Como salvar dados em uma transação usando o Sistema.
uma transação Namespace das transações e um objeto do TransactionScope
Salvando dados em uma Passo a passo que cria um aplicativo do Windows Forms para
transação demonstrar como salvar dados em um banco de dados dentro
de uma transação
Salvar dados em um banco de Como editar registros e salvar alterações em várias tabelas no
dados (várias tabelas) banco de dados
Salvar dados de um objeto Como passar dados de um objeto que não está em um conjunto
em um banco de dados de dados para um banco de dados usando um método DbDirect
do TableAdapter
Salvar os dados com os Como usar o TableAdapter para enviar consultas SQL
métodos TableAdapter diretamente para o banco de dados
DBDirect
Salvar um conjunto de dados Como salvar um conjunto de dados em um documento XML

como XML
Atualizações em duas fases

Atualizar uma fonte de dados é um processo de duas etapas. A primeira etapa é
atualizar o conjunto de dados com novos registros, registros alterados ou registros
excluídos. Se o aplicativo nunca enviar essas alterações à fonte de dados, a atualização
será concluída.
Se você enviar as alterações ao banco de dados, a segunda etapa será necessária. Se

você não estiver usando controles associados a dados, precisará chamar manualmente o
método Update do mesmo TableAdapter (ou adaptador de dados) usado para
preencher o conjunto de dados. No entanto, você também pode usar adaptadores
diferentes, por exemplo, para mover dados de uma fonte de dados para outra ou
atualizar várias fontes de dados. Se você não estiver usando a associação de dados e
estiver salvando alterações para tabelas relacionadas, precisará instanciar manualmente
uma variável da classe TableAdapterManager gerada automaticamente e, em seguida,
chamar seu método UpdateAll .
Um conjunto de dados contém coleções de tabelas, que contêm coleções de linhas. Se

você pretende atualizar uma fonte de dados subjacente posteriormente, deve usar os
métodos na propriedade DataTable.DataRowCollection ao 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 RemoveAt na propriedade Rows, a exclusão não será
comunicada ao banco de dados.
Mesclar conjuntos de dados

Você pode atualizar o conteúdo de um conjunto de dados mesclando-o com outro
conjunto de dados. Isso envolve copiar o conteúdo de um conjunto de dados de origem
para o conjunto de dados de chamada (conhecido como conjunto de dados de destino).
Quando você mescla conjuntos de dados, novos registros no conjunto de dados de
origem são adicionados ao conjunto de dados de destino. Além disso, colunas extras no
conjunto de dados de origem são adicionadas ao conjunto de dados de destino. A
mesclagem de conjuntos de dados é útil quando você tem um conjunto de dados local
e obtém um segundo conjunto de dados de outro aplicativo. Também é útil quando
você obtém um segundo conjunto de dados de um componente, como um serviço Web
XML, ou quando precisa integrar dados de vários conjuntos de dados.
Ao mesclar conjuntos de dados, você pode passar um argumento Booliano
( preserveChanges ) que informa ao método Merge se deve manter as modificações
existentes no conjunto de dados de 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:
DataRowVersion Conjunto de dados de destino Conjunto de dados de origem
Original James Wilson James C. Wilson
Current Jim Wilson James C. Wilson
Chamar o método Merge na tabela anterior com o preserveChanges=false

targetDataset.Merge(sourceDataset) resulta nos seguintes dados:
Original James C. Wilson James C. Wilson
Current James C. Wilson James C. Wilson
Chamar o método Merge com o preserveChanges = true

targetDataset.Merge(sourceDataset, true) resulta nos seguintes dados:
Original James C. Wilson James C. Wilson
Current Jim Wilson James C. Wilson
Ｕ Cuidado
No cenário preserveChanges = true , se o método RejectChanges for chamado em

um registro no conjunto de dados de destino, ele será revertido para os dados
originais do conjunto de dados de origem. Isso significa que, se você tentar
atualizar a fonte de dados original com o conjunto de dados de destino, talvez não
consiga encontrar a linha original a ser atualizada. Você pode evitar uma violação
de simultaneidade preenchendo outro conjunto de dados com os registros
atualizados da fonte de dados e, em seguida, executando uma mesclagem. (Uma
violação de simultaneidade ocorre quando outro usuário modifica um registro na
fonte de dados, depois que o conjunto de dados é preenchido.)
Atualizar restrições
Para fazer alterações em uma linha de dados existente, adicione ou atualize os dados
nas colunas individuais. Se o conjunto de dados contiver restrições (como chaves
estrangeiras ou restrições não anuláveis), é possível que o registro possa estar
temporariamente em um estado de erro ao atualizá-lo. 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 de restrição prematuras, você pode suspender temporariamente as

restrições de atualização. Isso atende a duas finalidades:
Isso evita que um erro seja gerado depois que você terminar de atualizar uma
coluna, mas não tiver iniciado a atualização de outra.
Isso impede que determinados eventos de atualização sejam gerados (eventos que
geralmente são usados para validação).
７ Observação
No Windows Forms, a arquitetura de associação de dados incorporada ao datagrid

suspende a verificação de restrição até que o foco saia de uma linha e você não
precise chamar explicitamente os métodos BeginEdit, EndEdit ou CancelEdit.
As restrições são desabilitadas automaticamente quando o método Merge é invocado

em um conjunto de dados. Quando a mesclagem for concluída, se houver restrições no
conjunto de dados que não possam ser habilitadas, uma ConstraintException será
gerada. Nessa situação, a propriedade EnforceConstraints será definida como false, e
todas as violações de restrição devem ser resolvidas antes de redefinir a propriedade
EnforceConstraints como true .
Depois de concluir uma atualização, você poderá reabilitar a verificação de restrição,

que também habilita novamente e gera os eventos de atualização.
Para obter mais informações sobre como suspender eventos, confira Desativar restrições
ao preencher um conjunto de dados.
Erros de atualização do conjunto de dados

Quando você atualiza um registro em um conjunto de dados, há uma possibilidade de
erro. Por exemplo, você pode gravar inadvertidamente dados do tipo errado em uma
coluna, dados muito longos ou dados que têm 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 fase de um evento de atualização. Para obter
mais informações, confira Validar dados em conjuntos de dados.
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 as linhas que indicam que elas foram alteradas (RowState) e
mantendo várias cópias de um registro (DataRowVersion). Usando essas informações, os
processos podem determinar o que mudou no conjunto de dados e podem enviar
atualizações apropriadas para a fonte de dados.
Propriedade RowState
A propriedade RowState de um objeto DataRow é 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 enumeração DataRowState:
Valor de Descrição
DataRowState
Added A linha foi adicionada como um item a um DataRowCollection. (Uma linha

nesse estado não tem uma versão original correspondente, pois não existia
quando o último método AcceptChanges foi chamado).
Deleted A linha foi excluída usando o Delete de um objeto DataRow.
Detached A linha foi criada, mas não faz parte de nenhum DataRowCollection. Um
objeto DataRow entra nesse estado imediatamente depois de ser criado,
antes de ser adicionado a uma coleção ou depois de ter sido 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 dados mantêm várias versões de registros. Os campos DataRowVersion
são usados ao recuperar o valor encontrado em um DataRow, usando a propriedade
Item[] ou o método GetChildRows do objeto DataRow.
A tabela a seguir detalha os possíveis valores da enumeração DataRowVersion:

Valor de Descrição
DataRowVersion
Current A versão atual de um registro contém todas as modificações executadas no

registro desde que a última vez o AcceptChanges foi chamado. Se a linha
tiver sido excluída, não haverá versão atual.
Default O valor padrão de um registro conforme definido pelo esquema ou fonte de

dados do conjunto de dados.
Original A versão original de um registro é uma cópia do registro, pois foi a última
vez que as alterações foram confirmadas no conjunto de dados. Na prática,
normalmente essa é a versão de um registro como lido em 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 o momento
em que você chamou o método BeginEdit e o método EndEdit.
Normalmente, você acessa a versão proposta de um registro em um
manipulador para um evento como RowChanging. Invocar o método
CancelEdit inverte 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 dados 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 existisse, provavelmente o registro seria
acrescentado à fonte de dados, resultando não apenas em um registro adicional
indesejado, mas em um registro impreciso 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 foi
carregado no conjunto de dados.
A versão proposta é útil quando você precisa executar a validação antes de realmente
confirmar as alterações no conjunto de dados.
Mesmo que os registros tenham sido alterados, nem sempre há versões original ou
atual dessa linha. Quando você insere uma nova linha na tabela, não há versão original,
apenas uma versão atual. Da mesma forma, se você excluir uma linha chamando o
método Delete da tabela, haverá uma versão original, mas não haverá versão atual.
Você pode testar para ver se existe uma versão específica de um registro, consultando o
método HasVersion de uma linha de dados. Você pode acessar qualquer versão de um
registro passando um valor de enumeração DataRowVersion 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 dados. Por
exemplo, um usuário pode estar trabalhando com um controle DataGridView do
Windows Forms que exibe muitos registros. No entanto, o usuário pode atualizar
apenas alguns registros, excluir um e inserir um novo. Os conjuntos de dados e as
tabelas de dados fornecem um método ( GetChanges ) para retornar apenas as linhas
modificadas.
Você pode criar subconjuntos de registros alterados usando o método GetChanges da

tabela de dados (GetChanges) ou do próprio conjunto de dados (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 dados, obterá um novo conjunto de dados com apenas registros alterados.
GetChanges por si só retorna todos os registros alterados. Por outro lado, ao passar o
DataRowState desejado como parâmetro para o método GetChanges , você pode

especificar qual subconjunto de registros alterados deseja: registros recém-adicionados,
registros 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 todo o conjunto de
dados, 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 dados

À medida que as alterações são feitas no conjunto de dados, a propriedade RowState
das linhas alteradas é definida. As versões original e atual dos registros são
estabelecidas, mantidas e disponibilizadas pela propriedade RowVersion. 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á dois momentos em que o conjunto de
dados e sua origem estão sincronizados:
Imediatamente depois de carregar as informações no conjunto de dados, como
quando você lê os dados na origem.
Depois de enviar as alterações do conjunto de dados para a fonte de dados (mas

não antes, porque você perderia as informações de alteração necessárias para
enviar alterações ao banco de dados).
Você pode confirmar as alterações pendentes no conjunto de dados chamando o

método AcceptChanges. Normalmente, AcceptChanges é chamado nos seguintes
momentos:
Depois de carregar o conjunto de dados. Se você carregar um conjunto de dados

chamando um método Fill do TableAdapter, o adaptador confirmará as
alterações automaticamente. No entanto, se você carregar um conjunto de dados
mesclando outro conjunto de dados, será necessário confirmar as alterações
manualmente.
７ Observação
Você pode impedir que o adaptador confirme as alterações automaticamente

ao chamar o método Fill , definindo a propriedade AcceptChangesDuringFill
do adaptador como false . Se estiver definido como false , o RowState de
cada linha inserida durante o preenchimento será definido como Added.
Depois de enviar as alterações do conjunto de dados para outro processo, como

um serviço Web XML.
Ｕ Cuidado
Confirmar a alteração dessa maneira apaga as informações 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 dados.
Esse método realiza o seguinte:
Grava a versão Current de um registro na versão Original e substitui a versão

original.
Remove as linhas em que a propriedade RowState está definida como Deleted.
Define a propriedade RowState de um registro como Unchanged.

O método AcceptChanges está disponível em três níveis. Você pode chamá-lo em um
objeto DataRow para confirmar alterações apenas para essa linha. Você também pode
chamá-lo em um objeto DataTable para confirmar todas as linhas em uma tabela. Por
fim, você pode chamá-lo no objeto DataSet para confirmar todas as alterações
pendentes em todos os registros de todas as tabelas do conjunto de dados.
A tabela a seguir descreve quais alterações são confirmadas com base no objeto em
que o método é chamado:
Método Result
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 da

tabela específica.
System.Data.DataSet.AcceptChanges As alterações são confirmadas em todas as linhas em

todas as tabelas do conjunto de dados.
７ Observação
Se você carregar um conjunto de dados chamando um método Fill do

TableAdapter, não precisará aceitar as alterações explicitamente. Por padrão, o
método Fill chama o método AcceptChanges depois que termina de preencher a
tabela de dados.
Um método relacionado, RejectChanges, desfaz o efeito das alterações copiando a

versão Original para a versão Current dos registros. Ele também define o RowState de
cada registro como Unchanged.
Validação de dados
Para verificar se os dados no seu aplicativo atendem aos requisitos dos processos para
os quais são passados, geralmente você precisa adicionar a validação. Isso pode
envolver verificar se a entrada de um usuário em um formulário está correta, validar
dados enviados para seu aplicativo por outro aplicativo ou até mesmo verificar se as
informações calculadas no seu componente estão dentro das restrições da sua fonte de
dados e dos requisitos de aplicativo.
Você pode validar os dados de várias maneiras:

Na camada de negócios, adicionando o código ao seu aplicativo para validar os
dados. O conjunto de dados é um local em que você pode fazer isso. O conjunto
de dados fornece algumas das vantagens da validação de back-end, como a
capacidade de validar alterações à medida que os valores de coluna e linha estão
sendo alterados. Para obter mais informações, confira Validar dados em conjuntos
de dados.
Na camada de apresentação, adicionando a validação aos formulários. Para obter

mais informações, confira Validação da entrada de usuário no Windows Forms.
No back-end de dados, enviando os dados para a fonte de dados, por exemplo, o

banco de dados, e permitindo que aceite ou rejeite os dados. Se você estiver
trabalhando com um banco de dados que tenha recursos avançados para validar
os dados e fornecer as informações de erro, essa pode ser uma abordagem
prática, pois você pode validar os dados, independentemente de onde venham. No
entanto, essa abordagem pode não atender aos requisitos de validação específicos
do aplicativo. Além disso, fazer com que a fonte de dados valide os 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.
） Importante
Ao usar comandos de dados com a propriedade CommandType 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 de usuário para um banco de dados, sempre verifique se as
informações são válidas. A melhor prática é sempre usar consultas
parametrizadas ou procedimentos armazenados, quando possível.
Transmitir atualizações para a fonte de dados

Depois que as alterações forem feitas em um conjunto de dados, você poderá transmitir
as alterações para uma fonte de dados. Mais comumente, você faz isso chamando o
método Update 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
(atualizar, inserir ou excluir), se houver, e então executa o comando apropriado.
Como ilustração de como as atualizações são feitas, suponha que seu aplicativo use um
conjunto de dados que contém uma única tabela de dados. O aplicativo busca duas
linhas do banco de dados. Após a recuperação, a tabela de dados carregados na
memória será assim:
SQL
(RowState) CustomerID Name Status

(Unchanged) c200 Robert Lyon Good
(Unchanged) c400 Nancy Buchanan Pending
O aplicativo altera o status de Nancy Buchanan para "Preferencial". Como resultado

dessa alteração, o valor da propriedade RowState dessa linha muda de Unchanged para
Modified. O valor da propriedade RowState para a primeira linha permanece
Unchanged. Agora a tabela de dados será assim:
SQL
(RowState) CustomerID Name Status

(Unchanged) c200 Robert Lyon Good
(Modified) c400 Nancy Buchanan Preferred
Agora o aplicativo chama o método Update para transmitir o conjunto de dados para o
banco de dados. Por sua vez, o método inspeciona cada linha. Para a primeira linha, o
método não transmite instruções SQL para o banco de dados, pois essa linha não foi
alterada desde que foi originalmente buscada no banco de dados.
No entanto, para a segunda linha, o método Update invoca automaticamente o

comando de dados correto e o transmite para o banco de dados. A sintaxe específica da
instrução SQL depende do dialeto do SQL compatível com o armazenamento de dados
subjacente. No entanto, as seguintes características gerais da instrução SQL transmitida
devem ser observadas:
A instrução SQL transmitida é uma instrução UPDATE. O adaptador sabe usar uma
instrução UPDATE, pois o valor da propriedade RowState é Modified.
A instrução 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, pois o
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 SQL transmitida inclui a cláusula SET para definir os novos valores das
colunas modificadas.
７ Observação
Se a propriedade UpdateCommand do TableAdapter tiver sido definida como o

nome de um procedimento armazenado, o adaptador não construirá uma
instrução SQL. Em vez disso, ele invocará o procedimento armazenado com os
parâmetros apropriados passados.
Passar parâmetros
Normalmente, você usa parâmetros para passar os valores dos registros que serão
atualizados no banco de dados. Quando o método Update do TableAdapter executa
uma instrução UPDATE, precisa preencher os valores de parâmetro. Ele obtém esses
valores da coleção Parameters para o comando de dados apropriado, nesse caso, o
objeto UpdateCommand no TableAdapter.
Se você tiver usado as ferramentas do Visual Studio para gerar um adaptador de dados,
o objeto UpdateCommand conterá uma coleção de parâmetros que correspondem a cada
espaço reservado de parâmetro na instrução.
A propriedade System.Data.SqlClient.SqlParameter.SourceColumn de cada parâmetro

aponta para uma coluna na tabela de dados. Por exemplo, a propriedade SourceColumn
para os parâmetros au_id e Original_au_id é definida como qualquer coluna na tabela
de dados que contenha a ID do autor. Quando o método Update do adaptador é
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 (os que serão
gravados no registro), bem como os valores antigos (para que o registro possa ser
localizado no banco de dados). Portanto, há dois parâmetros para cada valor: um para a
cláusula SET e outro para a cláusula WHERE. Ambos os parâmetros leem dados do
registro que está sendo atualizado, mas obtêm versões diferentes do valor da coluna
com base na propriedade SourceVersion do parâmetro. 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.
７ Observação
Você também pode definir valores na coleção Parameters por conta própria no
código, o que normalmente faria em um manipulador de eventos para o evento
RowChanging do adaptador de dados.
Confira também
Criar e configurar TableAdapters
Atualizar dados usando um TableAdapter
Validar os dados
Instruções: adicionar, modificar e excluir entidades (serviços de dados do WCF)
Inserir novos registros em um banco de
Framework
Artigo • 05/11/2024
Para inserir novos registros em um banco de dados com ADO.NET em um projeto do

.NET Framework, a abordagem comum é usar métodos TableAdapter. TableAdapters
fornecem comunicação entre seu aplicativo e um banco de dados. Eles fornecem
diferentes maneiras de inserir novos registros em um banco de dados, dependendo dos
requisitos do seu aplicativo. Você pode usar o método TableAdapter.Update ou um dos
métodos TableAdapter DBDirect (especificamente, o método TableAdapter.Insert ).
Este artigo descreve como inserir registros em um banco de dados para um aplicativo
criado com o ADO.NET e o .NET Framework usando o Visual Basic (VB) ou o C#. Se a
configuração do aplicativo usar o Entity Framework 6, consulte Adicionando uma nova
entidade ao contexto ou, para o Entity Framework Core, consulte Adicionando dados.
７ Observação

mais simples.
Pré-requisitos
Para trabalhar com métodos TableAdapter, você precisa ter uma instância
disponível. Para obter mais informações, consulte Criar e configurar TableAdapters
em aplicativos .NET Framework.
Segurança do .NET: você deve ter acesso ao banco de dados ao qual está
tentando se conectar e permissão para executar inserções na tabela desejada.
Escolha o método de inserção
Há diferentes abordagens para inserir registros em um banco de dados com base no
cenário do aplicativo. A tabela a seguir resume as opções:
Cenário Abordagem Observações
O aplicativo usa Use o método As alterações incluem atualizações,

conjuntos de TableAdapter.Update para enviar inserções e exclusões.
dados para todas as alterações para o banco
armazenar dados de dados
O aplicativo usa Use o método TableAdapter.Insert Essa abordagem permite que você
objetos para para inserir novos registros no tenha um controle mais preciso sobre a
armazenar dados banco de dados criação de novos registros.
O aplicativo usa Defina a propriedade Se o TableAdapter não tiver um método

TableAdapters, TableAdapter Insert , o TableAdapter será
método Insert GenerateDBDirectMethods como configurado para usar procedimentos
não disponível true de dentro do Designer de armazenados ou a propriedade
Conjunto de Dados e salve o GenerateDBDirectMethods será definida
conjunto de dados para regenerar como false .
o TableAdapter Se o método Insert permanecer
indisponível após a regeneração do
TableAdapter, 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).
O aplicativo não Usar objetos de comando para Exemplo: SqlCommand

usa inserir novos registros no banco
TableAdapters de dados
Inserir novos registros usando TableAdapters

Se o seu aplicativo usar conjuntos de dados para armazenar dados, você pode adicionar
novos registros ao DataTable desejado no conjunto de dados e, em seguida, chamar o
método TableAdapter.Update . O método TableAdapter.Update envia quaisquer
alterações no DataTable para o banco de dados, incluindo registros modificados e
excluídos.
Inserir novos registros com o método
TableAdapter.Update
O procedimento a seguir demonstra como inserir novos registros em um banco de
dados usando o método TableAdapter.Update :
1. Adicione novos registros ao DataTable desejado criando um novo DataRow e

adicionando-o à coleção Rows.
2. Depois de adicionar as novas linhas ao DataTable, chame o método

TableAdapter.Update . Você pode controlar a quantidade de dados a serem
atualizados passando um dos seguintes valores de parâmetro:
Um DataSet inteiro
Uma DataTable
Uma matriz de DataRows
Uma única DataRow
O código a seguir mostra como adicionar um novo registro a um DataTable e, em

seguida, chamar o método TableAdapter.Update para salvar a nova linha no banco
de dados. Este exemplo usa a tabela Region no banco de dados Northwind.
C#
// 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);
Inserir novos registros com o método TableAdapter.Insert

Se o aplicativo usar objetos para armazenar dados, você poderá usar o método
TableAdapter.Insert para criar novas linhas diretamente no banco de dados. O método
Insert aceita os valores individuais de cada coluna como parâmetros. Quando você
chama o método, um novo registro é inserido no banco de dados com os valores de
parâmetro passados.
Chame o método Insert do TableAdapter e passe os valores de cada coluna como

parâmetros.
O procedimento a seguir demonstra como usar o método TableAdapter.Insert para

inserir linhas. Este exemplo insere dados na tabela Region no banco de dados
Northwind.
７ Observação
Se você não tiver uma instância disponível, instancie o TableAdapter que deseja
usar.
C#
NorthwindDataSetTableAdapters.RegionTableAdapter regionTableAdapter =
regionTableAdapter.Insert(5, "NorthWestern");
Inserir novos registros com objetos de

comando
Você pode inserir novos registros diretamente em um banco de dados usando objetos
de comando.
Crie um novo objeto de comando e defina suas propriedades Connection ,

CommandType e CommandText .
O procedimento a seguir demonstra como inserir registros em um banco de dados

usando o objeto de comando. Este exemplo insere dados na tabela Region no banco de
dados Northwind.
C#
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();
Salvar dados com os métodos TableAdapter DBDirect em aplicativos do .NET
Framework
Comentários

Atualizar dados usando um
TableAdapter nos aplicativos .NET
Framework
Artigo • 12/01/2024
７ Observação

mais simples.
Depois que os dados em seu conjunto de dados tiverem sido modificados e validados,
você poderá enviar os dados atualizados de volta para um banco de dados chamando o
método Update de um TableAdapter. O método Update atualiza uma única tabela de
dados e executa o comando correto (INSERT, UPDATE ou DELETE) com base no
RowState de cada linha de dados na tabela. Quando um conjunto de dados tem tabelas
relacionadas, o 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
vinculação de dados cria uma variável membro da classe TableAdapterManager
chamada tableAdapterManager.
７ Observação
Ao tentar atualizar uma fonte de dados com o conteúdo de um conjunto de dados,

você poderá obter erros. Para evitar erros, recomendamos que você coloque o
código que chama o método Update do adaptador dentro de um bloco try / catch .
O procedimento exato para atualizar uma fonte de dados pode variar dependendo das
necessidades comerciais, mas inclui as seguintes etapas:
1. Chame o método Update do adaptador em um bloco try / catch .
2. Se uma exceção for capturada, localize a linha de dados que causou o erro.
3. Reconcilie o problema na linha de dados (programaticamente, se puder, 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 método Update de um TableAdapter. Transmita 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 bloco try / catch . O exemplo a
seguir mostra como atualizar o conteúdo da tabela Customers em
NorthwindDataSet de dentro de um bloco try / catch .
C#
try
{
this.Validate();
this.customersBindingSource.EndEdit();
this.customersTableAdapter.Update(this.northwindDataSet.Customers);
MessageBox.Show("Update successful");
}
catch (System.Exception ex)
{
MessageBox.Show("Update failed");
}
Artigo • 04/05/2023
７ Observação

Atualização hierárquica refere-se ao processo de salvar dados atualizados (de um

conjunto de dados com duas ou mais tabelas relacionadas) de volta a um banco de
dados mantendo regras de integridade referencial. 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 pedidos sejam criados para esse cliente. Para
obter mais informações sobre relações em conjuntos de dados, consulte Relações em
conjuntos de dados.
O recurso de atualização hierárquica usa um TableAdapterManager para gerenciar os

TableAdapter s em um conjunto de dados tipado. O componente TableAdapterManager é
uma classe gerada pelo Visual Studio, não um tipo .NET. Quando você arrasta uma
tabela da janela Fontes de Dados para uma página do Windows Form ou WPF, o 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 classe TableAdapterManager , consulte a seção Referência de
tableAdapterManager de TableAdapters.
Por padrão, um conjunto de dados trata tabelas relacionadas como "somente relações",
o que significa que ele 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 TableAdapterManager se comporta ao enviar
as alterações nas tabelas relacionadas de volta ao banco de dados.
Habilitar a atualização hierárquica em um

conjunto de dados
Por padrão, a atualização hierárquica é habilitada para todos os novos conjuntos de
dados adicionados ou criados em um projeto. Ative ou desative a atualização
hierárquica definindo a propriedade Atualização Hierárquica de um conjunto de dados
tipado no conjunto de dados como True ou False:
Criar uma relação entre tabelas

Para criar uma relação entre duas tabelas, no 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 restrições de chave estrangeira,
atualizações em cascata e 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 conjunto de dados gerado.
Por padrão, as tabelas de dados em um conjunto de dados são geradas com relações
(DataRelation) que correspondem às relações no banco de dados. No entanto, a relação
no conjunto de dados não é gerada como uma restrição de chave estrangeira. O
DataRelation é configurado como Somente Relação, sem UpdateRule ou DeleteRule em
vigor.
Por padrão, atualizações e exclusões em cascata são desativadas mesmo que a relação
de banco de dados esteja definida com as atualizações e/ou exclusões em cascata
ativadas. Por exemplo, criar um cliente e um pedido e tentar salvar os dados pode
causar um conflito com as restrições de chave estrangeira definidas no banco de dados.
Para obter mais informações, confira Desativar restrições ao preencher um conjunto de
dados.
Definir a ordem de execução de atualizações

Definir a ordem de execução de atualizações define a ordem das inserções, atualizações
e exclusões individuais necessárias para salvar todos os dados modificados em todas as
tabelas de um conjunto de dados. 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 propriedade UpdateOrder que pode ser definida para
executar atualizações primeiro, depois inserções e depois exclusões.
７ Observação
É importante entender que a ordem de atualização é inclusiva. Ou seja, quando
atualizações são executadas, inserções e exclusões são executadas para todas as
tabelas no conjunto de dados.
Para definir a propriedade UpdateOrder depois de arrastar itens da Janela Fontes de

Dados para um formulário, selecione o TableAdapterManager na bandeja de
componentes e defina a propriedade UpdateOrder na janela Propriedades.
Criar uma cópia de backup de um conjunto de

dados antes de executar uma atualização
hierárquica
Quando você salva dados (chamando o método TableAdapterManager.UpdateAll() ), o
TableAdapterManager tenta atualizar os dados de cada tabela em uma só 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 para seu estado original.
No entanto, às vezes, você pode querer restaurar o conjunto de dados da cópia de

backup. Um exemplo disso pode ocorrer quando você está 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
dados e o conjunto de dados 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 isso é um problema, o TableAdapterManager fornece uma propriedade
BackupDataSetBeforeUpdate que substitui o conjunto de dados existente por uma cópia
de backup quando a transação falha.
７ Observação
A cópia de backup fica apenas na memória enquanto o método

TableAdapterManager.UpdateAll está em execução. Portanto, não há acesso
programático a esse conjunto de dados de backup, porque ele substitui o conjunto

de dados original ou sai do escopo assim que o método
TableAdapterManager.UpdateAll 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 método EndEdit do
primeiro BindingSource adicionado ao formulário. Ou seja, esse código é gerado apenas
para a primeira tabela 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 ).
７ Observação
O Designer de Conjunto de Dados só adiciona o código BindingSource.EndEdit

para a primeira tabela arrastada para o 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:

C#
C#
this.Validate();
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,
pode ser necessário adicionar o novo registro pai ( Customer ) ao conjunto de dados
antes que as restrições de chave estrangeira permitam que novos registros filho
( Orders ) sejam adicionados ao conjunto de dados. Para realizar isso, você pode usar o
evento filho BindingSource.AddingNew .
７ Observação
A necessidade de confirmar novos registros pai depende do tipo de controle usado

para associar à sua fonte de dados. Neste passo a passo, 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 complexa como o DataGridView, essa chamada EndEdit 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 Form1 na 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 método

CustomersBindingSource.EndEdit . O código no manipulador de eventos
OrdersBindingSource_AddingNew deve ser semelhante ao seguinte:

C#
C#
Referência de TableAdapterManager
Por padrão, uma classe TableAdapterManager é gerada quando você cria um conjunto de
dados que contém tabelas relacionadas. Para impedir que a classe seja gerada, altere o
valor da propriedade Hierarchical Update do conjunto de dados para false. Quando
você arrasta uma tabela que tem uma relação para a superfície de design de uma
página do Windows Form ou WPF, o Visual Studio declara uma variável de membro da
classe. Se você não usa a vinculação de dados, precisa declarar a variável manualmente.
A classe TableAdapterManager não é um tipo .NET. Portanto, você não pode pesquisá-la
na documentação. Ela é criada em tempo de design como parte do processo de criação
do conjunto de dados.
Estes são os métodos e as propriedades da classe TableAdapterManager usados com

frequência:
Membro Descrição
Método UpdateAll Salva todos os dados de todas as tabelas de dados.
Propriedade Determina se é necessário criar uma cópia de backup do conjunto

BackUpDataSetBeforeUpdate de dados antes de executar o método booliano
TableAdapterManager.UpdateAll .
Propriedade Representa um TableAdapter . O TableAdapterManager gerado

tableName TableAdapter contém uma propriedade para cada TableAdapter que gerencia. Por
exemplo, um conjunto de dados com uma tabela Clientes e Pedidos
é gerado com um TableAdapterManager que contém as
propriedades CustomersTableAdapter e OrdersTableAdapter .
Propriedade UpdateOrder Controla a ordem dos comandos de inserção, atualização e exclusão

individuais. Defina como um dos valores na enumeração
TableAdapterManager.UpdateOrderOption .
Por padrão, o UpdateOrder é definido como InsertUpdateDelete.

Isso significa que inserções, atualizações e exclusões são executadas
para todas as tabelas no conjunto de dados.
Confira também
Tratar uma exceção de simultaneidade
Artigo • 04/05/2023
７ Observação

Exceções de simultaneidade (System.Data.DBConcurrencyException) são geradas

quando dois usuários tentam alterar os mesmos dados em um banco de dados ao
mesmo tempo. Neste passo a passo, você cria um aplicativo do Windows que ilustra
como capturar uma DBConcurrencyException, localizar a linha que causou o erro e
aprender uma estratégia de como lidar com isso.
Este guia orienta você no seguinte processo:
1. Para criar um novo projeto de Aplicativo do Windows Forms.
2. Criar um conjunto de dados com base na tabela Northwind Customers.
3. Criar um formulário com um DataGridView para exibir os dados.
4. Preencher um conjunto de dados com dados da tabela Clientes no banco de

dados da Northwind.
5. Usar o recurso Mostrar Dados da Tabela no Gerenciador de Servidores para

acessar os dados da tabela Clientes e alterar um registro.
6. Alterar o mesmo registro para um valor diferente, atualizar o conjunto de dados e

tentar gravar as alterações no banco de dados, o que resultará na geração de um
erro de simultaneidade.
7. Capturar o erro e exibir as diferentes versões do registro, permitindo que o usuário
determine se deseja continuar e atualizar o banco de dados ou cancelar a
atualização.
Pré-requisitos
da Northwind.


alguns dados.

Executar.


Comece criando um aplicativo do Windows Forms:

4. Nomeie o projeto ConcurrencyWalkthrough e escolha OK.
O projeto ConcurrencyWalkthrough é criado e adicionado ao Gerenciador de

Soluções e um novo formulário é aberto no designer.
Criar o conjunto de dados da Northwind

Em seguida, crie um conjunto de dados chamado NorthwindDataSet:
1. No menu Dados, clique em Adicionar Nova Fonte de Dados.
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 da 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.
７ Observação
Se você estiver se conectando a um arquivo de banco de dados local,

selecione Não quando for perguntado se deseja adicionar o arquivo ao seu
projeto.
4. Na tela Salvar cadeia de conexão no arquivo de configuração de aplicativo,

selecione Avançar.
5. Expanda o nó Tabelas e selecione a tabela Clientes. O nome padrão do conjunto
de dados deve ser NorthwindDataSet.
6. Selecione Concluir para adicionar o conjunto de dados ao projeto.
Criar um controle DataGridView associado a

dados
Nesta seção, você criará um System.Windows.Forms.DataGridView arrastando o item
Clientes da janela Fontes de Dados para o Formulário do Windows.
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ó NorthwindDataSet e selecione a tabela

Clientes.
3. Selecione a seta para baixo no nó da tabela e, em seguida, selecione

DataGridView na lista suspensa.
4. Arraste a tabela para uma área vazia do formulário.
Um controle DataGridView chamado CustomersDataGridView e um

BindingNavigator chamado CustomersBindingNavigator é adicionado ao
formulário associado ao BindingSource. Este, por sua vez, está associado à tabela
Clientes no NorthwindDataSet.
Testar o formulário
Agora você pode testar o formulário para verificar se ele se comporta da forma
esperada até o momento:
O formulário é exibido com um controle DataGridView que é preenchido com os

dados da tabela Clientes.
2. No menu Depurar, selecione Interromper Depuração.
Tratar erros de simultaneidade

A maneira como você trata os erros depende das regras de negócios específicas que
regem seu aplicativo. Neste passo a passo, usamos a estratégia a seguir como exemplo
para lidar com o erro de simultaneidade.
O aplicativo apresenta ao usuário três versões do registro:
O registro atual no banco de dados
O registro original carregado no conjunto de dados
As alterações propostas no conjunto de dados
Em seguida, o usuário pode substituir o banco de dados pela versão proposta ou

cancelar a atualização e atualizar o conjunto de dados com os novos valores do banco
de dados.
Para habilitar o tratamento de erros de simultaneidade

1. Crie um manipulador de erros personalizado.
2. Mostre opções para o usuário.
3. Processe a resposta do usuário.
4. Reenvie a atualização ou redefina os dados no conjunto de dados.
Adicionar código para tratar a exceção de simultaneidade

Quando você tenta executar uma atualização e uma exceção é gerada, geralmente você
faz algo com as informações fornecidas pela exceção gerada. Nesta seção, você
adicionará um código que tentará atualizar o banco de dados. Você também vai tratar
qualquer DBConcurrencyException que possa ser gerada, bem como quaisquer outras
exceções.
７ Observação
Os métodos CreateMessage e ProcessDialogResults são adicionados

posteriormente no passo a passo.
1. Adicione o seguinte código ao método Form1_Load :
C#
C#
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.");
}
}
2. Substitua o método CustomersBindingNavigatorSaveItem_Click para chamar o

método UpdateDatabase para que ele fique com a seguinte aparência:
C#
C#
private void customersBindingNavigatorSaveItem_Click(object sender,

EventArgs e)
{
UpdateDatabase();
}
Mostrar opções para o usuário

O código que você acabou de escrever chama o procedimento CreateMessage para
exibir informações de erro para o usuário. Neste passo a passo, você vai usar uma caixa
de mensagem para exibir as diferentes versões do registro para o usuário. Isso permitirá
que o usuário escolha se deseja substituir o registro pelas 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 método ProcessDialogResult .
Crie a mensagem adicionando o código a seguir ao Editor de Códigos. Insira este

código abaixo do método UpdateDatabase :
C#
C#
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;
}
Processar a resposta do usuário

Você também precisa de código para processar a resposta do usuário à 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 Merge
será chamado com o argumento preserveChanges definido como true. Isso fará com
que a tentativa de atualização seja bem-sucedida, pois a versão original do registro
agora corresponde ao registro que está no banco de dados.
Adicione o seguinte código abaixo do código que foi adicionado na seção anterior:
C#
C#
// 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;
}
}
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 simultaneidade, altere os dados no banco de
dados depois de preencher o NorthwindDataSet.
2. Depois que o formulário for exibido, deixe-o em execução e alterne para o IDE do
Visual Studio.
3. No menu Exibir, escolha Gerenciador de Servidores.
4. No Gerenciador de Servidores, 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.
７ Observação
Navegue até uma linha diferente para confirmar a alteração.
7. Alterne 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 simultaneidade é gerado e a caixa de mensagem é exibida.
A seleção de Não cancelará a atualização e atualizará o conjunto de dados com os

valores que estão atualmente no banco de dados. A seleção de Sim gravará o valor
proposto no banco de dados.
Confira também
Salvar dados usando uma transação em
Artigo • 05/11/2024
７ Observação

mais simples.
Salve dados em uma transação usando o namespace System.Transactions. Use o objeto

TransactionScope a fim de participar de uma transação que é gerenciada
automaticamente para você.
Os projetos não são criados com uma referência ao assembly System.Transactions, ou

seja, você precisa adicionar manualmente uma referência a projetos que usam
transações.
A maneira mais fácil de implementar uma transação é criar uma instância de um objeto
TransactionScope em uma instrução using . (Para obter mais informações, confira
Instrução using e instrução using.) O código executado dentro da instrução using
participa da transação.
Para confirmar a transação, chame o método Complete como a última instrução no

bloco using.
Para reverter a transação, gere uma exceção antes de chamar o método Complete.
Para adicionar uma referência ao arquivo

System.Transactions.dll
1. No menu Projeto, selecione Adicionar Referência.
2. Na guia .NET (guia SQL Server para projetos do SQL Server), selecione
System.Transactions e 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 na instrução using que contém a transação. O
código a seguir mostra como criar e instanciar um objeto TransactionScope em
uma instrução using:
C#
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();
}
Passo a passo: salvar dados em uma transação
Comentários

Passo a passo: salvar dados em uma
transação em aplicativos do .NET
Framework
Artigo • 07/12/2023
７ Observação

mais simples.
Este passo a passo demonstra como salvar dados em uma transação usando o
namespace System.Transactions. Neste passo a passo, você criará um aplicativo
Windows Forms. Você usará o Assistente de Configuração da Fonte de Dados para criar
um conjunto de dados para duas tabelas no banco de dados de exemplo Northwind.
Você adicionará controles associados a dados a um formulário do Windows e modificará
o código do botão salvar do BindingNavigator para atualizar o banco de dados dentro
de um TransactionScope.
Pré-requisitos
da Northwind.
parte da carga de trabalho do Desenvolvimento para desktop com .NET ou como


alguns dados.

Executar.

Criar um aplicativo do Windows Forms

A primeira etapa é criar um Aplicativo do Windows Forms (.NET Framework).

4. Nomeie o projeto como SavingDataInATransactionWalkthroughe escolha OK.
O projeto SavingDataInATransactionWalkthrough é 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 Customers e Orders no banco de dados de exemplo
Northwind.
Dados.
3. Na tela Escolher um Tipo de Fonte de Dados, selecione Banco de Dados e, em

seguida, Avançar.
4. Na tela 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.
-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.
confidenciais e, em seguida, selecione Avançar.
6. Na tela Salvar cadeia de conexão no arquivo de Configuração de Aplicativo,

selecione Avançar.
7. Expanda o nó Tabelas na tela Escolher Objetos do Banco de Dados.
8. Selecione as tabelas Customers e Orders , em seguida, selecione Concluir.
O NorthwindDataSet é adicionado ao projeto e as tabelas Customers e Orders

Adicionar controles ao formulário

Você pode criar controles de associação de dados arrastando itens da janela Fontes de
Dados para um 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 , BindingSource e BindingNavigator aparecem na bandeja
do componente.
3. Arraste o nó Pedidos relacionado (não o nó principal Pedidos, mas o nó da tabela

filho relacionado abaixo da coluna Fax) para o formulário abaixo de
ClientesDataGridView.
Um DataGridView aparece no formulário. OrdersTableAdapter e BindingSource

aparecem na bandeja de componentes.
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 do

BindingNavigator
Para a primeira tabela que entra em seu formulário como padrão, o código é adicionado
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, refatoramos o código de salvamento existente do manipulador de eventos de
clique do botão salvar. Também criamos mais alguns métodos para fornecer
funcionalidade de atualização específica 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 de Salvar no CustomersBindingNavigator (o botão com o ícone
de disquete).
2. Substitua o método CustomersBindingNavigatorSaveItem_Click pelo seguinte

código:
C#
C#
private void customersBindingNavigatorSaveItem_Click(object sender,

EventArgs e)
{
UpdateData();
}
private void UpdateData()

{
this.Validate();
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:
Exclua registros filho. (Nesse caso, exclua registros da tabela Orders .)
Exclua registros pai. (Nesse caso, exclua registros da tabela Customers .)
Insira registros pai. (Nesse caso, insira registros na tabela Customers .)
Insira registros filho. (Nesse caso, insira registros na tabela Orders .)

Para excluir pedidos existentes
Adicione o seguinte método DeleteOrders a Form1:
C#
C#
private void DeleteOrders()

{
NorthwindDataSet.OrdersDataTable deletedOrders;
deletedOrders = (NorthwindDataSet.OrdersDataTable)
northwindDataSet.Orders.GetChanges(DataRowState.Deleted);
if (deletedOrders != null)
{
try
{
ordersTableAdapter.Update(deletedOrders);
}
{
MessageBox.Show("DeleteOrders Failed");
}
}
}
Para excluir clientes existentes

Adicione o seguinte método DeleteCustomers a Form1:
C#
C#
private void DeleteCustomers()

{
NorthwindDataSet.CustomersDataTable deletedCustomers;
deletedCustomers = (NorthwindDataSet.CustomersDataTable)
northwindDataSet.Customers.GetChanges(DataRowState.Deleted);
if (deletedCustomers != null)
{
try
{
customersTableAdapter.Update(deletedCustomers);
}
{
MessageBox.Show("DeleteCustomers Failed");
}
}
}
Para adicionar novos clientes

Adicione o seguinte método AddNewCustomers a Form1:
C#
C#
private void AddNewCustomers()

{
NorthwindDataSet.CustomersDataTable newCustomers;
newCustomers = (NorthwindDataSet.CustomersDataTable)
northwindDataSet.Customers.GetChanges(DataRowState.Added);
if (newCustomers != null)
{
try
{
customersTableAdapter.Update(newCustomers);
}
{
MessageBox.Show("AddNewCustomers Failed");
}
}
}
Para adicionar novos pedidos

Adicione o seguinte método AddNewOrders a Form1:
C#
C#
private void AddNewOrders()

{
NorthwindDataSet.OrdersDataTable newOrders;
newOrders = (NorthwindDataSet.OrdersDataTable)
northwindDataSet.Orders.GetChanges(DataRowState.Added);
if (newOrders != null)
{
try
{
ordersTableAdapter.Update(newOrders);
}
{
MessageBox.Show("AddNewOrders Failed");
}
}
}
Pressione F5 para executar o aplicativo.
Como salvar dados usando uma transação
Salvar dados em um banco de dados
(várias tabelas) em aplicativos do .NET
Framework
Artigo • 07/12/2023
７ Observação

mais simples.
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 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:
Criar e configurar 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 quando arrastado 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 conjunto de dados.
Modificando o código para enviar os dados atualizados no conjunto de dados de

volta ao banco de dados.
Pré-requisitos
da Northwind.


alguns dados.
Executar.

Criar o aplicativo do Windows Forms

Crie um projeto de Aplicativo do Windows Forms 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 da Northwind, consulte Como
instalar bancos de dados de exemplo.

seguida, Avançar.

-ou-
Selecione Nova Conexão para abrir a caixa de diálogo Adicionar/Modificar

Conexão.

selecione Avançar.
8. Selecione as tabelas Clientes e Pedidos e, em seguida, selecione Finalizar.
O NorthwindDataSet é 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 Customers estão em um layout Detalhes
onde os dados são exibidos em controles individuais. Os dados da tabela Orders
estarão no layout Grade exibidos em um controle DataGridView.
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 controle para alterar o controle da

tabela Clientes para controles individuais. Para obter mais informações, consulte
Definir o controle a ser criado quando arrastado da janela Fontes de Dados.
Criar o formulário associados a dados

Dados para um 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 ,
BindingSource e BindingNavigator aparecem na bandeja do componente.
2. Arraste o nó Ordens relacionado da janela Fontes de Dados para Form1.
７ Observação
O nó Ordens relacionado está localizado abaixo da coluna Fax e é um nó filho

do nó Clientes.
navegação em registros são exibidos no formulário. OrdersTableAdapter e
BindingSource aparecem na bandeja de componentes.
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 BindingNavigator é adicionado ao código do formulário para enviar
atualizações para o banco de dados. Este procedimento modifica o código para enviar
atualizações na ordem correta. Isso elimina a possibilidade de gerar 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.
７ Observação
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 dentro de 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 qualquer alteração seja confirmada. Para obter mais informações,
consulte Transações e simultaneidade.
Para adicionar lógica de atualização ao aplicativo

1. Selecione o botão Salvar em BindingNavigator. Isso abre o Editor de Código para
o manipulador de eventos bindingNavigatorSaveItem_Click .
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 executadas na ordem correta. O
código deve se parecer com o seguinte:
C#
C#
this.Validate();
NorthwindDataSet.OrdersDataTable deletedOrders =
(NorthwindDataSet.OrdersDataTable)
northwindDataSet.Orders.GetChanges(DataRowState.Deleted);
NorthwindDataSet.OrdersDataTable newOrders =
northwindDataSet.Orders.GetChanges(DataRowState.Added);
NorthwindDataSet.OrdersDataTable modifiedOrders =
northwindDataSet.Orders.GetChanges(DataRowState.Modified);
try
{
// Remove all deleted orders from the Orders table.
{
ordersTableAdapter.Update(deletedOrders);
}
// Update the Customers table.

customersTableAdapter.Update(northwindDataSet.Customers);
// Add new orders to the Orders table.

{
ordersTableAdapter.Update(newOrders);
}
// Update all modified Orders.

if (modifiedOrders != null)
{
ordersTableAdapter.Update(modifiedOrders);
}
northwindDataSet.AcceptChanges();
}

{
MessageBox.Show("Update failed");
}
finally
{
{
deletedOrders.Dispose();
}
{
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.
Salvar dados de um objeto em um
banco de dados em aplicativos do .NET
Framework
Artigo • 05/11/2024
７ Observação

mais simples.
Você pode salvar dados em objetos em um banco de dados passando os valores do

objeto para um dos métodos DBDirect do TableAdapter (por exemplo,
TableAdapter.Insert ). Para obter mais informações, confira TableAdapter.
Para salvar dados de uma coleção de objetos, execute um loop pela coleção de objetos
(por exemplo, um loop for-next) e envie os valores de cada objeto para o banco de
dados usando um dos métodos DBDirect do TableAdapter.
Por padrão, os métodos DBDirect 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 objetos DataSet ou DataTable para reconciliar alterações para
enviar atualizações a um banco de dados.
７ Observação
Quando você está configurando um TableAdapter, a consulta principal precisa

fornecer informações suficientes para que os métodos DBDirect sejam criados. Por
exemplo, se um TableAdapter estiver configurado para consultar dados de uma
tabela que não tenha uma coluna de chave primária definida, ele não gerará
métodos DBDirect .
Métodos DBDirect Descrição

TableAdapter
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 registros existentes em um banco de dados. O método Update

usa 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 TableAdapter.Update também é usado para reconciliar as

alterações em um conjunto de dados de volta ao banco de dados
usando uma matriz DataSet, DataTable, DataRow ou uma matriz de
DataRows como 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 novos registros de um objeto em

um banco de dados
Crie os registros passando os valores para o método TableAdapter.Insert .
O exemplo a seguir cria um registro de cliente na tabela Customers passando os

valores no objeto currentCustomer para o método TableAdapter.Insert .
C#
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);
}
Para atualizar registros existentes de um objeto

para um banco de dados
Modifique os registros chamando o método TableAdapter.Update , passando os
novos valores para atualizar o registro e passando os valores originais para
localizar o registro.
７ Observação
Seu objeto precisa manter os valores originais para passá-los para o método
Update . Este exemplo usa propriedades com um prefixo orig para armazenar
os valores originais.
O exemplo a seguir atualiza um registro existente na tabela Customers passando

os valores novos e originais no objeto Customer para o método
TableAdapter.Update .
C#
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);
}
Para excluir registros existentes de um banco

de dados
Exclua os registros chamando o método TableAdapter.Delete e passando os
valores originais para localizar o registro.
７ Observação
Seu objeto precisa manter os valores originais para passá-los para o método
Delete . Este exemplo usa propriedades com um prefixo orig para armazenar
os valores originais.
O exemplo a seguir exclui um registro da tabela Customers passando os valores

originais no objeto Customer para o método TableAdapter.Delete .
C#
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);
}
Segurança do .NET
Você precisa ter permissão para executar o INSERT , o UPDATE ou o DELETE selecionado
na tabela no banco de dados.
Comentários

Salvar os dados com os métodos
TableAdapter DBDirect
Artigo • 04/05/2023
７ Observação

Este tutorial fornece instruções detalhadas para a execução de 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 e
procedimentos armazenados específicos de SQL chamando os métodos individuais
Insert , Update e Delete , conforme a necessidade do seu aplicativo (ao contrário do
método Update sobrecarregado, que executa instruções UPDATE, INSERT e DELETE em

apenas uma chamada).
Neste tutorial, você aprenderá a:
Criar e configurar 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.
Adicionar métodos para acessar diretamente o banco de dados e executar
inserções, atualizações e exclusões.
Pré-requisitos
As etapas neste tutorial funcionam com aplicativos .NET Framework Windows Forms.
Este tutorial usa o SQL Server Express LocalDB e o banco de dados de exemplo da
Northwind.


alguns dados.

Executar.


A primeira etapa é criar um Aplicativo do Windows Forms. Crie um projeto usando o
tipo de projeto Windows Forms App, usando C# ou Visual Basic.
７ Observação
O código deste tutorial está disponível em C# e Visual Basic. Para alternar a
linguagem de código nesta página entre C# e Visual Basic, use o comutador de
linguagem de código na parte superior da página à direita.
Criar uma fonte de dados com base em seu

banco de dados
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 da Northwind,
consulte Como instalar bancos de dados de exemplo.
Para criar a fonte de dados


seguida, Avançar.

-ou-

Adicionar/Modificar Conexão.

selecione Avançar.

8. Escolha a tabela Region e selecione Concluir.
O NorthwindDataSet é adicionado ao projeto e a tabela Region aparece na janela

Fontes de Dados.
Adiciona 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 associados a dados no formulário do Windows, arraste o nó Região

principal da janela Fontes de Dados para o formulário.

navegação em registros são exibidos no formulário. Um NorthwindDataSet,
RegionTableAdapter , BindingSource e BindingNavigator aparece na bandeja do
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 Texto
InsertButton Inserção
UpdateButton Atualizar
DeleteButton Excluir
Para adicionar código para inserir novos registros no

banco de dados
1. Selecione InsertButton 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 InsertButton_Click pelo seguinte código:

C#
C#
private void InsertButton_Click(object sender, EventArgs e)

{
Int32 newRegionID = 5;
String newRegionDescription = "NorthEastern";
try
{
regionTableAdapter1.Insert(newRegionID,
newRegionDescription);
}
{
MessageBox.Show("Insert Failed");
}
RefreshDataset();
}
private void RefreshDataset()

{
this.regionTableAdapter1.Fill(this.northwindDataSet1.Region);
}
７ Observação
Dependendo da versão do Visual Studio e dos modelos de projeto usados, os

nomes de variáveis como regionTableAdapter ou regionTableAdapter1 usados
nesse código podem ou não ter um 1 à direita no código gerado. Faça
quaisquer correções em seu código para garantir que o nome correto seja
usado em todos os lugares. O Visual Studio mostra um rabiscos vermelho em
que o nome está incorreto.
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:

C#
C#
private void UpdateButton_Click(object sender, EventArgs e)

{
Int32 newRegionID = 5;
try
{
regionTableAdapter1.Update(newRegionID, "Updated Region
Description", 5, "NorthEastern");
}
{
MessageBox.Show("Update Failed");
}
RefreshDataset();
}
Para adicionar código excluir registros do banco de dados

1. Selecione DeleteButton 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 DeleteButton_Click pelo seguinte código:
C#
C#
private void DeleteButton_Click(object sender, EventArgs e)

{
try
{
regionTableAdapter1.Delete(5, "Updated Region
Description");
}
{
MessageBox.Show("Delete Failed");
}
RefreshDataset();
}
Selecione F5 para executar o aplicativo.
Clique no botão Inserir e verifique se você vê o novo registro na grade.
Selecione o botão Atualizar e verifique se o registro foi atualizado na grade.
Selecione botão Excluir e verifique se o registro foi removido da grade.
Próximas etapas
Dependendo dos requisitos do aplicativo, existem várias etapas que você talvez queira
realizar após criar um formulário de associação de dados. Entre algumas das melhorias
que você poderia fazer nesse tutorial 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 conjunto de dados abaixo.
Confira também
Salvar um conjunto de dados como XML
em aplicativos do .NET Framework
Artigo • 12/01/2024
７ Observação

mais simples.
Acesse os dados XML em um conjunto de dados chamando os métodos XML

disponíveis no conjunto de dados. Para salvar os dados no formato XML, você pode
chamar o método GetXml ou o método WriteXml de um DataSet.
Chamar o método GetXml retorna uma cadeia de caracteres que contém os dados de
todas as tabelas de dados no conjunto de dados formatado como XML.
Chamar o método WriteXml envia os dados formatados em XML para um arquivo que
você especificar.
Para salvar os dados em um conjunto de dados

como XML em uma variável
O método GetXml retorna uma String. Declare uma variável do tipo String e
atribua a ela os resultados do método GetXml.
C#
string xmlData = northwindDataSet.GetXml();

Para salvar os dados em um conjunto de dados
como XML em um arquivo
O método WriteXml tem várias sobrecargas. Declare uma variável e atribua a ela
um caminho válido para salvar o arquivo. O seguinte código mostra como salvar
os dados em um arquivo:
C#
string filePath = "ENTER A VALID FILEPATH";

northwindDataSet.WriteXml(filePath);
Consultar conjuntos de dados em
Artigo • 12/01/2024
７ Observação

mais simples.
Para pesquisar registros específicos em um conjunto de dados, use o método FindBy na

DataTable, escreva sua própria instrução foreach para executar um loop na coleção
Rows da tabela ou use LINQ to DataSet.
Diferenciação de maiúsculas e minúsculas do

conjunto de dados
Em um conjunto de dados, os nomes de tabela e coluna não diferenciam maiúsculas de
minúsculas por padrão, ou seja, uma tabela em um conjunto de dados chamada
"Clientes" também pode ser chamada de "clientes". Isso corresponde às convenções de
nomenclatura de muitos bancos de dados, incluindo o SQL Server. No SQL Server, o
comportamento padrão é que os nomes dos elementos de dados não podem ser
diferenciados apenas por maiúsculas e minúsculas.
７ Observação
Ao contrário dos conjuntos de dados, os documentos XML diferenciam maiúsculas

de minúsculas, portanto, os nomes dos elementos de dados definidos em
esquemas diferenciam maiúsculas de minúsculas. Por exemplo, o protocolo do
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 pelo uso de
maiúsculas e minúsculas é usado para gerar uma classe de conjunto de dados.
No entanto, a diferenciação de maiúsculas e minúsculas pode ser um fator na forma

como os dados são interpretados no conjunto de dados. Por exemplo, se você filtrar
dados em uma tabela de conjunto de dados, os critérios de pesquisa poderão retornar
resultados diferentes dependendo de se a comparação diferencia maiúsculas de
minúsculas. Você pode controlar a diferenciação de maiúsculas e minúsculas da
filtragem, pesquisa e classificação definindo a propriedade CaseSensitive do conjunto de
dados. Todas as tabelas do conjunto de dados herdam o valor dessa propriedade por
padrão. (Você pode substituir essa propriedade para cada tabela definindo a
propriedade CaseSensitive da tabela).
Localizar uma linha específica em uma tabela

de dados
Para localizar uma linha em um conjunto de dados tipado com um

valor de chave primária
Para localizar uma linha, chame o método fortemente tipado FindBy que usa a
chave primária da tabela.
No exemplo a seguir, a coluna CustomerID é a chave primária da tabela Customers .

Isso significa que o método FindBy gerado é FindByCustomerID . O exemplo mostra
como atribuir um DataRow específico a uma variável usando o método gerado
FindBy .
C#
NorthwindDataSet.CustomersRow customersRow =
northwindDataSet1.Customers.FindByCustomerID("ALFKI");
Para localizar uma linha em um conjunto de dados não tipado com

um valor de chave primária
Chame o método Find de uma coleção DataRowCollection, passando a chave
primária como um parâmetro.
O exemplo a seguir mostra como declarar uma nova linha chamada foundRow e
atribuir a ela o valor retornado do método Find. Se a chave primária for
encontrada, o conteúdo do índice da coluna 1 será exibido em uma caixa de
mensagem.
C#
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");
}
Localizar linhas por valores de coluna
Para localizar linhas com base nos valores de qualquer coluna
As tabelas de dados são criadas com o método Select, que retorna uma matriz de
DataRows com base na expressão passada para o método Select. Para obter mais
informações sobre como criar expressões válidas, consulte a seção "Sintaxe de
expressão" da página da propriedade Expression.
O exemplo a seguir mostra como usar o método Select do DataTable para localizar
linhas específicas.
C#
DataRow[] foundRows;
foundRows = dataSet1.Tables["Customers"].Select("CompanyName Like
'A%'");
Acessar registros relacionados
Quando as tabelas em um conjunto de dados estão relacionadas, um objeto
DataRelation pode disponibilizar os registros relacionados em outra tabela. Por
exemplo, um conjunto de dados que contém tabelas Customers e Orders pode ser
disponibilizado.
Você pode usar um objeto DataRelation para localizar registros relacionados chamando
o método GetChildRows de um DataRow na tabela pai. Esse método retorna uma matriz
de registros filho relacionados. Ou você pode chamar o método GetParentRow de um
DataRow na tabela filho. Esse método retorna um único DataRow da tabela pai.
Esta página fornece exemplos usando conjuntos de dados tipados. Para obter
informações sobre como navegar em relações em conjuntos de dados não tipados,
consulte Navegando em DataRelations.
７ Observação
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 nas
relações em conjuntos de dados tipados. Os exemplos de código usam os métodos
tipados DataRows ( NorthwindDataSet.OrdersRow ) e FindByPrimaryKey ( FindByCustomerID )
gerados para localizar uma linha desejada e retornar os registros relacionados. Os
exemplos são compilados e executados corretamente somente se você tiver:
Uma instância de um conjunto de dados chamado NorthwindDataSet com uma

tabela Customers .
Uma tabela Orders .
Uma relação chamada FK_Orders_Customers relacionando as duas tabelas.
Além disso, ambas as tabelas precisam ser preenchidas com os dados para que todos os
registros sejam retornados.
Para retornar os registros filho de um registro pai selecionado

Chame o método GetChildRows de uma linha de dados específica Customers e
retorne uma matriz de linhas da tabela Orders :
C#
string custID = "ALFKI";

NorthwindDataSet.OrdersRow[] orders;
orders = (NorthwindDataSet.OrdersRow[])northwindDataSet.Customers.
FindByCustomerID(custID).GetChildRows("FK_Orders_Customers");
MessageBox.Show(orders.Length.ToString());
Para retornar o registro pai de um registro filho selecionado

Chame o método GetParentRow de uma linha de dados específica Orders e
retorne uma única linha da tabela Customers :
C#
int orderID = 10707;

NorthwindDataSet.CustomersRow customer;
customer = (NorthwindDataSet.CustomersRow)northwindDataSet.Orders.
FindByOrderID(orderID).GetParentRow("FK_Orders_Customers");
MessageBox.Show(customer.CompanyName);
Associar controles a dados em
aplicativos .NET Framework usando o
Visual Studio
Artigo • 12/01/2024
７ Observação

mais simples.
É possível exibir dados para usuários do aplicativo associando-se dados a controles.

Você pode criar esses controles associados a dados arrastando itens da janela Fontes de
Dados para uma superfície de design ou controles em uma superfície no Visual Studio.
Este tópico descreve as fontes de dados que você pode usar para criar controles
associados 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
associados a dados, consulte Associar controles do Windows Forms a dados no Visual
Studio e Associar controles do WPF a dados no 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 associados à interface do usuário. Em termos práticos, uma
fonte de dados pode ser uma classe do Entity Framework, um conjunto de dados, um
ponto de extremidade de serviço encapsulado em um objeto de proxy .NET, uma classe
LINQ to SQL ou qualquer objeto ou coleção .NET. Algumas fontes de dados permitem
que você crie controles associados a dados arrastando itens da janela Fontes de Dados,
enquanto outras não. A tabela a seguir mostra quais fontes de dados têm suporte.
Fonte de dados Suporte para arrastar e Suporte para Suporte para

soltar no Designer de arrastar e soltar arrastar e soltar no
Formulários do Windows no Designer do Silverlight Designer
WPF
Dataset Sim Sim No
Modelo de Dados de Sim1 Sim Yes

Entidade
Classes do LINQ to SQL Não2 Não2 Não2
Serviços (incluindo WCF Yes Sim Sim

Data Services, serviços
WCF e serviços Web)
Objeto Sim Sim Sim
SharePoint Sim Sim Yes
1. Gere o modelo usando o assistente Modelo de Dados de Entidade e arraste esses

objetos para o designer.
2. Classes LINQ to SQL 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
associados a dados. Para obter mais informações, consulte Passo a passo: criando
classes LINQ to SQL (Designer O-R).
janela Fontes de Dados

Fontes de dados estão disponíveis para o 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 no projeto, ou você pode abri-la (quando um projeto está aberto) escolhendo
Exibir>Outras Janelas>Fontes de Dados. Você pode arrastar itens dessa janela para
criar controles associados aos dados subjacentes, além de 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 associar
controles a dados.
Tarefa Mais informaçõ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
Defina o controle que é criado quando você arrasta Definir o controle a ser criado quando
um item da janela Fontes de Dados para o arrastado da janela Fontes de Dados
designer.
Modifique a lista de controles associados a itens na Adicionar controles personalizados à janela

janela Fontes de Dados. Fontes de Dados
Crie controles associados a dados. Associar controles do Windows Forms a

dados no Visual Studio
Tarefa Mais informações
Associar controles WPF a dados no Visual

Studio
Associe a um objeto ou uma coleção. Associar objetos no Visual Studio
Filtre dados que aparecem na interface do usuário. Filtrar e classificar dados em um aplicativo
do Windows Forms
Personalize legendas para controles. Personalizar como o Visual Studio cria

legendas para controles associados a dados
Associação de dados do Windows Forms
Definir o controle a ser criado quando
arrastado da janela Fontes de Dados
Artigo • 08/08/2024
７ Observação

mais simples.
Você pode criar controles associados a dados arrastando itens da janela Fontes de
Dados para o designer do WPF ou do Windows Forms. Cada item na janela Fontes de
Dados possui um controle padrão que é criado ao arrastá-lo para o designer. No
entanto, você pode optar por criar um controle diferente.
Definir os controles a serem criados para

objetos ou tabelas de dados
Antes de arrastar itens que representam objetos ou tabelas de dados 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 objetos ou

tabelas de dados
1. Verifique se o designer do WPF ou o designer do Windows Forms está aberto.
2. Na janela Fontes de Dados, selecione o item que representa o objeto ou a tabela
de dados que você deseja definir.
 Dica
Se a janela Fontes de Dados não estiver aberta, você poderá abri-la

selecionando Exibir>Outras Janelas>Fontes de Dados.
3. Clique no menu da lista suspensa do item e selecione um dos seguintes itens no

menu:
Para exibir cada campo de dados em um controle separado, clique em

Detalhes. Quando você arrasta o item de dados para o designer, essa ação
cria um controle associado a dados diferente para cada coluna ou
propriedade do objeto ou tabela de dados pai, juntamente com rótulos para
cada controle.
Para exibir todos os dados em um só 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ê abriu, de qual

versão do .NET o projeto tem como destino e de você ter adicionado controles
personalizados com suporte para a 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á adicioná-lo à lista. Para obter mais informações, confira 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 objetos ou tabelas de dados na janela Fontes
de Dados, consulte Criar um controle do usuário do Windows Forms com suporte
para associação de dados complexa.
Definir os controles a serem criados para

propriedades ou colunas de dados
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
propriedades ou colunas
1. Verifique se o designer do WPF ou o designer do 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 deseja definir o controle a ser
criado.
4. Clique no menu da lista suspensa da coluna ou propriedade e selecione o controle

que deseja criar quando o item for arrastado para o designer.
A lista de controles disponíveis depende de qual designer você abriu, de qual

versão do .NET o projeto tem como destino e de quais controles personalizados
com suporte para associação de dados você adicionou à Caixa de Ferramentas. Se
o controle que você deseja criar estiver na lista de controles disponíveis, você
poderá adicioná-lo à lista. Para obter mais informações, confira Adicionar controles
personalizados à janela Fontes de Dados.
Para saber como criar um controle personalizado que pode ser adicionado à lista
de controles para propriedades ou colunas de dados na janela Fontes de Dados,
consulte Criar um controle do usuário do Windows Forms com suporte para
associação de dados simples.
Se não quiser criar um controle para a coluna ou propriedade, selecione Nenhum

no menu da lista suspensa. Isso será útil se você quiser arrastar a tabela ou o
objeto pai para o designer, mas não quiser incluir a coluna ou propriedade
específica.
Comentários
Adicionar controles personalizados à
janela Fontes de Dados
Artigo • 04/05/2023
７ Observação

Ao arrastar um item da janela Fontes de Dados para uma superfície de design para criar
um controle associado a dados, você pode selecionar o tipo de controle criado. Cada
item na janela tem uma lista suspensa que exibe os controles que você pode escolher. O
conjunto de controles associado 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 associados a dados a
serem criados para 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 associáveis

Para adicionar ou remover controles da lista de controles disponíveis para itens na
janela Fontes de Dados com 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 clique no menu suspenso do item.
 Dica
Se a janela Fontes de Dados não estiver aberta, abra-a selecionando

Exibir>Outras Janelas>Fontes de Dados.
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 da interface do usuário de dados.
Se o Designer do WPF estiver aberto, a caixa de diálogo Personalizar

Associaçã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 para uma coluna de uma tabela ou 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 com

formas definidas pelo usuário, selecione [Outros]. Por exemplo, selecione
[Outros] se o 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 que esteja
disponível para o tipo de dados selecionado ou desmarque a seleção de todos os
controles que você deseja remover da lista.
７ Observação
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 que você acabou
de associar a um ou mais controles e 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 especifique o
comportamento de associaçã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:
Atributo Descriçã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 este atributo nos controles que exibem

listas (ou tabelas) de dados, mas também precisam
apresentar uma única coluna ou propriedade, como
ComboBox.
2. Para o 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 associáveis para um tipo de dados.
3. Na caixa Controles associados, o controle que você acabou de adicionar à Caixa
de Ferramentas deve aparecer.
７ Observação
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 associaçã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 arraste o item a ser
associado da janela Fontes de Dados para o controle.
Confira também
Caixa de diálogo Opções de personalização da interface do usuário de dados
Associar controles WPF a dados no
Visual Studio
Artigo • 04/05/2023
７ Observação

É possível exibir dados para usuários do aplicativo com a associação de dados a

controles. Para criar esses controles de associação de dados, é possível arrastar itens da
janela Fontes de Dados para o Designer do WPF 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 associados a dados no Visual
Studio, confira Associar controles a dados no Visual Studio. Para obter mais informações
sobre vinculação de dados do WPF, confira Visão geral de vinculaçã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 Designer do WPF.
Tarefa Mais
informações
Tarefa Mais
informações
Crie novos controles de associação de dados. Associar

controles do WPF
Associe controles existentes a dados. a um conjunto de
dados
Crie controles que exibam dados relacionados em uma relação pai-filho: Exibir dados
quando o usuário seleciona um registro de dados pai em um controle, outro relacionados em
controle exibe dados filho relacionados ao registro selecionado. aplicativos WPF
Crie uma tabela de pesquisa que exiba informações de uma tabela com base Criar tabelas de
no valor de um campo de chave estrangeira em outra tabela. pesquisa em
aplicativos do
WPF
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 Designer do WPF. 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 Designer do WPF, o
Visual Studio gera XAML que define um novo controle de associação de dados (ou
associa um controle existente à fonte de dados). Para algumas fontes de dados, o 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 XAML e o código que o Visual Studio gera para cada tipo de
fonte de dados na janela Fontes de Dados.
Fonte de dados Gerar XAML que associa um Gerar código que preenche a fonte
controle à fonte de dados de dados com dados
Fonte de dados Gerar XAML que associa um Gerar código que preenche a fonte
controle à fonte de dados de dados com dados
Dataset Sim Sim
Modelo de Dados Sim Sim

de Entidade
Serviço Sim Não
Objeto Sim Não
Conjunto de dados
Quando você arrasta uma tabela ou uma coluna da janela Fontes de Dados para o
designer, o Visual Studio gera XAML que faz 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 que foi selecionado
para o item arrastado e associará 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 de 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 já houver um manipulador de eventos
Loaded, o Visual Studio adicionará 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 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 na entidade.
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 \
<EntityName> é o nome da entidade.
Cria um manipulador de eventos Loaded para o elemento de interface do usuário

que contém o controle. O manipulador de eventos chama o método
Get<EntityName>Query para preencher a entidade com dados, recupera o
CollectionViewSource dos recursos do contêiner e, em seguida, torna o primeiro

item dados o item atual. Se já houver um manipulador de eventos Loaded, o Visual
Studio adicionará esse código ao manipulador de eventos existente.
Serviços
Quando você arrasta um objeto ou uma propriedade de serviço da janela Fontes de
Dados para o designer, o Visual Studio gera XAML que cria um controle de associação
de dados (ou associa um controle existente ao objeto ou à propriedade). No entanto, o
Visual Studio não gera o código que preenche o objeto de serviço do proxy com dados.
Você deve gravar esse código sozinho. Para obter um exemplo que demonstra como
fazer isso, confira Associar controles WPF a um serviço de dados WCF.
O Visual Studio gera XAML, que faz o seguinte:

exibir os dados no objeto retornado pelo serviço.
um novo Grid.
Objetos
Quando você arrasta um objeto ou uma propriedade da janela Fontes de Dados para o
designer, o Visual Studio gera XAML que cria um controle de associação de dados (ou
associa um controle existente ao objeto ou à propriedade). No entanto, o Visual Studio
não gera código para preencher o objeto com dados. Você deve gravar esse código
sozinho.
７ Observação
As classes personalizadas precisam ser públicas e, por padrão, ter um construtor

sem parâmetros. Elas não podem ser classes aninhadas com um "ponto" na sintaxe.
Para obter mais informações, confira XAML e classes personalizadas para WPF.
O Visual Studio gera XAML, que faz o seguinte:

exibir os dados no objeto.
um novo Grid.
Confira também
Vincular controles do WPF a um
conjunto de dados em aplicativos do
.NET Framework
Artigo • 07/12/2023
７ Observação

mais simples.
Neste passo a passo, você criará um aplicativo WPF que contém controles de associação
de dados. Os controles são associados a registros de produto que são encapsulados em
um conjunto de dados. Você também adicionará botões para navegar pelos produtos e
salvar alterações em registros de produtos.
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.
７ Observação
Pré-requisitos
Você precisará dos seguintes componentes para concluir este passo a passo:
processamento instaladas no Visual Studio. Para instalá-las, abra Instalador do
Visual Studio e escolha Modificar (ou Mais>Modificar) ao lado da versão do
Visual Studio que você deseja modificar. Confira Modificar o 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 AdventureWorks Light (AdventureWorksLT)
anexado a ele. Para baixar o banco de dados, consulte os bancos de dados de
exemplo doAdventureWorks.
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 mais informações, consulte as

ferramentas de conjunto de dados no Visual Studio e tableAdapters.
Associação de dados do WPF. Para obter mais informações, consulte Visão geral
de vinculação de dados.
Criar o projeto
Crie um novo projeto do WPF para exibir registros de produto.
1. Abra o Visual Studio.
2. Na tela Iniciar, selecione Criar um novo projeto.
3. Pesquise o modelo de projeto do 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 conjunto 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.

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).
O Visual Studio adiciona um novo AdventureWorksLTDataSet.xsd arquivo

AdventureWorksLTDataSet.xsd ao projeto, e adiciona um item correspondente
AdventureWorksLTDataSet à janela Fonte de dados O
AdventureWorksLTDataSet.xsd arquivo define um conjunto de dados tipado
chamado AdventureWorksLTDataSet e um 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.

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.
SQL
WHERE ThumbnailPhotoFileName <> 'no_image_available_small.gif'
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> :

XAML
<RowDefinition Height="75" />
<Button HorizontalAlignment="Left" Margin="22,20,0,24"
Name="backButton" Width="75"><</Button>
Name="nextButton" Width="75">></Button>
<Button HorizontalAlignment="Right" Margin="0,21,46,24"
Name="saveButton" Width="110">Save changes</Button>
Criar controles associados a dados

Crie controles que exibem registros do cliente arrastando a Product tabela da janela
Fontes de Dados para o WPF Designer.
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.
７ Observação
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
mais informações sobre o XAML e o código gerados, consulte Associar controles
WPF a dados no 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 o código que permite aos usuários rolar nos registros do produto ao usar os
botões < e >.
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-os apenas como globais

para o formulário e atribua-os dentro do Window_Loaded manipulador de eventos
semelhante ao seguinte:
C#
C#
private AdventureWorksProductsEditor.AdventureWorksLTDataSet
AdventureWorksLTDataSet;
private
AdventureWorksProductsEditor.AdventureWorksLTDataSetTableAdapters.P
roductTableAdapter adventureWorksLTDataSetProductTableAdapter;
private System.Windows.Data.CollectionViewSource productViewSource;

{
AdventureWorksLTDataSet =
((AdventureWorksProductsEditor.AdventureWorksLTDataSet)
(this.FindResource("adventureWorksLTDataSet")));
// Load data into the table Product. You can modify this code
as needed.
adventureWorksLTDataSetProductTableAdapter = new
AdventureWorksProductsEditor.AdventureWorksLTDataSetTableAdapters.P
roductTableAdapter();
adventureWorksLTDataSetProductTableAdapter.Fill(AdventureWorksLTDat
aSet.Product);
productViewSource = ((System.Windows.Data.CollectionViewSource)
(this.FindResource("productViewSource")));
productViewSource.View.MoveCurrentToFirst();
}
3. Adicione o seguinte código ao manipulador de eventos do backButton_Click :
C#
C#
if (productViewSource.View.CurrentPosition > 0)
{
productViewSource.View.MoveCurrentToPrevious();
}
4. Retorne ao designer e clique duas vezes no botão >.
5. Adicione o seguinte código ao manipulador de eventos do nextButton_Click :
C#
C#
if (productViewSource.View.CurrentPosition <
((CollectionView)productViewSource.View).Count - 1)
{
productViewSource.View.MoveCurrentToNext();
}
Salvar alterações nos registros do 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.

eventos saveButton_Click para o evento Click.
2. Adicione o seguinte código ao manipulador de eventos do saveButton_Click :
C#
C#
adventureWorksLTDataSetProductTableAdapter.Update(AdventureWorksLTD
ataSet.Product);
７ Observação
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 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 em 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 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 mais informações, consulte
Associar controles do WPF a um serviço de dados do 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
mais informações, consulte Passo a passo: exibir dados relacionados em um
aplicativo WPF.
Associar controles WPF a dados no Visual Studio
Visão geral da vinculação de dados
Associar controles do WPF a um WCF
Data Service
Artigo • 10/04/2023
Neste passo a passo, você criará um aplicativo WPF que contém controles de associação
de dados. Os controles estão associados a registros de clientes que são encapsulados
em um WCF Data Service. 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.
Criando um que expõe os dados no Modelo de Dados de Entidade para 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.
Criando um botão que salva as alterações dos dados nos controles para o e a
fonte de dados subjacente.
７ Observação
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 os bancos de dados de exemplo do 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 mais

informações, confira Visão geral do Entity Framework.
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. Inicie este passo a passo criando um projeto C# ou Visual Basic ASP.NET Aplicativo
Web. Nomeie o projeto AdventureWorksService.

Default.aspx e selecione Excluir. Esse arquivo não é necessário para o passo a
passo.
Crie um Modelo de Dados de Entidade para o

serviço
Para expor os dados para 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 WFCF, dois tipos de
modelos de dados: Modelos de Dados de Entidade e modelos de dados personalizados
definidos usando objetos CRL (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.
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.
Criar o serviço
Crie um Serviço de Dados do WCF para expor os dados no Modelo de Dados de
Entidade a um aplicativo WPF:
2. Na lista Modelos Instalados, clique em Web e selecione o item de projeto Serviço

de Dados WCF.
3. Na caixa Nome, digite AdventureWorksService.svc e clique em OK.
O Visual Studio adiciona 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 de AdventureWorks.svc códigos, substitua o AdventureWorksService

declaração se sala com os seguintes códigos.
C#
C#
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);
}
}
Este código atualiza a classe AdventureWorksService, de modo que ela deriva de

umDataService<T> que opera AdventureWorksLTEntities na classe de contexto do
objeto em seu 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.
Para criar o aplicativo cliente WPF

Para exibir os dados do WCF Data Service, crie um novo aplicativo WPF com uma fonte
de dados que se baseie 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.
O Visual Studio adiciona o AdventureWorksSalesEditor projeto à solução.

7. Na página Escolher um Tipo de Fonte de Dados do assistente, selecione Serviço e

clique em Próximo.
8. Na caixa de diálogo Adicionar Referência de Serviço, clique em Descobrir.
O Visual Studio pesquisa a solução atual para os serviços disponíveis e acrescenta

AdventureWorksService.svc AdventureWorksService.svc à lista de serviços
disponíveis na caixa Serviços.
9. Na caixa Namespace, digite AdventureWorksService.
10. Na caixa Serviços, clique em AdventureWorksService.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 Serviç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> :
XAML
Name="backButton" Width="75"><</Button>
Name="nextButton" Width="75">></Button>
<Button HorizontalAlignment="Right" Margin="0,21,46,24"
Name="saveButton" Width="110">Save changes</Button>
Criar os controles associados a dados

Crie controles que exibem registros do cliente ao arrastar o SalesOrderHeaders nó
SalesOrderHeaders 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, pressupõe-se 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 mais informações sobre o XAML e o
código gerados, consulte Associar controles WPF a dados no 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 proxy de serviço para carregar dados de vendas do serviço. Em seguida,
atribua os dados retornados à fonte de dados para a CollectionViewSource janela do
WPF.
1. No designer, para criar o Window_Loaded manipulador de eventos, clique duas

vezes no texto 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.
C#
C#
private AdventureWorksService.AdventureWorksLTEntities
dataServiceClient;
private
System.Data.Services.Client.DataServiceQuery<AdventureWorksService.
SalesOrderHeader> salesQuery;
private CollectionViewSource ordersViewSource;

{
// 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();
}
Navegar pelos registros de vendas
Adicione o código que permite aos usuários rolem nos registros de vendas, usando os
botões < e >.
1. No designer, clique duas vezes no botão < na superfície da janela.

eventos backButton_Click para o evento Click.
2. Adicione o seguinte código ao manipulador de eventos backButton_Click gerado:
C#
C#
if (ordersViewSource.View.CurrentPosition > 0)
ordersViewSource.View.MoveCurrentToPrevious();
3. Retorne ao designer e clique duas vezes no botão >.

eventos nextButton_Click para o evento Click.
4. Adicione o seguinte código ao manipulador de eventos nextButton_Click gerado:
C#
C#
if (ordersViewSource.View.CurrentPosition <
((CollectionView)ordersViewSource.View).Count - 1)
{
ordersViewSource.View.MoveCurrentToNext();
}
Salvar alterações nos 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.

eventos saveButton_Click para o evento Click.
2. Adicione o seguinte código ao manipulador de eventos do saveButton_Click .
C#
C#
AdventureWorksService.SalesOrderHeader currentOrder =
(AdventureWorksService.SalesOrderHeader)ordersViewSource.View.Curre
ntItem;
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 Compilar, clique em Compilar Solução. Verifique se a solução é

compilada sem erros.
2. Pressione Ctrl++F5.
O Visual Studio inicia o projeto AdventureWorksService 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 em 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
Associar controles WPF a um conjunto dedados.
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 aplicativoWPF.
Confira também
Associar controles do WPF a um conjunto de dados
Visão geral do WCF (.NET Framework)
Visão geral do Entity Framework (.NET Framework)
Visão geral da Associação de Dados (.NET Framework)
Criar tabelas de pesquisa em aplicativos
WPF do .NET Framework
Artigo • 12/04/2024
７ Observação

mais simples.
O termo tabela de pesquisa (também conhecido como 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 pai ou de um objeto da janela Fontes de Dados
para um controle que já esteja associado a uma coluna ou propriedade em uma tabela
filho relacionada.
Por exemplo, considere uma tabela de Orders em um banco de dados de vendas. Cada
registro na tabela Orders inclui um CustomerID que indica qual cliente fez o pedido. A
CustomerID é uma chave é estrangeira que aponta para um registro de cliente na tabela
Customers . Ao exibir uma lista de pedidos da tabela Orders , talvez seja mais
interessante exibir o nome real do cliente em vez do CustomerID . Como o nome do

cliente está na tabela Customers , você precisa criar uma tabela de pesquisa para exibi-lo.
A tabela de pesquisa usa o valor CustomerID no registro Orders para navegar na relação
e retornar o nome do cliente.
Criar uma tabela de pesquisa

1. Adicione um dos seguintes tipos de fontes de dados com os dados relacionados
ao seu projeto:
Conjunto de dados ou Modelo de Dados de Entidade.
Serviço de Dados do WCF, serviço WCF ou serviço Web. Para obter mais
informações, veja Como conectar-se a dados em um serviço.
Objetos. Para obter mais informações, confira Associar a objetos no Visual

Studio.
７ Observação
Para 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 verifique se o designer contém um contêiner que é

uma reprodução automática válida para itens da janela Fontes de Dados.
Para obter mais informações sobre reproduções automáticas válidas, consulte

Associar controles WPF a dados no 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ê consiga ver a tabela pai
ou o objeto e a tabela ou o objeto filho relacionado.
７ Observação
A tabela ou o objeto filho relacionado é o nó que aparece como um nó filho

expansível sob a tabela pai ou o objeto.
5. Clique no menu da lista suspensa do nó filho e selecione Detalhes.
6. Expanda o nó filho.
7. No nó filho, clique no menu da lista suspensa do item que relaciona os dados filho
e pai. (No exemplo anterior, este é o nó CustomerID). Selecione um dos seguintes
tipos de controles que dão suporte à associação de pesquisa:
ComboBox
ListBox
ListView
７ Observação
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.
７ Observação
Para obter informações sobre como adicionar controles personalizados à

lista de controles que você pode selecionar para itens na janela Fontes
de Dados, veja 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ó Pedidos).
O Visual Studio gera o XAML que cria novos controles associados a dados para
cada um dos itens que você arrasta. O XAML também adiciona um novo
CollectionViewSource para a tabela filho ou o objeto aos recursos da reprodução
automática. Em algumas fontes de dados, o Visual Studio também gera código
para carregar dados na tabela ou no objeto. Para obter mais informações, confira
9. Arraste o nó pai da janela Fontes de Dados até o controle da associação de

pesquisa criado anteriormente. (No exemplo anterior, o nó pai é o nó Clientes).
O Visual Studio define algumas propriedades no controle para configurar a

associação de pesquisa. A tabela a seguir lista as propriedades que o Visual Studio
modifica. Se necessário, você pode alterar essas propriedades no XAML ou na
janela Propriedades.
Propriedade Explicação da configuração
ItemsSource Essa propriedade especifica a coleção ou associação usada para

obter os dados exibidos no controle. O Visual Studio define essa
propriedade como o CollectionViewSource para os dados pai que
você arrastou até o controle.
DisplayMemberPath Essa propriedade especifica o caminho do item de dados exibido no

controle. O 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.
SelectedValue O Visual Studio associa essa propriedade à coluna ou propriedade

dos dados filho que você arrastou até o designer. Essa é a chave
estrangeira para os dados pai.
SelectedValuePath O Visual Studio define essa propriedade como o caminho da coluna

ou propriedade dos dados filho que é a chave estrangeira para os
dados pai.
Exibir dados relacionados em aplicativos WPF
Passo a passo: exibindo dados relacionados em um aplicativo WPF
Comentários
Exibir dados relacionados em aplicativos
WPF
Artigo • 04/05/2023
７ Observação

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 clientes de uma tabela Customers . Quando o
usuário seleciona um cliente específico, outra grade exibe os pedidos desse cliente de
uma tabela Orders relacionada.
Você pode criar controles associados 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 verifique se o designer contém um contêiner que é uma

reprodução automática válida para itens da janela Fontes de Dados.
Para obter mais informações sobre reproduções automáticas válidas, consulte
4. Na janela Fontes de Dados, expanda o nó que representa a tabela pai ou o objeto

na relação. A tabela ou 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 soltar válido no designer.
cada item que você arrasta. O XAML também adiciona um novo
CollectionViewSource para a tabela pai ou o objeto aos recursos da reprodução
automática. Em algumas fontes de dados, o Visual Studio também gera código
para carregar dados na tabela pai ou no objeto. Para obter mais informações,
confira Associar controles WPF a dados no Visual Studio.
6. Na janela Fontes de Dados, localize a tabela ou objeto filho relacionado. Tabelas e

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 quaisquer itens individuais no nó filho) da janela Fontes de

Dados para um destino de soltar válido no designer.
cada um dos itens que você arrasta. O XAML também adiciona um novo
CollectionViewSource para a tabela filho ou o objeto aos recursos da reprodução
automática. Esse novo CollectionViewSource é associado à propriedade da tabela
pai ou objeto que você acabou de arrastar para o designer. Em algumas fontes de
dados, o Visual Studio também gera código para carregar dados na tabela filho ou
no objeto.
A figura a seguir demonstra a tabela Pedidos relacionada da tabela Customers em

um conjunto de dados na janela Fontes de Dados.
Confira também
Criar tabelas de pesquisa em aplicativos do WPF
Associar controles a imagens de um
banco de dados em aplicativos .NET
Framework
Artigo • 12/01/2024
７ Observação

mais simples.
Use a janela Fontes de Dados para associar uma imagem em um banco de dados a um
controle em seu aplicativo. Por exemplo, você pode associar uma imagem a um controle
Image em um aplicativo WPF ou a um controle PictureBox em um aplicativo do
Windows Forms.
Normalmente, as imagens em um banco de dados são armazenadas como matrizes de

bytes. Os itens na janela Fontes de Dados 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, desde uma simples matriz de bytes até o arquivo
executável de um aplicativo grande. Para criar um controle associado a 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 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 no Designer de Formulários do Windows.
2. Na janela Fontes de Dados, expanda a tabela ou objeto desejado para exibir suas
colunas ou propriedades.
 Dica
Se a janela Fontes de Dados não estiver aberta, abra-a selecionando

Exibir>Outras Janelas>Fontes de Dados.
3. Selecione a coluna ou a propriedade que contém os dados da imagem e selecione

um dos seguintes controles na lista de controles suspensos:
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

à associação de dados e que possa exibir imagens. Se o controle que você
deseja usar não estiver na lista de controles disponíveis, você poderá
adicioná-lo à lista e selecioná-lo. Para obter mais informações, confira
Adicionar controles personalizados à janela Fontes de Dados.
Vincular controles do Windows Forms a
Framework
Artigo • 12/01/2024
７ Observação

mais simples.
É possível exibir dados para usuários do aplicativo com a associação de dados ao

Windows Forms. Para criar esses controles associados a dados, arraste itens da janela
Fontes de Dados para o Designer de Formulários do Windows no Visual Studio.
 Dica
Se a janela Fontes de Dados não estiver visível, você pode abri-la escolhendo
Exibir>Outras Janelas>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 os itens, você pode definir o tipo de controle ao qual deseja associá-
los. Valores diferentes serão exibidos caso você escolha a própria tabela ou uma coluna
individual. Você também pode definir valores personalizados. Em uma tabela, Detalhes
significa que cada coluna está associada a um controle separado.
Controles BindingSource e BindingNavigator

O componente BindingSource serve a duas finalidades. Em primeiro lugar, ele fornece
uma camada de abstração ao associar os controles a dados. Os controles no formulário
são associados ao componente BindingSource 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 componente BindingSource, confira:
Componente BindingSource
Visão geral do componente BindingSource
Arquitetura do componente BindingSource
O controle BindingNavigator fornece uma interface do usuário para navegar por dados
exibidos por um aplicativo do Windows.
Associar a dados em um controle DataGridView

Para um controle DataGridView, tabela inteira está associada a esse controle único. ao
arrastar um DataGridView para o formulário, também é exibida uma faixa de
ferramentas para navegar nos registros (BindingNavigator). Um DataSet, TableAdapter,
BindingSource e BindingNavigator são exibidos na bandeja de componentes. 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 de eventos Form_Load . O código para salvar os dados para atualizar o
banco de dados está localizado no Save manipulador 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 inteligente no canto superior direito de cada um deles:
Se os controles de que seu aplicativo precisa não estiverem disponíveis na janela Fontes
de Dados, você poderá adicioná-los. Para obter mais informações, confira Adicionar
controles personalizados à janela Fontes de Dados.
Você também pode arrastar itens da janela Fontes de Dados aos controles que já estão
em um formulário para associar o controle aos dados. Um controle que já está
associado aos dados tem suas associações de dados redefinidas para o item mais
recente que foi arrastado 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 a
partir da janela Fontes de Dados. Por exemplo, não é válido arrastar um item que tenha
um tipo de dados de DateTime para um CheckBox, porque CheckBox não é capaz de
exibir uma data.
Associar a dados em controles individuais

Quando você associa uma fonte de dados a Detalhes, cada coluna no conjunto de
dados é associada a um controle separado.
） Importante
Observe que, na ilustração anterior, você arrasta da propriedade Orders da tabela

Customers, e não da tabela Orders. Ao associar à propriedade Customer.Orders , os
comandos de navegação feitos no DataGridView são refletidos imediatamente nos
controles de detalhes. Se você arrastasse a partir da tabela Orders, os controles
ainda estariam associados ao conjunto de dados, mas não seriam sincronizados
com o DataGridView.
A ilustração a seguir mostra os controles padrão associados a dados que são

adicionados ao formulário depois que a propriedade Orders na tabela Customers é
associada 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.
Associando controles a dados no Visual Studio
Associação de dados no Windows Forms (.NET Framework)
Filtrar e classificar dados em um
aplicativo do Windows Forms do .NET
Framework
Artigo • 05/11/2024
７ Observação

mais simples.
Filtre dados definindo a propriedade Filter como uma expressão de cadeia de caracteres
que retorna os registros desejados.
Classifique dados definindo a propriedade Sort como o nome da coluna na qual deseja
classificar; acrescente DESC para classificar em ordem decrescente ou ASC para
classificar em ordem crescente.
７ Observação
Se o aplicativo não usar componentes BindingSource, você poderá filtrar e

classificar dados usando objetos DataView. Para obter mais informações, consulte
DataViews.
Para filtrar dados usando um componente

BindingSource
Defina a propriedade Filter como a expressão que deseja retornar. Por exemplo, o
código a seguir retorna clientes com um CompanyName que começa com "B":
C#
customersBindingSource.Filter = "CompanyName like 'B'";
Para classificar dados usando um componente

BindingSource
Defina a propriedade Sort como a coluna na qual deseja classificar. Por exemplo, o
seguinte código classifica os clientes na coluna CompanyName em ordem
decrescente:
C#
customersBindingSource.Sort = "CompanyName Desc";
Comentários

Confirmar edições no processo em
controles associados a dados antes de
salvar os dados
Artigo • 06/12/2023
７ Observação

mais simples.
Ao editar valores em controles associados a dados, os usuários precisam 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ê solta gera código no evento de
clique do botão Salvar do BindingNavigator. Esse código chama o método EndEdit do
BindingSource. Portanto, a chamada para o método EndEdit é 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 automaticamente as alterações,

mesmo que um usuário tente salvar dados sem confirmar as alterações, como parte do
processo de salvamento.
７ Observação
O designer só adiciona o código BindingSource.EndEdit para o primeiro item

arrastado para um formulário. Portanto, é necessário adicionar uma linha de código
para chamar o método EndEdit para cada BindingSource no formulário. Você pode
adicionar manualmente uma linha de código para chamar o método EndEdit para
cada BindingSource. Como alternativa, você pode adicionar o método
EndEditOnAllBindingSources 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 componentes BindingSource e chamar o método EndEdit 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 componentes
BindingSource.
C#
C#
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();
}
}
2. Adicione a seguinte linha de código imediatamente antes de qualquer chamada

para salvar os dados do formulário (o método TableAdapterManager.UpdateAll() ):
C#
C#
EndEditOnAllBindingSources();
Criar tabelas de pesquisa em aplicativos
do Windows Forms
Artigo • 04/05/2023
７ Observação

O termo tabela de pesquisa 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 em seu formulário que já está associado à
coluna na tabela filho relacionada.
Por exemplo, considere uma tabela de Orders em um banco de dados de vendas. Cada
registro na tabela Orders inclui um CustomerID que indica qual cliente fez o pedido. A
CustomerID é uma chave é estrangeira que aponta para um registro de cliente na tabela
Customers . Nesse cenário, você expande a tabela Orders na janela Fontes de Dados e
define o nó principal como Detalhes. Em seguida, define a coluna CustomerID para usar
um ComboBox (ou qualquer outro controle que dê suporte à associação de pesquisa) e
arrasta o nó Orders para o formulário. Por fim, você arrasta o nó Customers para o
controle associado à coluna relacionada; nesse caso, o ComboBox associado à coluna
CustomerID .
Para associar um controle de pesquisa

1. Com o projeto aberto, abra a janela Fontes de Dados escolhendo Exibir>Outras
Janela>Fontes de Dados.
７ Observação
As tabelas de pesquisa exigem que duas tabelas ou objetos relacionados

estejam disponíveis na janela Fontes de Dados. Para obter mais informações,
confira Relações em conjunto de dados abaixo.
2. Expanda os nós na janela Fontes de Dados até que você possa ver a tabela pai e
todas as suas colunas, a tabela filho relacionada e todas as suas colunas.
７ Observação
O nó da tabela filho é o nó que aparece como um nó filho expansível na

tabela pai.
3. Altere o tipo de remoção da tabela relacionada a Detalhes escolhendo Detalhes

na lista no nó da tabela filho. Para obter mais informações, confira Definir o
controle a ser criado ao arrastar da janela Fontes de Dados.
4. Localize o nó que relaciona as duas tabelas (o nó CustomerID no exemplo anterior).

Altere seu tipo de lista suspensa para um ComboBox selecionando ComboBox na
lista de controles.
5. Arraste o nó principal da tabela filho da janela Fontes de Dados para o formulário.
Controles de entrada de dados (com rótulos descritivos) e uma faixa de

ferramentas (BindingNavigator) aparecem no formulário. Um DataSet,
TableAdapter, BindingSource e BindingNavigator são exibidos na bandeja de
componentes.
6. Agora, arraste o nó principal da tabela pai da janela Fontes de Dados diretamente

para o controle de pesquisa (o ComboBox).
As associações de pesquisa agora estão estabelecidas. Confira a tabela a seguir

para obter as propriedades específicas que foram definidas no controle.

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 for necessário fazer um ajuste, defina isso como o 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 for necessário fazer um ajuste, defina isso 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 for necessário fazer um ajuste, defina isso como a chave primária da

tabela com a coluna que você deseja exibir.
SelectedValue O Visual Studio define essa propriedade como a coluna original que foi
solta da janela Fontes de Dados.
Se for necessário fazer um ajuste, defina isso como a coluna de chave

estrangeira na tabela relacionada.
Confira também
Criar um formulário do Windows Forms
do .NET Framework para pesquisar
dados com o ADO.NET
Artigo • 24/07/2024
７ Observação

mais simples.
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 os valores dos parâmetros e executar a consulta), usando a caixa de diálogo
Criador 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:
Criar e configurar a fonte de dados em seu aplicativo com o assistente

Configuração da Fonte de Dados.
Definir o tipo de soltura 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.
Preencher a caixa de diálogo Criador de Critérios de Pesquisa.
Inserir parâmetros no formulário e executar a consulta parametrizada.
７ Observação
Os procedimentos neste artigo se aplicam somente a projetos do Windows Forms

do .NET Framework, não a projetos do Windows Forms do .NET Core.
Pré-requisitos
Você precisa ter a carga de trabalho Armazenamento e processamento de dados
instalada. Confira Modificar o Visual Studio.
da Northwind.


alguns dados.

Executar.

Criar o aplicativo do Windows Forms

Crie um projeto de Aplicativo do Windows Forms (.NET Framework) para C# ou Visual
Basic. Nomeie o projeto WindowsSearchForm.

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.
o assistente de Configuração de Fonte de Dados.

selecione Avançar.
4. Na tela Escolher um Modelo de Banco de Dados, escolha Conjunto de Dados e

selecione Avançar.
5. Na página Escolha a Conexão de Dados, faça o seguinte:

estiver disponível na lista suspensa, selecione-a.

6. Na página Salvar cadeia de conexão no arquivo de configuração do aplicativo,
clique em Avançar.
8. Selecione a tabela Clientes e, depois, Concluir.
O NorthwindDataSet é adicionado ao seu projeto e a tabela Clientes aparece na

Criar o formulário
Dados para um formulário:
1. Verifique se o designer do Windows Forms tem 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 de consulta na caixa de diálogo Criador de

Critérios de Pesquisa.
3. Adicione WHERE City = @City à consulta na área Texto da Consulta.
A consulta deve ser semelhante ao seguinte:
SQL
SELECT CustomerID, CompanyName, ContactName, ContactTitle,
Address, City, Region, PostalCode, Country, Phone, Fax
FROM Customers
WHERE City = @City
７ Observação
Fontes de dados do Access e OLE DB usam o ponto de interrogação (“?”) para

denotar parâmetros, portanto, a cláusula WHERE seria algo como: 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 deixa-o pronto para receber o parâmetro
como entrada:
1. Pressione F5 para executar o aplicativo.
2. Digite Londres na caixa de texto Cidade e selecione 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,
confira Relações em conjunto de dados abaixo.
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).
Comentários
Criar um controle de usuário do
Windows Forms do .NET Framework
que dê suporte à associação de dados
simples
Artigo • 24/07/2024
７ Observação

mais simples.
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 controles, consulte Desenvolvendo

controles do Windows Forms em tempo de design.
Ao criar controles para uso em cenários de associação de dados, implemente um dos

seguintes atributos de associação de dados:
Uso de atributo de associação de dados
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
Uso de atributo de associação de dados
passo a passo.)
Implemente o ComplexBindingPropertiesAttribute nos controles, como um DataGridView que

exibe listas (ou tabelas) de dados. Para obter mais informações, confira Criar um controle de
usuário do 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, confira Criar um controle de usuário do 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 números de telefone de
clientes em um formato de número de telefone padrão usando um MaskedTextBox e
configurando a máscara para um número de telefone.
Durante este passo a passo, você aprenderá a:
Crie um novo Aplicativo do Windows Forms (.NET Framework).
Adicionar um novo Controle de Usuário ao projeto.
Projetar visualmente o controle do usuário.
Implementar o atributo DefaultBindingProperty .
Criar um conjunto de dados com o assistente de Configuração de 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
da Northwind.


alguns dados.

Executar.


A primeira etapa é criar um Aplicativo do Windows Forms (.NET Framework):

4. Dê ao projeto o nome 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 associável a dados com base em um
Controle de Usuário. Adicione um item 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.
Projetar o controle PhoneNumberBox

Este passo a passo expande o MaskedTextBox existente 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 obrigatório de associação

de dados
Para controles simples que dão suporte à associação de dados, implemente o
DefaultBindingPropertyAttribute:
1. Mude o controle PhoneNumberBox à exibição de código. (No menu Exibir,

escolha Código.)
2. Substitua o código em PhoneNumberBox pelo seguinte:
C#
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()
{
}
}
}
3. No menu Compilação, escolha Compilar Solução.
Criar uma fonte de dados com base em seu

banco de dados
de dados com base na tabela Customers 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 da Northwind,
consulte Como instalar bancos de dados de exemplo.
Dados.

selecione Avançar.
Se uma conexão de dados com o banco de dados de amostra Northwind


6. Na página Salvar cadeia de conexão no arquivo de Configuração de Aplicativo,
clique em Avançar.
8. Escolha a tabela Customers e selecione Concluir.
O NorthwindDataSet é adicionado ao projeto e a tabela Customers aparece na

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 seu formulário:
1. Abra Form1 no designer.
3. Clique na seta da lista suspensa no nó Clientes e escolha Detalhes na lista de

controle.
4. Clique na seta da lista 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 da lista suspensa na coluna Telefone e escolha PhoneNumberBox.

É possível criar controles de associação de dados ao arrastar itens da janela Fontes de
Dados para o formulário.
Para criar controles associados 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.
Próximas etapas
Dependendo dos requisitos do aplicativo, existem várias etapas que você pode realizar
após criar um controle que dê suporte à 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 com suporte para associação de dados complexa e Criar um controle de
usuário do Windows Forms com suporte para associação de dados de pesquisa.
Definir o controle a ser criado quando arrastado da janela Fontes de Dados
Comentários
Windows Forms do .NET Framework
que dá suporte à associação de dados
complexos com o ADO.NET
Artigo • 22/12/2023
７ Observação

mais simples.
Ao exibir dados em formulários em aplicativos do Windows, você poderá escolher

controles existentes na Caixa de Ferramentas. Ou poderá criar controles personalizados
se o aplicativo exigir funcionalidade que não esteja disponível 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 controles, confira Desenvolver controles
do Windows Forms no 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 do atributo de associação de dados

exibe uma única coluna (ou propriedade) de dados. Para obter mais informações, confira Criar um
controle de usuário do Windows Forms que dá suporte à associação de dados simples.

exibe listas (ou tabelas) de dados. (Esse processo é descrito nesta página de passo a passo.)

Para obter mais informações, confira Criar um controle de usuário do Windows Forms que dá
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.
Implementar o atributo ComplexBindingProperty .
Criar um conjunto de dados com o assistente de Configuração da Fonte de Dados.
Defina 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
da Northwind.


alguns dados.

Executar.

Crie um projeto de aplicativo do Windows

Forms
A primeira etapa é criar um projeto Aplicativo do Windows Forms em C# ou Visual
Basic. Nomeie o projeto como ComplexControlWalkthrough.

Como este passo a passo cria um controle associável a dados de um Controle de
Usuário, adicione um item 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.
Projetar o controle ComplexDataGridView
Para adicionar um DataGridView ao controle de usuário, arraste um DataGridView da
Caixa de Ferramentas para a superfície de design do controle de usuário.

de dados
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:
C#
C#
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()
{
}
}
}
Criar uma fonte de dados a partir do seu banco

de dados
Use o Assistente de Configuração de Fonte de Dados para criar uma fonte de dados
com base na tabela Customers no banco de dados de exemplo Northwind:
Dados.
3. Selecione Banco de Dados na página Escolher um Tipo de Fonte de Dados e, em

seguida, clique em Avançar.


confidenciais e, em seguida, clique em Avançar.

clique em Avançar.
8. Selecione a tabela Customers e clique em Concluir.
O NorthwindDataSet é adicionado ao projeto e a tabela Customers aparece na

Definir a tabela Clientes para usar o controle

ComplexDataGridView
itens para seu formulário:
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.

Dados para um 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.
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 pesquisa. Para obter mais

informações, confira Criar um controle de usuário do Windows Forms que dá
Confira também
Definir o controle a ser criado quando arrastado da janela Fontes de Dados
Controles dos Windows Forms
Windows Forms compatível com
associação de dados de consulta
Artigo • 04/05/2023
７ Observação

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 controles, consulte Desenvolver

controles do Windows Forms no 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:

exibe uma única coluna (ou propriedade) de dados. Para obter mais informações, confira Criar um
controle de usuário do Windows Forms que dá suporte à associação de dados simples.

exibe listas (ou tabelas) de dados. Para obter mais informações, confira Criar um controle de
usuário do Windows Forms que dá suporte à associação de dados complexa.

(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 pesquisa é associado ao campo CustomerID da
tabela Orders . Ele usa este valor para pesquisar CompanyName na tabela Customers .
Criar um novo Aplicativo do Windows Forms.
Implementar o atributo LookupBindingProperty .
Criar um conjunto 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
da Northwind.


alguns dados.

Executar.

Criar um projeto de aplicativo do Windows

Forms
A primeira etapa é criar um projeto de Aplicativo do Windows Forms.

4. Nomeie o projeto LookupControlWalkthrough e escolha OK.
O projeto LookupControlWalkthrough é criado e adicionado ao Gerenciador de

Soluções.

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.
Projetar o controle LookupBox

Para projetar o controle LookupBox, arraste um ComboBox da Caixa de Ferramentas
para a superfície de design do controle de usuário.

de dados
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:
C#
C#
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()
{
}
}
}
Criar uma fonte de dados a partir do seu 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.
3. Selecione Banco de Dados na página Escolher um Tipo de Fonte de Dados e, em

seguida, clique em Avançar.


confidenciais e, em seguida, clique em Avançar.
clique em Avançar.
8. Selecione as tabelas Customers e Orders e, em seguida, clique em Concluir.

Definir a coluna CustomerID da tabela Pedidos

para usar o controle LookupBox
itens para seu formulário.
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.

É possível criar controles de associação de dados ao arrastar itens da janela Fontes de
Dados para Form1.
Para criar controles de associação de dados no Windows Form, arraste o nó Pedidos da

janela Fonte de Dados para o Windows Form e verifique se o controle LookupBox é
usado para exibir dados na coluna CustomerID .
Associar o controle para pesquisar
CompanyName na tabela Clientes
Para configurar as associações de pesquisa, selecione o nó principal Clientes na janela
Fonte de Dados e arraste-o para a caixa de combinação em 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 .
Navegue por alguns registros e verifique se CompanyName aparece no controle

LookupBox .
Confira também
Passar dados entre formulários
Artigo • 30/07/2024
７ Observação

mais simples.
Este tutorial 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 tutorial mostra como criar um método no segundo
formulário que recebe dados do primeiro.
７ Observação
Este tutorial demonstra apenas uma maneira de passar dados entre formulários.
Existem outras opções para passar dados para um formulário, incluindo criar um
segundo construtor para receber dados ou criar uma propriedade pública que
pode ser definida com os dados do primeiro formulário.
As tarefas ilustradas neste tutorial incluem:
Criar um novo projeto Windows Forms App (.NET Framework).
Criar e configurar um conjunto de dados com o Assistente de Configuração da

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 quando arrastado 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 tutorial usa o SQL Server Express LocalDB e o banco de dados de exemplo da
Northwind.
parte da carga de trabalho Armazenamento e processamento de dados ou como


alguns dados.

Executar.
Criar o projeto de aplicativo do Windows

Forms

4. Dê ao projeto o nome PassingDataBetweenForms e escolha OK.
O projeto PassingDataBetweenForms é criado e adicionado ao Gerenciador de

Soluções.

Dados.

selecione Avançar.
4. Na página Escolha um Modelo de Banco de Dados, verifique se o Conjunto de

dados foi especificado e selecione Avançar.
Se uma conexão de dados com o banco de dados de amostra Northwind


6. Se o banco de dados exigir uma senha e a opção para incluir dados confidenciais
estiver habilitada, selecione a opção e selecione Avançar.
clique em Avançar.
9. Selecione as tabelas Clientes e Pedidos e, em seguida, selecione Finalizar.

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.

em registros são exibidos no Form1. Um NorthwindDataSet,
Criar o segundo formulário

Crie um segundo formulário para o qual passar os 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.

em registros são exibidos no Form2. Um NorthwindDataSet,
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 do cliente
selecionado no Form1.
1. Clique duas vezes no arquivo NorthwindDataSet.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 selecione Avançar.
4. Deixe a opção padrão SELECT que retorna linhas e selecione Avançar.
5. Adicione uma cláusula WHERE à consulta para retornar Orders com base no
CustomerID . A consulta deve ser semelhante ao seguinte:
SQL
SELECT OrderID, CustomerID, EmployeeID, OrderDate, RequiredDate,

ShippedDate, ShipVia, Freight, ShipName, ShipAddress, ShipCity,
ShipRegion, ShipPostalCode, ShipCountry
FROM Orders
WHERE CustomerID = @CustomerID
７ Observação
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 Avançar.
7. Para Preencher com nome de DataTableMethod, digite FillByCustomerID .
8. Desmarque a opção Retornar uma DataTable e selecione Avançar.
Criar um método no Form2 para o qual passar

dados
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 :
C#
C#
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
selecione 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:
C#
C#
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();
}
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 nesse tutorial 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 no banco de dados.
Comentários
Associar objetos como fontes de dados
no Visual Studio
Artigo • 04/05/2023
７ Observação

O 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ê associa a controles de
interface do usuário, a abordagem recomendada é usar o Entity Framework para gerar a
classe ou classes. O 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
mantidas automaticamente no banco de dados quando você chama AcceptChanges no
objeto DbSet. Para obter mais informações, confira Documentação do Entity
Framework .
 Dica
As abordagens de associação de objeto neste artigo só devem ser consideradas se

o aplicativo já for 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ê for processar forem tabulares e não muito complexos nem muito
grandes. Para obter 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 vinculação de dados, confira 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.
Geralmente, 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 associado a dados e, se o objeto implementar a interface
ITypedList ou IListSource, o objeto precisará ter um construtor padrão. Caso contrário, o
Visual Studio não poderá instanciar o objeto de fonte de dados e ele exibirá um erro
quando você arrastar o item para a superfície de design.
Exemplos de uso de objetos personalizados

como fontes de dados
Embora existam inúmeras maneiras de implementar a lógica do aplicativo ao trabalhar
com objetos como uma fonte de dados, para bancos de dados 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. Ela não se destina a ser 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:
Carregar dados em objetos (normalmente de um banco de dados).
Criar uma coleção tipada de objetos.
Adicionar objetos a uma coleção e remover objetos dela.
Exibir os dados do objeto para os usuários em um formulário.
Alterar/editar os dados em um objeto.
Salvar dados de objetos de volta para o 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 preenchem tabelas de dados.
O método TableAdapter.Fill preenche uma tabela de dados existente com os

dados retornados.
O método TableAdapter.GetData retorna uma nova tabela de dados preenchida

com os dados.
A maneira mais fácil de carregar seus objetos personalizados com os dados é chamar o
método TableAdapter.GetData , percorrer a coleção de linhas na tabela de dados
retornada e preencher cada objeto com os valores em cada linha. Você pode criar um
método GetData que retorna uma tabela de dados populada para qualquer consulta
adicionada a um TableAdapter.
７ Observação
O Visual Studio nomeia as consultas de TableAdapter Fill e GetData por padrão,

mas você pode alterar esses nomes para qualquer nome de método válido.
O seguinte exemplo mostra como percorrer as linhas em uma tabela de dados e

preencher um objeto com os dados:
C#
C#
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);
}
}
Criar uma coleção tipada de objetos

Você pode criar classes de coleção para seus objetos ou usar as coleções tipadas
fornecidas automaticamente pelo componente BindingSource.
Ao criar 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 gerar eventos que enviam notificações para a
infraestrutura de associação de dados no Windows Forms.
A coleção gerada automaticamente em BindingSource usa um BindingList<T> para a
respectiva coleção tipada. Se o aplicativo não exigir funcionalidade adicional, você
poderá manter sua coleção dentro do BindingSource. Para obter mais informações,
confira a propriedade List da classe BindingSource.
７ Observação
Se sua coleção exigir funcionalidade não fornecida pela implementação base do

BindingList<T>, você deverá criar uma coleção personalizada para que possa
adicionar à classe conforme necessário.
O seguinte código mostra como criar a classe para uma coleção fortemente tipada de
objetos Order :
C#
C#
/// <summary>
/// A collection of Orders
/// </summary>
public class Orders: System.ComponentModel.BindingList<Order>
{
// Add any additional functionality required by your collection.
}
Adicionar objetos a uma coleção

Você adiciona objetos a uma coleção chamando o método Add da classe de coleção
personalizada ou do BindingSource.
７ Observação
O método Add é fornecido automaticamente para sua coleção personalizada

quando você herda de BindingList<T>.
O seguinte código mostra como adicionar objetos à coleção tipada em um

BindingSource:
C#
C#
Customer currentCustomer = new Customer();

customerBindingSource.Add(currentCustomer);
O seguinte código mostra como adicionar objetos a uma coleção tipada que herda de
BindingList<T>:
７ Observação
Neste exemplo, a coleção Orders é uma propriedade de um objeto Customer .
C#
C#
Order currentOrder = new Order();

currentCustomer.Orders.Add(currentOrder);
Remover objetos de uma coleção

Você remove objetos de uma coleção chamando o método Remove ou RemoveAt de sua
classe de coleção personalizada ou de BindingSource.
７ Observação
Os métodos Remove e RemoveAt são fornecidos automaticamente para sua coleção

personalizada quando você herda de BindingList<T>.
O seguinte código mostra como localizar e remover objetos da coleção tipada em um

BindingSource com o método RemoveAt:
C#
C#
int customerIndex = customerBindingSource.Find("CustomerID", "ALFKI");

customerBindingSource.RemoveAt(customerIndex);
Exibir dados de objeto para usuários
Para exibir os dados em objetos para os 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 as
propriedades individuais para o formulário da janela Fontes de Dados.
Modificar os dados em objetos

Para editar dados em objetos personalizados associados a controles do Windows Forms,
basta editar os dados no controle associado (ou diretamente nas propriedades do
objeto). A arquitetura de associação de dados atualiza os dados no objeto.
Se o aplicativo exigir o acompanhamento das alterações e a reversão das alterações

propostas em seus valores originais, você precisará implementar essa funcionalidade em
seu modelo de objeto. Para obter exemplos de como as tabelas de dados acompanham
as alterações propostas, confira DataRowState, HasChanges e GetChanges.
Salvar dados em objetos de volta para o banco de dados

Salve os dados de volta no banco de dados passando os valores do objeto para os
métodos DBDirect do TableAdapter.
O 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étodos DBDirect Descrição

TableAdapter
TableAdapter.Insert Adiciona novos registros a um banco de dados, permitindo que você

passe valores de coluna individuais como parâmetros de método.
TableAdapter.Update Atualiza registros existentes em um banco de dados. O método Update

usa 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 TableAdapter.Update também é usado para reconciliar

alterações em um conjunto de dados de volta ao banco de dados, usando
uma matriz DataSet, DataTable, DataRow de DataRows como 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, faça 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 seguinte exemplo mostra como usar o método DBDirect TableAdapter.Insert para

adicionar um novo cliente diretamente ao banco de dados:
C#
C#
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);
}
Confira também
Personalizar como o Visual Studio cria
legendas para controles associados
a dados em aplicativos do .NET
Framework
Artigo • 12/01/2024
７ Observação

mais simples.
Ao arrastar itens da janela Fontes de Dados para um designer, uma consideração

especial entra em jogo: os nomes de coluna nos rótulos de legenda são reformatados
em uma cadeia de caracteres mais legível quando duas ou mais palavras são
concatenadas.
Você pode personalizar a forma como esses rótulos são criados definindo os valores
SmartCaptionExpression, SmartCaptionReplacement e SmartCaptionSuffix na chave
do Registro HKEY_CURRENT_USER\Software\Microsoft\VisualStudio\16.0\Data
Designers.
７ Observação
Essa chave do Registro não existe até que você a crie.
A legenda inteligente é controlada pela expressão regular inserida no valor

SmartCaptionExpression. Adicionar a chave do Registro de Designers de Dados
substitui a expressão regular padrão que controla rótulos de legenda. Para obter mais
informações sobre expressões regulares, confira Usar expressões regulares no Visual
Studio.
A tabela a seguir descreve os valores de registro que controlam rótulos de legenda.
Item de registro Descrição
SmartCaptionExpression A expressão regular que você usa para corresponder aos seus
padrões.
SmartCaptionReplacement O formato para exibir todos os grupos correspondentes no

SmartCaptionExpression.
SmartCaptionSuffix Uma cadeia de caracteres opcional a ser acrescentada ao final da

legenda.
A tabela a seguir lista as configurações padrão internas para esses valores de registro.
Item de registro Valor Explicação

padrão
SmartCaptionExpression (\\p{Ll}) Corresponde a um caractere minúsculo seguido por

(\\p{Lu})|_+ um caractere maiúsculo ou um sublinhado.
SmartCaptionReplacement USD 1, USD O $1 representa todos os caracteres

2 correspondentes nos primeiros parênteses da
expressão, e $2 representa todos os caracteres
correspondentes nos segundos parênteses. A
substituição é a primeira correspondência, um
espaço e, em seguida, a segunda correspondência.
SmartCaptionSuffix : Representa um caractere acrescentado à cadeia de

caracteres retornada. Por exemplo, se a legenda for
Company Name , o sufixo o tornará Company Name: .
Ｕ Cuidado
Tenha muito cuidado ao fazer qualquer coisa no Editor de registro. Faça backup do
registro antes de editá-lo. Se o Editor de registro for usado incorretamente, você
poderá causar sérios problemas que podem obrigar a reinstalação do sistema
operacional. A Microsoft não garante que seja possível resolver os problemas
causados pelo uso incorreto do Editor de registro. Use o Editor de Registro por sua
conta e risco.
Para obter informações sobre backup, edição e restauração do registro, confira
Informações de registro do Windows para usuários avançados .
Modificar o comportamento de legendagem

inteligente da janela Fontes de Dados
1. Abra uma janela de comando clicando em Iniciar e depois em Executar.
2. Digite regedit na caixa de diálogo Executar e clique em OK.
3. Expanda o nó HKEY_CURRENT_USER>Software>Microsoft>VisualStudio.
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 da cadeia de caracteres:
SmartCaptionExpression
SmartCaptionReplacement
SmartCaptionSuffix
6. Clique com o botão direito do mouse no valor SmartCaptionExpression 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 SmartCaptionReplacement e

9. Insira a cadeia de caracteres de substituição formatada do modo que você deseja

exibir os padrões correspondentes em sua expressão regular.
10. Clique com o botão direito do mouse no valor SmartCaptionSuffix e selecione

Modificar.
11. Insira todos os caracteres que você quer 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 legendagem inteligente

1. Abra uma janela de comando clicando em Iniciar e depois em Executar.
2. Digite regedit na caixa de diálogo Executar e clique em OK.
3. Expanda o nó HKEY_CURRENT_USER>Software>Microsoft>VisualStudio.
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 da cadeia de caracteres:
SmartCaptionExpression
SmartCaptionReplacement
SmartCaptionSuffix
6. Clique com o botão direito do mouse no item SmartCaptionExpression e

7. Insira (.*) como o valor. Isso corresponderá à toda a cadeia de caracteres.
8. Clique com o botão direito do mouse no item SmartCaptionReplacement e

9. Insira $1 como o valor. Isso substitui a cadeia de caracteres pelo valor

correspondente, que é a cadeia de caracteres inteira, de modo 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.
Serviços do Windows Communication
Foundation e WCF Data Services no
Visual Studio
Artigo • 01/11/2023
O Visual Studio fornece ferramentas para trabalhar com o WCF (Windows

Communication Foundation) e WCF Data Services, tecnologias da Microsoft para criar
aplicativos distribuídos. Este tópico fornece uma introdução aos serviços de uma
perspectiva do Visual Studio. Para obter a documentação completa, consulte WCF Data
Services 4.5.
O que é o WCF?
O WCF (Windows Communication Foundation) é uma estrutura unificada para criar
aplicativos distribuídos seguros, confiáveis, transacionados e interoperáveis. Ele substitui
tecnologias de comunicação entre processos mais antigas, como serviços Web ASMX,
Comunicação Remota do .NET, Serviços Empresariais (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 protocolo OData (Open Data). WCF
Data Services permite expor 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ídos por
ASP.NET Web API para criar novos serviços OData. A biblioteca de clientes WCF Data
Services continua sendo uma boa opção para consumir serviços OData em um
aplicativo .NET do Visual Studio (Referência de Serviço de Adição de >Projeto). Para
obter mais informações, consulte WCF Data Services 4.5.
modelo de programação do WCF

O modelo de programação do WCF baseia-se na comunicação entre duas entidades:
um serviço WCF e um cliente WCF. O modelo de programação é encapsulado no
namespace System.ServiceModel 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 atributo ServiceContractAttribute, conforme mostrado
no seguinte código:
C#
C#
[ServiceContract]
public interface IService1
Você define funções ou métodos expostos por um serviço WCF marcando-os com um
atributo OperationContractAttribute.
C#
C#
[OperationContract]
string GetData(string value);
Além disso, você pode expor dados serializados marcando um tipo composto com um
atributo DataContractAttribute. Isso habilita a associaçã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 é composto por um endereço, uma associação e um

contrato. O endereço define onde o serviço está localizado; isso pode ser uma URL, um
endereço FTP ou uma rede ou 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 a
Autenticação do Windows ou nomes de usuário e senhas e muito mais. Um contrato
inclui as operações expostas pela classe de serviço WCF.
Vários pontos de extremidade podem ser expostos para um único serviço WCF. Isso
permite que clientes diferentes se comuniquem com o mesmo serviço de maneiras
diferentes. 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 diferentes.
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
app.config e inclui informações sobre os tipos e métodos 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 por HTTP e
usar a Autenticação do Windows.
Depois que um cliente WCF for criado, você referencia o serviço em seu código da
mesma forma que faria com qualquer outro objeto. Por exemplo, para chamar o
método GetData mostrado anteriormente, você escreveria um código semelhante ao
seguinte:
C#
C#
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;
}
Ferramentas WCF no Visual Studio

O 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 do WCF

Você pode usar os modelos do Visual Studio do WCF como uma base para criar
rapidamente seu próprio serviço. Em seguida, você pode usar o Host Automático do
Serviço WCF e o Cliente de Teste do WCF para depurar e testar o serviço. Juntas, essas
ferramentas fornecem um ciclo de teste e depuração rápido e conveniente e eliminam a
exigência de se comprometer com um modelo de hospedagem em um estágio inicial.
Modelos do WCF
Os modelos do Visual Studio do WCF fornecem uma estrutura de classe básica para o
desenvolvimento de serviços. Vários modelos do WCF estão disponíveis na caixa de
diálogo Adicionar Novo Projeto. Eles incluem projetos lLibrary do serviço WCF, sites de
serviço do WCF e modelos de item de serviço do WCF.
Quando você seleciona um modelo, os arquivos são adicionados para 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 "Hello
World" e você não precisou escrever nenhum código. É claro que você deseja adicionar
código para fornecer funções e métodos para seu serviço do mundo real, mas os
modelos fornecem a base básica.
Para saber mais sobre modelos do WCF, confira Modelos do Visual Studio do WCF.
Host de serviço do WCF
Quando você inicia o depurador do 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 do 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 encontrado.
Usando o Host de Serviço do WCF, você pode testar um serviço WCF sem escrever
nenhum código extra ou se comprometer com um host específico durante o
desenvolvimento.
Para saber mais sobre o Host de Serviço do WCF, consulte Host de serviço do WCF
(WcfSvcHost.exe).
Cliente de teste do WCF
O Cliente de Teste do WCF é uma ferramenta que permite testar parâmetros de teste,
enviar essa entrada a um serviço WCF e exibir a resposta retornada pelo serviço. Ele
fornece uma experiência de teste de serviço conveniente quando combinado com o
host de serviço WCF. Encontre a ferramenta na pasta %ProgramFiles(x86)%\Microsoft
Visual Studio\2017\Enterprise\Common7\IDE.
Quando você pressiona F5 para depurar um projeto de serviço do WCF, o Cliente de

Teste do WCF abre e exibe uma lista de pontos de extremidade de serviç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 o serviço.
Para saber mais sobre o Cliente de Teste do WCF, consulte Cliente de teste do WCF
(WcfTestClient.exe).
Acessar serviõs WCF no Visual Studio

O Visual Studio simplifica a tarefa de criar clientes WCF, gerando automaticamente um
proxy e um ponto de extremidade para serviços que você adiciona usando a caixa de
diálogo Adicionar Referência de Serviço. Todas as informações de configuração
necessárias são adicionadas ao arquivo 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 Serviço permite que você insira o endereço
de um serviço ou pesquise um serviço 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 Serviço permite personalizar 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.
Selecionar um ponto de extremidade de

serviço
Alguns serviços do WCF (Windows Communication Foundation) 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 uma associação
HTTP e um nome de usuário e segurança de senha e um segundo ponto de
extremidade que usa Autenticação FTP e 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.
７ Observaçã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 serviço.
2. No Editor de Código, adicione um construtor para a referência de serviço:
C#
C#
ServiceReference.Service1Client proxy = new

ServiceReference.Service1Client(
７ Observação
Substitua ServiceReference pelo namespace para a referência de serviço e

substitua Service1Client pelo nome do serviço.
3. Uma lista do IntelliSense é exibida que inclui as sobrecargas para o construtor.

Selecione a sobrecarga endpointConfigurationName As String .
4. Após a sobrecarga, digite = ConfigurationName, em que ConfigurationName é o

nome do ponto de extremidade que você deseja usar.
７ Observação
Se você não souber os nomes dos pontos de extremidade disponíveis, poderá

encontrá-los no arquivo app.config.
Para localizar os pontos de extremidade disponíveis para

um serviço WCF
1. Em Gerenciador de Soluções, clique com o botão direito do mouse no arquivo
deapp.config do projeto que contém a referência de serviço e clique em Abrir. O
arquivo aparece no editor de códigos.
2. Pesquise a <Client> marca no arquivo.
3. Pesquise abaixo da marca <Client> para obter uma marca que começa com
<Endpoint> .
Se a referência de serviço fornecer vários pontos de extremidade, haverá duas ou

mais marcas <Endpoint .
4. Dentro da marca <EndPoint> , você encontrará um parâmetro name=" SomeService "

(em que SomeService representa um nome de ponto de extremidade). Esse é o
nome do ponto de extremidade que pode ser passado para a sobrecarga
endpointConfigurationName As String de um construtor para uma referência de
serviço.
Chamar um método de serviço de forma

assíncrona
A maioria dos métodos nos serviços do WCF (Windows Communication Foundation)
pode ser chamada de forma síncrona ou assíncrona. Chamar um método de forma
assíncrona permite que seu aplicativo continue a funcionar 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 Serviço.
７ Observação
Essa opção é definida 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.
７ Observação
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 Projeto, clique em Configurar Referência de Serviço.
3. Na caixa de diálogo Configurar Referência de Serviço, marque a caixa de seleção

Gerar operações assíncronas.
Associar dados retornados por um serviço

Você pode associar dados retornados por um serviço WCF (Windows Communication
Foundation) a um controle, assim como 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
A janela Fontes de Dados é exibida.
2. Na janela Fontes de Dados, expanda o nó para sua 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 desse tipo são exibidos.
4. Selecione um campo e clique na seta suspensa para exibir uma lista de controles
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,

juntamente com um componente BindingSource e um componente
BindingNavigator.
7. Repita as etapas 4 a 6 para quaisquer 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 sua 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 em Detalhes para

exibir os dados em controles individuais.
5. Arraste o nó para o formulário. Os controles são adicionados ao formulário,

juntamente com um componente BindingSource e um componente
BindingNavigator.
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 Serviço.
Para desabilitar o compartilhamento de tipo em um único

assembly
3. Na caixa de diálogo Configurar Referências de Serviço, selecioneReutilizar tipos

em assemblies referenciados especificados.
4. Marque a caixa de seleção para cada assembly no qual você deseja habilitar o
compartilhamento de tipos. Para desabilitar o compartilhamento de tipo para um
assembly, deixe a caixa de seleção desmarcada.
Para desabilitar o compartilhamento de tipos em todos

os assemblies
3. Na caixa de diálogo Configurar Referências de Serviço, desmarque Reutilizar

tipos em assemblies referenciados especificados.
Tópicos relacionados
Título Descrição
Passo a passo: criando um Serviço Fornece uma demonstração passo a passo da criação e do
WCF em Windows Forms uso de serviços WCF no Visual Studio.
Passo a passo: criando um serviço Fornece uma demonstração passo a passo de como criar e
de dados WCF com WPF e Entity usar WCF Data Services no Visual Studio.
Framework
Usando as ferramentas de Discute como criar e testar serviços WCF no Visual Studio.
desenvolvimento do WCF
Como adicionar, atualizar ou remover uma referência de

WCF Data Service
Solução de problemas de Apresenta alguns erros comuns que podem ocorrer com
referências de serviço referências de serviço e como impedi-los.
Depurando serviços WCF Descreve os problemas comuns de depuração e técnicas

que você pode encontrar ao depurar aplicativos Web.
Passo a passo: criando um aplicativo Fornece instruções passo a passo para criar um conjunto
de dados de N camadas de dados tipado e separar o código do TableAdapter e do
Título Descrição
conjunto de dados em vários projetos.
Configurar a caixa de diálogo de Descreve os elementos da interface do usuário da caixa de

referência de serviço diálogo Configurar Referência de Serviço.
Referência
System.ServiceModel
System.Data.Services
Confira também
Trabalhe com um modelo conceitual
(WCF Data Services)
Artigo • 16/01/2024
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
constantemente entre um esquema de banco de dados e um modelo de objeto.
Você pode usar modelos conceituais com aplicativos do WCF Data Services. Os tópicos
a seguir mostram como consultar dados por meio de um modelo conceitual.
Tópico Descrição
How to: Execute Data Service Queries Mostra como consultar um serviço de dados a partir
(Como executar consultas de serviço de de um aplicativo .NET.
dados)
Como projetar 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 quais tipos de dados são válidos na
linguagem que corresponde ao seu domínio. Você pode definir dados válidos no
modelo ou adicionar validação às operações executadas em uma entidade ou serviço de
dados.
Os tópicos a seguir mostram como adicionar validação aos aplicativos do WCF Data
Services.
Tópico Descrição
Como interceptar mensagens de serviço Mostra como adicionar validação a uma operação de
de dados serviço de dados.
Os tópicos a seguir mostram como criar, atualizar e excluir dados executando operações
em entidades.
Tópico Descrição
Como adicionar, modificar e excluir Mostra como criar, atualizar e excluir dados de entidades
entidades em um serviço de dados.
Como definir relacionamentos entre Mostra como criar ou alterar relações em um serviço de
entidades dados.
Serviços do Windows Communication Foundation e WCF Data Services no Visual
Studio
Consultar o serviço de dados
Conectar-se a dados em um serviço de
WCF
Artigo • 30/07/2024
Conecte seu aplicativo .NET Framework aos dados retornados de um serviço WCF
(Windows Communication Foundation) executando o Assistente de Configuração da
Fonte de Dados e selecionando Serviç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 projeto e fica

disponível imediatamente na janela Fontes de Dados.
７ Observação
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 Fontes de Dados na conclusão do
assistente. Isso ocorre porque os conjuntos de dados não tipados não fornecem
esquema, assim, o assistente não tem informações suficientes para criar a fonte de
dados.
７ Observação
Pré-requisitos
As ferramentas do WCF não são instaladas com a carga de trabalho do .NET. Use o
Instalador do Visual Studio para modificar sua instalação. No instalador, escolha
Windows Communication Foundation em Componentes Individuais. Consulte
Para conectar seu aplicativo a um serviço
1. No menu Dados, clique em Adicionar Nova Fonte de Dados.
2. Selecione Serviço na página Escolher um Tipo de Fonte de Dados e selecione

Avançar.
3. Insira o endereço do serviço que você deseja usar ou clique em Descobrir para
localizar serviços na solução atual e selecione Ir.
4. Como opção, você pode digitar um novo Namespace no lugar do valor padrão.
７ Observação
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.
A fonte de dados é adicionada à janela Fontes de Dados.
Associar controles do WPF a um WCF Data Service
Studio
Comentários
Passo a passo: criar um serviço WCF
simples no Windows Forms do .NET
Framework
Artigo • 16/01/2024
Este passo a passo demonstra como criar um serviço WCF (Windows Communication
Foundation) simples, testá-lo e acessá-lo de um aplicativo do Windows Forms do .NET
Framework.
７ Observação
Pré-requisitos
Windows Communication Foundation em Componentes Individuais. Consulte
Criar um serviço
1. Abra o Visual Studio.
2. Na tela Iniciar, selecione Criar um novo projeto.
3. Digite biblioteca de serviços wcf na caixa de pesquisa na página Criar um projeto.

Selecione o modelo de C# ou Visual Basic para a Biblioteca de Serviços WCF e
clique em Avançar.
 Dica
Se não vir nenhum modelo, talvez você precise 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 selecione Windows Communication Foundation. Clique
em Modificar.
4. Na página Configurar o novo projeto, clique em Criar.
７ Observação
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 funções ao serviço.
5. No Gerenciador de Soluções, clique duas vezes em IService1.vb ou IService1.cs.

Localize a seguinte linha:
C#
[OperationContract]
string GetData(int value);
Altere o tipo do parâmetro value para cadeia de caracteres:
C#
[OperationContract]
string GetData(string value);
No código acima, observe o atributo OperationContract . Esse atributo é necessário para

qualquer método exposto pelo serviço.
6. No Gerenciador de Soluções, clique duas vezes em Service1.vb ou Service1.cs.
Localize a seguinte linha:
C#
public string GetData(int value)
{
return string.Format("You entered: {0}", value);
}
Altere o tipo do parâmetro value para cadeia de caracteres:
C#
public string GetData(string value)

{
return string.Format("You entered: {0}", value);
}
Teste o serviço
1. Pressione F5 para executar o serviço. Um formulário do Cliente de Teste do WCF
aparece e carrega o serviço.
2. No formulário Cliente de Teste do WCF, clique duas vezes no método GetData()

em IService1. 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 Projeto. Escolha o
projeto Windows Forms App (.NET Framework).
2. Clique com o botão direito no projeto e selecione Adicionar > Referência de
Serviço. A caixa de diálogo Adicionar Referência de Serviço é exibida.
3. Na caixa de diálogo Adicionar Referência de Serviço, clique em Descobrir.
Service1 é exibido no painel Serviços.
4. Clique em OK para adicionar a referência de serviço.
Compilar um aplicativo cliente

1. No 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. Abra a Caixa de Ferramentas clicando em Exibir>Caixa de Ferramentas (ou

Ctrl+Alt+X no teclado).
3. Na Caixa de Ferramentas, arraste um controle TextBox , um controle Label e um

controle Button para o formulário.

4. Clique duas vezes em Button e adicione o seguinte código ao manipulador de

eventos Click :
C#
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;
}
5. Em Gerenciador de Soluções, clique com o botão direito do mouse no nó do

projeto (por exemplo, WindowsFormsApp1) e clique em Definir como Projeto de
Inicialização.
6. Pressione F5 para executar o projeto. Insira algum texto e clique no botão. O

rótulo exibe "Você inseriu:" e mostra o texto inserido.
Studio
Solucionar problemas de referências do
WCF (Windows Communication
Foundation) ou WCF Data Services no
Visual Studio
Artigo • 11/02/2025
Aplica-se a: Visual Studio
Este artigo lista soluções para problemas comuns que podem ocorrer quando você está
trabalhando com referências ao Windows Communication Foundation (WCF) ou ao WCF
Data Services no Visual Studio.
Se você quiser atualizar ou remover uma referência de serviço, consulte Adicionar,

atualizar ou remover uma referência de serviço de dados WCF.
Erro quando nenhum endereço de serviço é

disponibilizado
Ao selecionar o botão Ir sem endereço, você poderá ver uma mensagem de erro que
diz "Digite o endereço de um serviço". Para resolver esse problema, identifique o
endereço do serviço e insira-o.
Se for um serviço em sua solução, use o botão Descobrir para encontrá-lo e

selecioná-lo e, em seguida, tente o botão Ir novamente.
Se for um serviço hospedado em algum lugar na Internet, adicione-o seguindo as
instruções Adicionar uma referência de serviço WCF.
Erro ao retornar dados de um serviço

Ao retornar um DataSet ou DataTable de um serviço, é possível obter uma exceção "A
cota de tamanho máximo para mensagens de entrada foi excedida". Por padrão, a
propriedade MaxReceivedMessageSize para algumas associações é definida como um
valor relativamente pequeno para limitar a exposição a ataques de negação 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 arquivo app.config para abri-lo.
2. Localize a propriedade MaxReceivedMessageSize e altere-a para um valor maior.
Não consigo encontrar um serviço na minha

solução
Quando você seleciona o botão Descobrir na caixa de diálogo Adicionar Referências
de Serviço , um ou mais projetos da Biblioteca de Serviços WCF na solução não
aparecem na lista de serviços. Esse problema pode ocorrer se uma Biblioteca de
Serviços tiver sido adicionada à solução, mas ainda não tiver sido compilada.
1. Em Gerenciador de Soluções, clique com o botão direito do mouse no projeto

Biblioteca de Serviços do WCF.
2. Selecione Compilar.
Erro ao acessar um serviço em uma área de

trabalho remota
Quando um usuário acessa um serviço WCF hospedado na Web por meio de 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, ele
poderá receber a seguinte mensagem de erro: "A solicitação HTTP não é autorizada
com o esquema de autenticação do cliente 'Anônimo'. O cabeçalho de autenticação
recebido do servidor era 'NTLM'."
1. No projeto do site, abra as páginas Propriedades.

2. Na guia Opções de Inicialização, desmarque a caixa de seleção Autenticação
NTLM.
７ Observação
Você deve desativar a autenticação NTLM somente para sites que contêm
exclusivamente serviços WCF. A segurança dos serviços WCF é gerenciada pela
configuração no arquivo web.config. Dessa forma, a autenticação NTLM se torna
desnecessária.
Nível de acesso para a configuração de classes
geradas não tem efeito
A definição da opção Nível de acesso para classes geradas na caixa de diálogo
Configurar Referências de Serviço como Interno ou Amigo nem sempre pode
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 intervir no código de um serviço WCF do código do cliente, você pode receber um
erro relacionado a símbolos ausentes. Isso pode ocorrer quando um serviço que fazia
parte da sua 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 do cliente de serviço. Isso garante que o cliente sempre acesse
binários de serviço atualizados, o que é importante principalmente para cenários de
depuração, como a depuração 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 se

torna inválida. O Visual Studio não pode mais garantir que o projeto de serviço seja
recriado conforme necessário.
Para corrigir esse erro, recompile manualmente o projeto de serviço:
1. No menu Ferramentas, selecione 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 avançadas de build está
marcada e selecione OK.
4. Carregue o projeto de serviço WCF.
5. Na caixa de diálogo Gerenciador de Configurações, defina a Configuração de
solução ativa para 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 Compilar , selecione Recompilar para recompilar o projeto de serviço
WCF.
O WCF Data Services não é exibido no
navegador
Quando tenta exibir uma representação XML de dados em um Serviço de Dados do
WCF, o Internet Explorer pode interpretar mal os dados como um feed RSS. Verifique se
a opção para exibir feeds RSS está desabilitada.
Para corrigir esse erro, desabilite feeds RSS:
1. No Internet Explorer, no menu Ferramentas , selecione Opções da Internet.

2. Na guia Conteúdo , na seção Feeds , selecione Configurações.
3. Na caixa de diálogo Configurações de feed, desmarque a caixa de seleção Ativar
exibição de leitura de feed e selecione OK.
4. Selecione OK para fechar a caixa de diálogo Opções da Internet.
Comentários
Fornecer comentários sobre o produto

Caixa de diálogo Configurar Referência
de Serviço
Artigo • 04/02/2025
７ Observação

simples.
A caixa de diálogo Configurar Referência de Serviço permite configurar o

comportamento dos serviços do WCF (Windows 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 Serviço. Você também pode acessar a caixa de diálogo
clicando no botão Avançado na caixa de diálogo Adicionar Referência de Serviço.
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 de 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, selecione 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 de um cliente WCF,
selecione os tipos das listas Tipo de coleção e Tipo de coleção dicionário.
Para desabilitar o compartilhamento de tipos, desmarque 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, marque a caixa de seleção
Reutilizar tipos em assemblies referenciados especificados e selecione as
referências desejadas na Lista de assemblies referenciados.
Lista UIElement
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 depois movido para um servidor de produção, exigindo uma
alteração de endereço.
７ Observação
O elemento Address não está disponível quando a caixa de diálogo Configurar

Referência de Serviço é exibida a partir da caixa de diálogo Adicionar Referência
de Serviço.
nível de acesso para classes geradas
Determina o nível de acesso ao código para classes de cliente WCF.
７ Observação
Para projetos de site, essa opção é sempre definida como Public e não pode ser
alterada. Para obter mais informações, consulte Referências de serviço de solução
de problemas.
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 tarefa

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 TPL (Biblioteca Paralela
de Tarefas).
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 listas 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 é verificada.
Usar novamente os tipos em todos os assemblies consultados
Quando selecionada, todos os tipos na Lista de assemblies referenciados são

reutilizados, se possível. Por padrão, essa opção está selecionada.
Usar novamente os tipos em determinados assemblies consultados
Quando selecionada, somente os tipos selecionados na Lista de 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 da Web
Exibe a caixa de diálogo Adicionar referência da Web.
７ Observação
Essa opção só deve ser usada para projetos destinados à versão 2.0 do .NET
Framework.
７ Observação
O botão Adicionar Referência da Web só estará disponível quando a caixa de

diálogo Configurar Referência de Serviço estiver exibida na caixa de diálogo
Adicionar Referência de Serviço.
Consulte também
Como adicionar uma referência a um serviço Web
Windows Communication Foundation Services e WCF Data Services
Comentários

Adicionar, atualizar ou remover uma
referência do WCF Data Service
Artigo • 30/07/2024
Para projetos .NET Framework, a referência de serviço permite que um projeto acesse um
ou mais WCF Data Services. Use a caixa de diálogo Adicionar Referência de Serviço
para procurar WCF Data Services na solução atual, localmente, em uma rede local ou na
Internet.
Para projetos do .NET Core, você pode usar o nó Serviços Conectados no Gerenciador
de Soluções para acessar o Provedor do Microsoft WCF Web Service Reference, que
permite gerenciar referências de serviço de dados do WCF (Windows Communication
Foundation).
７ Observação
Pré-requisitos
Windows Communication Foundation em Componentes Individuais. Confira Modificar
o Visual Studio.
Adicionar uma referência de serviço WCF
Para adicionar uma referência a um serviço externo

(projetos do .NET Framework)
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 selecione Adicionar Referência
de Serviço.
A caixa de diálogo Adicionar Referência de Serviço é exibida.

2. Na caixa Endereço, insira a URL do serviço e selecione Ir para pesquisar o serviço.
Se o serviço implementar segurança de nome de usuário e senha, esses dados
poderão ser solicitados. Você também pode escolher um serviço em sua própria
solução. Escolha o botão Descobrir e escolha Serviços na Solução.
７ Observação
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 Serviços, expanda o nó para o 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 arquivo app.config.
Para adicionar uma referência a um serviço externo

(projetos do .NET Core, incluindo o .NET 5 e versões
posteriores)
1. No Gerenciador de Soluções, clique duas vezes no nó Serviços Conectados.
A guia Configurar Serviços é aberta.
2. Escolha Provedor do Microsoft WCF Web Service Reference.
A caixa de diálogo Configurar WCF Web Service Reference é exibida.

3. Na caixa URI, insira a URL do serviço e selecione Ir para pesquisar o serviço. Se o
serviço implementar segurança de nome de usuário e senha, esses dados poderão
ser solicitados.
７ Observação
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 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.
6. Clique em Finalizar para adicionar a referência ao projeto.

Para adicionar uma referência a um serviço na solução
atual (projetos do .NET Framework)
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 selecione Adicionar Referência
de Serviço.
A caixa de diálogo Adicionar Referência de Serviç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 Serviços.
5. Clique em OK para adicionar a referência ao projeto.

Para adicionar uma referência a um serviço na solução

atual (projetos do .NET Core)
1. No Gerenciador de Soluções, clique duas vezes no nó Serviços Conectados.
A guia Configurar Serviços é aberta.
2. Escolha Provedor do Microsoft WCF Web Service Reference.
A caixa de diálogo Configurar WCF Web Service Reference é exibida.
3. Clique em Descobrir.
Todos os serviços (WCF Data Services e serviços WCF) na solução atual são
adicionados à lista Serviços.
6. Clique em Finalizar para adicionar a referência ao projeto.

Atualizar uma referência de serviço

Às vezes, o Modelo de Dados de Entidade para um WCF Data Services é alterado.
Quando isso acontece, você deve atualizar a referência de serviço.
Atualizar uma referência de serviço

Para projetos .NET Core, use a ferramenta dotnet-svcutil . Consulte dotnet-svcutil para
a instalação e as instruções.
Para projetos do .NET Framework:
No Gerenciador de Soluções, expanda o nó Serviços Conectados, clique com o

botão direito do mouse na referência de serviço e selecione Atualizar Referência
de Serviç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 quaisquer
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 de
sua solução.
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 selecione 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.
７ Observação
Qualquer código que faça referência à referência de serviço deve ser

removido manualmente.
Studio
Comentários
Métodos de DataContext (Designer de
Objeto Relacional)
Artigo • 18/03/2023
Os métodos DataContext (no contexto das ferramentas LINQ to SQL no Visual Studio)
são os métodos da classe DataContext que executam procedimentos e funções
armazenados em um banco de dados.
A classe DataContext é uma classe LINQ to SQL que atua como um canal entre um
banco de dados SQL Server e as classes de entidade LINQ to SQL mapeadas para esse
banco de dados. A classe DataContext contém as informações da cadeia de conexão e
os métodos para se conectar a um banco de dados e manipular os dados no banco de
dados. Por padrão, a classe DataContext contém vários métodos que você pode chamar,
como o método SubmitChanges que envia dados atualizados das classes do LINQ to
SQL para o banco de dados. Você também pode criar métodos DataContext adicionais
que mapeiem para procedimentos armazenados e funções. Ou seja, a chamada desses
métodos personalizados executará a função ou o procedimento armazenado no banco
de dados para o qual o método DataContext está mapeado. Você pode adicionar novos
métodos à classe DataContext exatamente como adiciona métodos para estender
qualquer classe. No entanto, em discussões sobre os métodos DataContext no contexto
do Designer Relacional de Objetos, são os métodos DataContext que mapeiam para as
funções e procedimentos armazenados que estão sendo discutidos.
Painel Métodos
Os métodos DataContext que mapeiam para os procedimentos e funções armazenados
são exibidos no painel Métodos do Designer Relacional de Objetos. O painel Métodos
é o painel na lateral direita do painel Entidades (a superfície de design principal). O
painel de Métodos lista todos os métodos DataContext que você criou usando o
Designer Relacional de Objetos. Por padrão, o painel de Métodos está vazio. Arraste os
procedimentos ou funções armazenadas do Gerenciador de Servidores ou do
Gerenciador de Banco de Dados para o Designer Relacional de Objetos para criar
métodos DataContext e popular o painel de Métodos. Para obter mais informações,
consulte Como criar métodos DataContext mapeados para procedimentos e funções
armazenados (Designer Relacional de Objetos).
７ Observação
Abra e feche o painel de métodos clicando com o botão direito do mouse no
Designer Relacional de Objetos e depois clicando em Ocultar Painel de Métodos,
ou Mostrar Painel de Métodos, ou use ainda 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 de Métodos do Designer Relacional de Objetos. 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:
Os métodos DataContext 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 e funções armazenados (Designer
Relacional de Objetos), System.Data.Linq.ISingleResult<T> e IMultipleResults.
Os métodos DataContext 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 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, confira Como atribuir procedimentos
armazenados para executar atualizações, inserções e exclusões (Designer
Tipos de retorno de métodos de DataContext

Quando você arrasta procedimentos armazenados e funções do Gerenciador de
Servidores ou do Gerenciador de Banco de Dados para o Designer Relacional de
Objetos, o tipo de retorno do método DataContext gerado difere dependendo de onde
você solta o item. Soltar os itens diretamente na classe de uma entidade existente cria
um método DataContext com o tipo de retorno da classe de entidade; soltar itens em
uma área vazia do Designer Relacional de Objetos (em qualquer painel) cria um
método DataContext que retorna um tipo gerado automaticamente. O tipo gerado
automaticamente possui o nome que corresponde ao nome e às propriedades do
procedimento ou da função armazenados, que são mapeados para os campos
retornados pela função ou procedimento armazenado.
７ Observação
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, confira Como alterar o tipo
de retorno de um método DataContext (Designer Relacional de Objetos).
Objetos que você arrasta do banco de dados para a superfície do Designer Relacional
de Objetos serã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á
acrescentado ao final do novo nome para diferenciar 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
Procedimentos armazenados
exclusões (Designer Relacional de Objetos)
Passo a passo: personalizando a inserção, a atualização e o comportamento de
Herança de classe de dados (Designer
Artigo • 12/01/2024
Como outros objetos, as classes de LINQ to SQL podem usar a 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 Designer Relacional de Objetos (Designer de
O/R) dá suporte ao conceito de herança de tabela única, pois geralmente é o
implementado nos 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, pense em uma tabela Persons que contém todos os
empregados de uma empresa. Algumas pessoas são funcionários e algumas pessoas
são gerentes. A tabela Persons contém uma coluna denominada Type que possui o
valor de 1 para gerentes e o valor de 2 para funcionários. A coluna Type é a coluna de
discriminador. Nesse cenário, você pode criar uma subclasse de funcionários e
preencher a classe apenas com os registros que possuem valor Type de 2.
Quando configurar a herança nas classes de entidade usando o 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:
Propriedade A propriedade (mapeado para a coluna) que determina qual classe ao

Discriminatória registro atual pertence.
Valor Discriminador O valor (na coluna designada como a propriedade discriminatória) que
de Classe Base determina que um registro é a classe base.
Valor Discriminatório O valor (na propriedade designada como a propriedade

da Classe Derivada discriminatória) que determina que um registro é da classe derivada.
Padrão de Herança A classe preenchida quando o valor da propriedade designada como

Propriedade Discriminatória não corresponder nem ao Valor
Discriminador de Classe Base nem ao Valor Discriminatório da 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 Relacional de Objetos.
Tópico Descrição
Como configurar a herança usando o Descreve como configurar classes de entidade que
Designer Relacional de Objetos usam herança de tabela única usando o Designer
Relacional de Objetos.
Passo a passo: criando classes LINQ to Fornece instruções passo a passo sobre como
SQL usando a herança de tabela única configurar classes de entidade que usam herança de
(Designer Relacional de Objetos) tabela única usando o Designer Relacional de
Objetos.
Passo a passo: criando classes LINQ to SQL usando a herança de tabela única
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
Artigo • 12/01/2024
O tipo de retorno de um ou mais métodos de DataContext é a classe de entidade

selecionada. Excluir um classe de entidade usada como o tipo de retorno para um
método DataContext faz com que a 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 Servidores/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
A cadeia de conexão contém credenciais
com uma senha de texto não
criptografado e não estiver usando
segurança integrada
Artigo • 12/01/2024
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.
２ Aviso
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 caracteres de conexão sem as informações confidenciais,
selecione 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 caracteres de conexão sem as informações confidenciais,

selecione Não.
A cadeia de conexão é armazenada como uma configuração de aplicativo, mas a

senha não é incluído.
Confira também
A propriedade <nome da propriedade>
não pode ser excluída porque está
participando da associação <nome da
associação>
Artigo • 12/01/2024
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.

1. Selecione a linha de associação no Designer Relacional de Objetos que conecta as
classes de dados mencionadas 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
A propriedade <nome da propriedade>
não pode ser excluída
Artigo • 12/01/2024
A propriedade <nome da propriedade> não pode ser excluída porque está definida
como a Propriedade discriminatória para herança entre <nome da classe> e <nome da
classe>
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.

1. No Designer Relacional de Objetos, selecione a linha de herança que conecta as
classes de dados mencionadas na mensagem de erro.
2. Defina a propriedade discriminatória para uma propriedade diferente.
3. Tente excluir novamente a propriedade.
Confira também
A propriedade de conexão no arquivo
de configurações do aplicativo está
ausente ou incorreta
Artigo • 12/01/2024
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 no arquivo de

configurações do aplicativo que não pode ser encontrada. 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
Não é possível criar uma associação
<nome da associação> – os tipos de
propriedade não correspondem
Artigo • 12/01/2024
Não é possível criar uma associação <nome da associação> – os tipos de propriedade

não correspondem. As propriedades não têm tipos correspondentes: <nomes de
propriedade>.
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.

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
Como: criar uma associação entre classes LINQ to SQL (O/R Designer)
Aviso: foram feitas alterações na caixa
de diálogo Configurar Comportamento
que não foram aplicadas
Artigo • 12/01/2024
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 Comportamento permite que você configure os

comportamentos Insert , Update e Delete para qualquer classe disponível. Esta
mensagem aparece quando você seleciona uma nova combinação de Classe e
Comportamento 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 Comportamento selecionados.
Para cancelar a mudança anterior e continuar, clique em Não.
Confira também
Você tiver selecionado um objeto de
base de dados de um provedor de base
de dados sem suporte
Artigo • 12/01/2024
O Designer Relacional de Objetos oferece suporte somente ao provedor de dados. NET

Framework 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.
７ Observação
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 do. NET Framework para SQL Server.
Confira também
Este método relacionado é o método de
suporte para a seguir inserção,
atualização, ou métodos padrão de
exclusão
Artigo • 12/01/2024
Este método relacionado é o método de suporte para os métodos Insert , Update ou

Delete a seguir. Se ele for excluído, esses métodos também serão excluídos. Deseja
continuar?
O método selecionado DataContext é usado atualmente como um dos métodos Insert ,

Update ou Delete para uma das classes de entidade em no Designer Relacional de
Objetos. Excluir o método selecionado fará com que a classe de entidade que estiver
usando esse método reverta para o comportamento padrão de tempo de execução para
executar a inserção, atualização ou exclusão durante uma atualização.
Opções selecionadas de métodos

Para excluir o método selecionado, fazendo com que a classe de entidade use
atualizações em tempo de execução, clique em Sim.
O método selecionado é excluído e quaisquer classes que usassem esse método

para substituir o comportamento de atualização são revertidas para usar o
comportamento padrão de runtime 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
Um ou mais itens selecionados contêm
um tipo de dados que não é suportado
pelo designer
Artigo • 12/01/2024
Um ou mais itens arrastados do Gerenciador de Servidores ou do Gerenciador de

Banco de Dados para o Designer Relacional de Objetos contém um tipo de dados que
não recebe suporte do Designer Relacional de Objetos como, por exemplo, Tipos CLR
definidos pelo usuário.

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 do Gerenciador de Servidores ou do Gerenciador de Banco de

Dados para o designer.
Confira também
Altere o tipo de retorno de um método
DataContext não pode ser desfeito
Artigo • 12/01/2024
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 Servidores 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 no Object Relational Designer. 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 do
Object Relational Designer, um método DataContext que retorna um tipo 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.
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 no Object Relational Designer e exclua-o.
2. Localize o item em Gerenciador de Servidores/Gerenciador de Banco de Dados e

arraste-o até o Object Relational Designer.
Um método de DataContext é criado com o tipo de retorno padrão original.
Confira também
O designer não pode ser alterado para
depuração
Artigo • 12/01/2024
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á sendo executado no modo de depuração, o
Designer Relacional de Objetos é somente leitura.
Para corrigir esse erro, selecione Parar Depuração no menu Depurar. O aplicativo para a
depuração e você pode modificar itens no Designer Relacional de Objetos.
Confira também
A conexão selecionada usa um provedor
de base de dados sem suporte
Artigo • 12/01/2024
Esta mensagem aparece quando você arrasta itens que não usam o provedor de dados
.NET Framework para SQL Server do Gerenciador de Servidores ou do Gerenciador de
Banco de Dados para as ferramentas do LINQ to SQL no Visual Studio.
O Designer Relacional de Objetos dá suporte apenas para conexões de dados que

usam o Provedor do .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 usem o
provedor de dados do .NET Framework para SQL Server ao Designer Relacional de
Objetos.
Confira também
System.Data.SqlClient
Os objetos que você está adicionando
ao designer usam uma conexão de
dados diferente da que o designer usa
Artigo • 12/01/2024
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 Designer Relacional de Objeto (Object Relational

Designer), todos os itens usam uma conexão de dados compartilhada. (A superfície de
design representa o DataContext, que usa apenas uma conexão para todos os objetos
na superfície). Se você adicionar ao designer um objeto que usa uma conexão de dados
diferente da conexão de dados que está sendo usada atualmente 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 Relacional de Objetos, e o

DataContext.Connection é definido para a nova conexão.
７ Observação
Se você clicar em Sim, todas as classes de entidade no Designer Relacional

de Objetos serão mapeadas para a nova conexão.
Para continuar usando 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 para a conexão

existente.
Confira também
Não é possível criar uma associação
<nome da associação> – propriedade
listada duas vezes
Artigo • 12/01/2024
Não é possível criar uma associação <nome da associação>. A mesma propriedade é

listada mais de uma vez: <nome da propriedade>.
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
Como: criar uma associação entre classes LINQ to SQL (O/R Designer)
Não foi possível recuperar informações
de esquema do objeto de banco de
dados <nome do objeto>
Artigo • 12/01/2024
Esta mensagem aparece normalmente quando um objeto no Gerenciador de

Servidores/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
Um ou mais objetos de base de dados
selecionado retornam um esquema que
não corresponde ao esquema de classe
de destino
Artigo • 12/01/2024
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.

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

Visualstudio Data Tools vs 2022

Enviado por

Dados do documentoclique para ver informações do documento

Direitos autorais:

Formatos disponíveis

Visualstudio Data Tools vs 2022

Enviado por

Dados do documento

Descrição original:

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Visualstudio Data Tools vs 2022

Enviado por

Direitos autorais:

Formatos disponíveis

Dê a sua opinião sobre a experiência de download do PDF.

Trabalhar com dados no Visual Studio

Usando do Visual Studio Connected Services, você pode simplificar o processo de

Para outras tecnologias relacionadas a dados, o Visual Studio 2022 dá suporte ao

Armazenamento do Azure (local e remoto)

SQL Data Warehouse

Para obter a documentação de acesso a dados relacionada ao ASP.NET, consulte

Aplicativos da Plataforma Universal do Windows (UWP) em C# ou Visual Basic podem

Para o armazenamento de dados no computador local, a abordagem recomendada é

Se você precisar manter aplicativos de 32 bits que se conectam a bancos de dados

Se você planeja converter o projeto para ser um processo de 64 bits, é

LINQ to SQL: um mapeador relacional de objeto de geração anterior. Ele funciona

Django e Banco de Dados SQL no Azure

SQL Server Data Tools— descreve as ferramentas que simplificam o design, a

ADO.NET— Descreve a arquitetura ADO.NET e como usar as classes ADO.NET para

LINQ (Consulta Integrada à Linguagem)— descreve os recursos de consulta integrados

documentos e dados XML— apresenta uma visão geral de um conjunto abrangente e

Fornecer comentários sobre o produto | Pergunte à comunidade

Os conjuntos de dados e as classes relacionadas são tecnologias herdadas do .NET

Visual Studio com as cargas de trabalho do desenvolvimento do .NET para

Configurar o banco de dados de exemplo

1. No Visual Studio, abra a janela Gerenciador de Servidores.

2. Clique com o botão direito do mouse em Conexões de Dados e escolha Criar

3. Na caixa de texto Nome do servidor, insira (localdb)\mssqllocaldb.

O banco de dados de Vendas vazio é criado e adicionado ao nó Conexões de

5. Clique com o botão direito do mouse na conexão de dados de Vendas e selecione

Uma janela do editor de consultas vai se abrir.

7. Cole o script T-SQL no editor de consultas e escolha o botão Executar.

Após um curto período de tempo, a consulta termina de ser executada e os

Criar os formulários e adicionar controles

O Visual Studio cria o projeto e vários arquivos, incluindo um formulário vazio do

A caixa de grupo e os controles de rótulo adicionam clareza, mas não são

Controles para o formulário Navegação Propriedades

Botão Nome = btnGoToAdd

Botão Nome = btnGoToFillOrCancel

Botão Nome = btnExit

Controles para o formulário NewCustomer Propriedades

TextBox Nome = txtCustomerName

TextBox Nome = txtCustomerID

Botão Nome = btnCreateAccount

DateTimePicker Formato = Curto

Botão Nome = btnPlaceOrder

Botão Nome = btnAddAnotherAccount

Botão Nome = btnAddFinish

Controles para o formulário FillOrCancel Propriedades

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

1. Se você estiver usando C#, no Gerenciador de Soluções, expanda o nó

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