Criar um aplicativo de dados básico usando ADO.NET

Ao criar um aplicativo que manipula dados em um banco de dados, normalmente você executa tarefas como definir cadeias de conexão, inserir dados e executar procedimentos armazenados. Ao seguir este artigo, você pode descobrir como interagir com um banco de dados de dentro de um aplicativo FOD ( formulários sobre dados ) do Windows Forms usando Visual C# ou Visual Basic e ADO.NET. Todas as tecnologias de dados do .NET, incluindo conjuntos de dados, LINQ (Language-Integrated Query) para SQL e Entity Framework, finalmente executam etapas semelhantes às etapas mostradas neste artigo.

Este artigo demonstra como obter dados rapidamente de um banco de dados. Se seu aplicativo precisar modificar dados de maneiras nãotriviais e atualizar o banco de dados, considere usar o Entity Framework e a associação de dados. Isso permite que os controles de interface do usuário sincronizem automaticamente com as alterações nos dados subjacentes.

Para acessar o código completo deste tutorial, consulte o repositório GitHub de documentos do Visual Studio para C# e Visual Basic.

Prerequisites

• Visual Studio com as cargas de trabalho de desenvolvimento de desktop com .NET e armazenamento e processamento de dados instaladas. Para instalá-los, abra o Instalador do Visual Studio e escolha 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.

Este artigo pressupõe que você esteja familiarizado com a funcionalidade básica do IDE do Visual Studio. Ele também pressupõe que você pode criar um aplicativo do Windows Forms, adicionar formulários a um projeto, adicionar botões e outros controles aos formulários, definir propriedades de controle e codificar eventos simples. Se você não estiver familiarizado com essas tarefas, conclua o tutorial Criar um aplicativo do Windows Forms no Visual Studio com C# ou o tutorial Criar um aplicativo do Windows Forms no Visual Studio com o Visual Basic 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 do Gerenciador de Servidores .

2. Clique com o botão direito do mouse em Conexões de Dados e escolha Criar Novo Banco de Dados do SQL Server.

3. Para o nome do servidor, insira (localdb)\mssqllocaldb.

4. Para novo nome de banco de dados, insira Vendas e escolha OK.

   O Visual Studio cria um banco de dados de Vendas vazio no nó Conexões de Dados no Gerenciador de Servidores.

5. Clique com o botão direito do mouse na conexão de dados vendas e selecione Nova Consulta.

   Uma janela do editor de consultas é aberta.

6. Copie o script Transact-SQL de Vendas para a sua área de transferência.

7. Cole o script T-SQL na janela do editor de consultas e selecione Executar.

   Após um curto período de tempo, a consulta termina de ser executada e os objetos de banco de dados são criados. O banco de dados contém duas tabelas: Cliente e Pedidos. Essas tabelas não contêm dados inicialmente, mas você pode adicionar dados ao executar o aplicativo criado. O banco de dados também contém cinco procedimentos armazenados básicos.

Criar os formulários e adicionar controles

1. Crie um projeto C# ou Visual Basic com o modelo do Aplicativo windows forms (.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. No Gerenciador de Soluções, adicione dois formulários do Windows ao seu projeto para que ele tenha um total de três formulários e dê a eles os seguintes nomes:

   • Navigation

   • NewCustomer

   • FillOrCancel

3. Para cada formulário, adicione as caixas de texto, botões e outros controles mostrados nas ilustrações a seguir. Para cada controle, defina as propriedades descritas pelas tabelas.

   Note

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

   Formulário de navegação

   

   Controles para o formulário de navegação

   Controlar texto	Tipo de controle	Propriedades de controle
   Adicionar uma conta	Button	Nome = btnGoToAdd
   Preencher ou cancelar um pedido	Button	Nome = btnGoToFillOrCancel
   Exit	Button	Nome = btnExit

   Formulário NewCustomer

   

   Controles para o formulário NewCustomer

   Texto de rótulo e controle	Tipo de controle	Propriedades de controle
   Nome do cliente	TextBox	Nome = txtCustomerName
   ID do cliente	TextBox	Nome = txtCustomerID SomenteLeitura = Verdadeiro
   Criar conta	Button	Nome = btnCreateAccount
   Valor do pedido	NumericUpdown	Nome = numOrderAmount DecimalPlaces = 0 Máximo = 5000
   Data do pedido	DateTimePicker	Nome = dtpOrderDate Formato = Curto
   Fazer pedido	Button	Nome = btnPlaceOrder
   Finish	Button	Nome = btnAddFinish
   Adicionar outra conta	Button	Nome = btnAddAnotherAccount

   Formulário FillOrCancel

   

   Controles para o formulário FillOrCancel

   Texto de rótulo e controle	Tipo de controle	Propriedades de controle
   ID do pedido	TextBox	Nome = txtOrderID
   Localizar pedido	Button	Nome = btnFindByOrderID
   Se estiver preenchendo um pedido...	DateTimePicker	Nome = dtpFillDate Formato = Curto
   (None)	DataGridView	Nome = dgvCustomerOrders SomenteLeitura = Verdadeiro RowHeadersVisible = Falso
   Cancelar pedido	Button	Nome = btnCancelOrder
   Preencher pedido	Button	Nome = btnFillOrder
   Finish	Button	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 a necessidade de inserir a cadeia de caracteres manualmente em cada formulário, armazene a cadeia de caracteres no arquivo App.config em seu projeto. Em seguida, crie um método que retorna a cadeia de caracteres quando o método é chamado de qualquer formulário em seu aplicativo.

Para localizar a cadeia de conexão:

1. No Gerenciador de Servidores, clique com o botão direito do mouse na conexão de dados Sales e escolha Propriedades.

2. Localize a propriedade Cadeia de caracteres de Conexão e copie seu valor de cadeia de caracteres para a área de transferência.

Para armazenar a cadeia de conexão em seu projeto:

1. No Gerenciador de Soluções, execute uma das seguintes etapas, dependendo do tipo de projeto:

   • Para um projeto em C#, expanda o nó Propriedades dentro do projeto e, depois, abra o arquivo Settings.settings.

   • Para um projeto do Visual Basic, selecione Mostrar Todos os Arquivos, expanda o nó Meu Projeto e, em seguida, 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.

   

Escrever o código para os formulários

Esta seção contém breves visões gerais do que cada formulário faz. Ele também fornece o código que define a lógica subjacente quando você seleciona um botão no formulário.

Formulário de navegação

O formulário de navegação é aberto quando você executa o aplicativo e inclui os seguintes botões:

• Adicionar uma conta: abre o formulário NewCustomer .

• Preencher ou cancelar pedidos: abre o formulário FillOrCancel .

• Sair: fecha o aplicativo.

Tornar o formulário de navegação o formulário de inicialização

Para projetos em C#:

1. No Gerenciador de Soluções, abra Program.cs.

2. Altere a Application.Run linha para: Application.Run(new Navigation());

Para projetos do Visual Basic:

1. No Gerenciador de Soluções, clique com o botão direito do mouse no projeto e escolha Propriedades.

2. No Designer de Projeto, selecione a guia Aplicativo e, em seguida, selecione Navegação na lista de objetos de inicialização.

Criar manipuladores de eventos gerados automaticamente para o formulário de navegação

Para criar métodos de manipulador de eventos vazios, clique duas vezes em cada um dos três botões no formulário de navegação. Clicar duas vezes em um botão adiciona código gerado automaticamente no arquivo de código designer, o que permite que uma seleção de botão acione um evento.

Se você decidir copiar e colar o código diretamente em seus arquivos de código em vez de usar a ação de clique duplo no designer, certifique-se de definir o manipulador de eventos como o método certo:

1. Na janela Propriedades do arquivo de código do formulário, vá para a guia Eventos usando o botão com ícone de raio da barra de ferramentas.

2. Pesquise a propriedade Click e verifique se seu valor é o método correto do manipulador de eventos.

Adicionar código para a lógica do formulário de navegação

Na página de código do formulário de Navegação, preencha os corpos dos métodos para os três manipuladores de eventos de seleção de botão, conforme mostrado no código a seguir.

/// <summary>
/// Opens the NewCustomer form as a dialog box,
/// which returns focus to the calling form when it is closed. 
/// </summary>
private void btnGoToAdd_Click(object sender, EventArgs e)
{
    Form frm = new NewCustomer();
    frm.Show();
}

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

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

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

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

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

Formulário NewCustomer

Quando você insere um nome de cliente e, em seguida, 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 .

Criar manipuladores de eventos gerados automaticamente para o formulário NewCustomer

Crie um manipulador de evento de 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 código gerado automaticamente no arquivo de código do Designer que permite que uma seleção de botão acione 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 não seja necessário qualificar totalmente os nomes de seus membros.

   • C#
   • VB

   using System.Data.SqlClient;
   

2. Adicione algumas variáveis e métodos auxiliares à classe.

   • C#
   • VB

   // 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 seleção de botão.

   • C#
   • VB

   /// <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.
                   sqlCommand.Parameters.Add(new SqlParameter("@CustomerID", SqlDbType.Int));
                   sqlCommand.Parameters["@CustomerID"].Direction = ParameterDirection.Output;
   
                   try
                   {
                       connection.Open();
   
                       // Run the stored procedure.
                       sqlCommand.ExecuteNonQuery();
   
                       // Customer ID is an IDENTITY value from the database.
                       this.parsedCustomerID = (int)sqlCommand.Parameters["@CustomerID"].Value;
   
                       // Put the Customer ID value into the read-only text box.
                       this.txtCustomerID.Text = Convert.ToString(parsedCustomerID);
                   }
                   catch
                   {
                       MessageBox.Show("Customer ID was not returned. Account could not be created.");
                   }
                   finally
                   {
                       connection.Close();
                   }
               }
           }
       }
   }
   
   /// <summary>
   /// Calls the Sales.uspPlaceNewOrder stored procedure to place an order.
   /// </summary>
   private void btnPlaceOrder_Click(object sender, EventArgs e)
   {
       // Ensure the required input is present.
       if (IsOrderDataValid())
       {
           // Create the connection.
           using (SqlConnection connection = new SqlConnection(Properties.Settings.Default.connString))
           {
               // Create SqlCommand and identify it as a stored procedure.
               using (SqlCommand sqlCommand = new SqlCommand("Sales.uspPlaceNewOrder", connection))
               {
                   sqlCommand.CommandType = CommandType.StoredProcedure;
   
                   // Add the @CustomerID input parameter, which was obtained from uspNewCustomer.
                   sqlCommand.Parameters.Add(new SqlParameter("@CustomerID", SqlDbType.Int));
                   sqlCommand.Parameters["@CustomerID"].Value = this.parsedCustomerID;
   
                   // Add the @OrderDate input parameter.
                   sqlCommand.Parameters.Add(new SqlParameter("@OrderDate", SqlDbType.DateTime, 8));
                   sqlCommand.Parameters["@OrderDate"].Value = dtpOrderDate.Value;
   
                   // Add the @Amount order amount input parameter.
                   sqlCommand.Parameters.Add(new SqlParameter("@Amount", SqlDbType.Int));
                   sqlCommand.Parameters["@Amount"].Value = numOrderAmount.Value;
   
                   // Add the @Status order status input parameter.
                   // For a new order, the status is always O (open).
                   sqlCommand.Parameters.Add(new SqlParameter("@Status", SqlDbType.Char, 1));
                   sqlCommand.Parameters["@Status"].Value = "O";
   
                   // Add the return value for the stored procedure, which is  the order ID.
                   sqlCommand.Parameters.Add(new SqlParameter("@RC", SqlDbType.Int));
                   sqlCommand.Parameters["@RC"].Direction = ParameterDirection.ReturnValue;
   
                   try
                   {
                       //Open connection.
                       connection.Open();
   
                       // Run the stored procedure.
                       sqlCommand.ExecuteNonQuery();
   
                       // Display the order number.
                       this.orderID = (int)sqlCommand.Parameters["@RC"].Value;
                       MessageBox.Show("Order number " + this.orderID + " has been submitted.");
                   }
                   catch
                   {
                       MessageBox.Show("Order could not be placed.");
                   }
                   finally
                   {
                       connection.Close();
                   }
               }
           }
       }
   }
   
   /// <summary>
   /// Clears the form data so another new account can be created.
   /// </summary>
   private void btnAddAnotherAccount_Click(object sender, EventArgs e)
   {
       this.ClearForm();
   }
   
   /// <summary>
   /// Closes the form/dialog box.
   /// </summary>
   private void btnAddFinish_Click(object sender, EventArgs e)
   {
       this.Close();
   }
   

Formulário FillOrCancel

O formulário FillOrCancel executa uma consulta para retornar um pedido quando você insere uma ID do pedido e, em seguida, selecione o botão Localizar pedido . A linha retornada aparece em uma tabela de dados de 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.

Criar manipuladores de eventos gerados automaticamente para o formulário FillOrCancel

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 código gerado automaticamente no arquivo de código do Designer que permite que uma seleção de botão acione 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#
   • VB

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

2. Adicione uma variável e um método auxiliar à classe.

   • C#
   • VB

   // 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 seleção de botão.

   • C#
   • VB

   /// <summary>
   /// Executes a t-SQL SELECT statement to obtain order data for a specified
   /// order ID, then displays it in the DataGridView on the form.
   /// </summary>
   private void btnFindByOrderID_Click(object sender, EventArgs e)
   {
       if (IsOrderIDValid())
       {
           using (SqlConnection connection = new SqlConnection(Properties.Settings.Default.connString))
           {
               // Define a t-SQL query string that has a parameter for orderID.
               const string sql = "SELECT * FROM Sales.Orders WHERE orderID = @orderID";
   
               // Create a SqlCommand object.
               using (SqlCommand sqlCommand = new SqlCommand(sql, connection))
               {
                   // Define the @orderID parameter and set its value.
                   sqlCommand.Parameters.Add(new SqlParameter("@orderID", SqlDbType.Int));
                   sqlCommand.Parameters["@orderID"].Value = parsedOrderID;
   
                   try
                   {
                       connection.Open();
   
                       // Run the query by calling ExecuteReader().
                       using (SqlDataReader dataReader = sqlCommand.ExecuteReader())
                       {
                           // Create a data table to hold the retrieved data.
                           DataTable dataTable = new DataTable();
   
                           // Load the data from SqlDataReader into the data table.
                           dataTable.Load(dataReader);
   
                           // Display the data from the data table in the data grid view.
                           this.dgvCustomerOrders.DataSource = dataTable;
   
                           // Close the SqlDataReader.
                           dataReader.Close();
                       }
                   }
                   catch
                   {
                       MessageBox.Show("The requested order could not be loaded into the form.");
                   }
                   finally
                   {
                       // Close the connection.
                       connection.Close();
                   }
               }
           }
       }
   }
   
   /// <summary>
   /// Cancels an order by calling the Sales.uspCancelOrder
   /// stored procedure on the database.
   /// </summary>
   private void btnCancelOrder_Click(object sender, EventArgs e)
   {
       if (IsOrderIDValid())
       {
           // Create the connection.
           using (SqlConnection connection = new SqlConnection(Properties.Settings.Default.connString))
           {
               // Create the SqlCommand object and identify it as a stored procedure.
               using (SqlCommand sqlCommand = new SqlCommand("Sales.uspCancelOrder", connection))
               {
                   sqlCommand.CommandType = CommandType.StoredProcedure;
   
                   // Add the order ID input parameter for the stored procedure.
                   sqlCommand.Parameters.Add(new SqlParameter("@orderID", SqlDbType.Int));
                   sqlCommand.Parameters["@orderID"].Value = parsedOrderID;
   
                   try
                   {
                       // Open the connection.
                       connection.Open();
   
                       // Run the command to execute the stored procedure.
                       sqlCommand.ExecuteNonQuery();
                   }
                   catch
                   {
                       MessageBox.Show("The cancel operation was not completed.");
                   }
                   finally
                   {
                       // Close connection.
                       connection.Close();
                   }
               }
           }
       }
   }
   
   /// <summary>
   /// Fills an order by calling the Sales.uspFillOrder stored
   /// procedure on the database.
   /// </summary>
   private void btnFillOrder_Click(object sender, EventArgs e)
   {
       if (IsOrderIDValid())
       {
           // Create the connection.
           using (SqlConnection connection = new SqlConnection(Properties.Settings.Default.connString))
           {
               // Create command and identify it as a stored procedure.
               using (SqlCommand sqlCommand = new SqlCommand("Sales.uspFillOrder", connection))
               {
                   sqlCommand.CommandType = CommandType.StoredProcedure;
   
                   // Add the order ID input parameter for the stored procedure.
                   sqlCommand.Parameters.Add(new SqlParameter("@orderID", SqlDbType.Int));
                   sqlCommand.Parameters["@orderID"].Value = parsedOrderID;
   
                   // Add the filled date input parameter for the stored procedure.
                   sqlCommand.Parameters.Add(new SqlParameter("@FilledDate", SqlDbType.DateTime, 8));
                   sqlCommand.Parameters["@FilledDate"].Value = dtpFillDate.Value;
   
                   try
                   {
                       connection.Open();
   
                       // Execute the stored procedure.
                       sqlCommand.ExecuteNonQuery();
                   }
                   catch
                   {
                       MessageBox.Show("The fill operation was not completed.");
                   }
                   finally
                   {
                       // Close the connection.
                       connection.Close();
                   }
               }
           }
       }
   }
   
   /// <summary>
   /// 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 o esperado.

Para verificar se o banco de dados está atualizado com suas alterações:

1. Abra o nó Tabelas no Explorador de Servidores.

2. Clique com o botão direito do mouse nos nós Clientes e Pedidos e escolha Mostrar Dados da Tabela.

Conteúdo relacionado

• Ferramentas de dados do Visual Studio para .NET