Tworzenie prostej aplikacji do obsługi danych za pomocą pakietu ADO.NET

Podczas tworzenia aplikacji, która manipuluje danymi w bazie danych, wykonujesz podstawowe zadania, takie jak definiowanie parametry połączenia, wstawianie danych i uruchamianie procedur składowanych. Korzystając z tego tematu, możesz dowiedzieć się, jak wchodzić w interakcje z bazą danych z poziomu prostej aplikacji formularzy systemu Windows Forms za pośrednictwem danych przy użyciu języka Visual C# lub Visual Basic i ADO.NET. Wszystkie technologie danych platformy .NET — w tym zestawy danych, LINQ to SQL i Entity Framework — ostatecznie wykonują kroki bardzo podobne do tych przedstawionych w tym artykule.

W tym artykule przedstawiono prosty sposób szybkiego pobierania danych z bazy danych. Jeśli aplikacja musi modyfikować dane w sposób nietrywialny i aktualizować bazę danych, należy rozważyć użycie programu Entity Framework i użycie powiązania danych w celu automatycznego synchronizowania kontrolek interfejsu użytkownika ze zmianami w danych bazowych.

Wymagania wstępne

Aby utworzyć aplikację, potrzebne są następujące elementy:

• Program Visual Studio z zainstalowanymi obciążeniami tworzenia aplikacji klasycznych i przechowywania danych i przetwarzania danych. Aby je zainstalować, otwórz Instalator programu Visual Studio i wybierz pozycję Modyfikuj (lub Więcej>modyfikacji) obok wersji programu Visual Studio, którą chcesz zmodyfikować.

• SQL Server Express LocalDB. Jeśli nie masz bazy danych SQL Server Express LocalDB, możesz zainstalować ją ze strony pobierania programu SQL Server.

W tym temacie założono, że znasz podstawowe funkcje środowiska IDE programu Visual Studio i możesz tworzyć aplikację Windows Forms, dodawać formularze do projektu, umieszczać przyciski i inne kontrolki na formularzach, ustawiać właściwości kontrolek i kodować proste zdarzenia. Jeśli nie znasz tych zadań, zalecamy ukończenie samouczka Tworzenie aplikacji Windows Forms w programie Visual Studio przy użyciu języka Visual Basic lub samouczek Tworzenie aplikacji Windows Forms w programie Visual Studio z językiem C# przed rozpoczęciem tego przewodnika.

Konfigurowanie przykładowej bazy danych

Utwórz przykładową bazę danych, wykonując następujące kroki:

1. W programie Visual Studio otwórz okno Eksplorator serwera.

2. Kliknij prawym przyciskiem myszy pozycję Połączenie danych i wybierz polecenie Utwórz nową bazę danych programu SQL Server.

3. W polu tekstowym Nazwa serwera wprowadź wartość (localdb)\mssqllocaldb.

4. W polu tekstowym Nowa nazwa bazy danych wprowadź wartość Sales (Sprzedaż), a następnie wybierz przycisk OK.

   Pusta baza danych Sales jest tworzona i dodawana do węzła Data Połączenie ions w Eksploratorze serwera.

5. Kliknij prawym przyciskiem myszy połączenie danych Sales i wybierz pozycję Nowe zapytanie.

   Zostanie otwarte okno edytora zapytań.

6. Skopiuj skrypt Sales Transact-SQL do schowka.

7. Wklej skrypt języka T-SQL do edytora zapytań, a następnie wybierz przycisk Wykonaj .

   Po krótkim czasie zapytanie zakończy działanie i zostaną utworzone obiekty bazy danych. Baza danych zawiera dwie tabele: Customer (Klient) i Orders (Zamówienia). Te tabele nie zawierają początkowo żadnych danych, ale można dodawać dane podczas uruchamiania tworzonej aplikacji. Baza danych zawiera również cztery proste procedury składowane.

Tworzenie formularzy i dodawanie kontrolek

1. Utwórz projekt w języku C# lub Visual Basic przy użyciu szablonu aplikacji Windows Forms App (.NET Framework), a następnie nadaj mu nazwę SimpleDataApp.

   Program Visual Studio tworzy projekt i kilka plików, w tym pusty formularz systemu Windows o nazwie Form1.

2. Dodaj do projektu dwa formularze systemu Windows, aby miał trzy formularze, a następnie nadaj im następujące nazwy:

   • Nawigacja

   • NewCustomer

   • FillOrCancel

3. Dla każdego formularza dodaj pola tekstowe, przyciski i inne kontrolki, które są wyświetlane na poniższych ilustracjach. Dla każdej kontrolki ustaw właściwości opisane w tabelach.

   Uwaga

   Pole grupy i kontrolki etykiety dodają jasność, ale nie są używane w kodzie.

   Formularz nawigacji

   

Formularz NewCustomer

Formularz FillOrCancel

Przechowywanie parametry połączenia

Gdy aplikacja próbuje otworzyć połączenie z bazą danych, aplikacja musi mieć dostęp do parametry połączenia. Aby uniknąć ręcznego wprowadzania ciągu w każdym formularzu, zapisz ciąg w pliku App.config w projekcie i utwórz metodę zwracającą ciąg, gdy metoda jest wywoływana z dowolnego formularza w aplikacji.

Parametry połączenia można znaleźć, klikając prawym przyciskiem myszy połączenie danych Sales w Eksploratorze serwera i wybierając polecenie Właściwości. Znajdź właściwość Połączenie ionString, a następnie naciśnij klawisze Ctrl A, Ctrl++C, aby zaznaczyć i skopiować ciąg do schowka.

1. Jeśli używasz języka C#, w Eksplorator rozwiązań rozwiń węzeł Właściwości w projekcie, a następnie otwórz plik Ustawienia.settings. Jeśli używasz języka Visual Basic, w Eksplorator rozwiązań kliknij pozycję Pokaż wszystkie pliki, rozwiń węzeł Mój projekt, a następnie otwórz plik Ustawienia.settings.

2. W kolumnie Name (Nazwa) wprowadź .connString

3. Na liście Typ wybierz pozycję (ciąg Połączenie ion).

4. Na liście Zakres wybierz pozycję Aplikacja.

5. W kolumnie Wartość wprowadź parametry połączenia (bez cudzysłowów zewnętrznych), a następnie zapisz zmiany.

   

Pisanie kodu formularzy

Ta sekcja zawiera krótkie omówienie tego, co robi każdy formularz. Udostępnia również kod, który definiuje podstawową logikę po kliknięciu przycisku na formularzu.

Formularz nawigacji

Po uruchomieniu aplikacji zostanie otwarty formularz nawigacji. Przycisk Dodaj konto otwiera formularz NewCustomer. Przycisk Wypełnij lub anuluj zamówienia otwiera formularz FillOrCancel. Przycisk Zakończ zamyka aplikację.

Tworzenie formularza nawigacji jako formularza uruchamiania

Jeśli używasz języka C#, w Eksplorator rozwiązań otwórz Program.cs, a następnie zmień Application.Run wiersz na następujący:Application.Run(new Navigation());

Jeśli używasz języka Visual Basic, w Eksplorator rozwiązań otwórz okno Właściwości, wybierz kartę Aplikacja, a następnie wybierz pozycję SimpleDataApp.Navigation na liście Formularz uruchamiania.

Tworzenie automatycznie wygenerowanych programów obsługi zdarzeń

Kliknij dwukrotnie trzy przyciski w formularzu nawigacji, aby utworzyć puste metody obsługi zdarzeń. Dwukrotne kliknięcie przycisków powoduje również dodanie automatycznie wygenerowanego kodu w pliku kodu Projektant, który umożliwia kliknięcie przycisku w celu wywołania zdarzenia.

Dodawanie kodu dla logiki formularza nawigacji

Na stronie kodowej formularza nawigacji wypełnij elementy metody dla trzech procedur obsługi zdarzeń kliknięcia przycisku, jak pokazano w poniższym kodzie.

/// <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

Formularz NewCustomer

Po wprowadzeniu nazwy klienta, a następnie wybraniu przycisku Utwórz konto , formularz NewCustomer tworzy konto klienta, a program SQL Server zwraca wartość IDENTITY jako nowy identyfikator klienta. Następnie możesz złożyć zamówienie dla nowego konta, określając kwotę i datę zamówienia oraz wybierając przycisk Złożyć zamówienie .

Tworzenie automatycznie wygenerowanych programów obsługi zdarzeń

Utwórz pustą procedurę obsługi zdarzeń Click dla każdego przycisku w formularzu NewCustomer, klikając dwukrotnie każdy z czterech przycisków. Dwukrotne kliknięcie przycisków powoduje również dodanie automatycznie wygenerowanego kodu w pliku kodu Projektant, który umożliwia kliknięcie przycisku w celu wywołania zdarzenia.

Dodawanie kodu dla logiki formularza NewCustomer

Aby ukończyć logikę formularza NewCustomer, wykonaj następujące kroki.

1. System.Data.SqlClient Przełącz przestrzeń nazw do zakresu, aby nie trzeba było w pełni kwalifikować nazw jej członków.

   • C#
   • VB

   using System.Data.SqlClient;
   

2. Dodaj kilka zmiennych i metod pomocnika do klasy, jak pokazano w poniższym kodzie.

   • 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. Ukończ elementy metody dla czterech procedur obsługi zdarzeń kliknięcia przycisku, jak pokazano w poniższym kodzie.

   • 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();
   }
   

Formularz FillOrCancel

Formularz FillOrCancel uruchamia zapytanie, aby zwrócić zamówienie po wprowadzeniu identyfikatora zamówienia, a następnie kliknij przycisk Znajdź zamówienie . Zwrócony wiersz jest wyświetlany w siatce danych tylko do odczytu. Jeśli wybierzesz przycisk Anuluj zamówienie , możesz oznaczyć zamówienie jako anulowane (X) lub oznaczyć zamówienie jako wypełnione (F), jeśli wybierzesz przycisk Wypełnij zamówienie . Jeśli ponownie wybierzesz przycisk Znajdź kolejność , zostanie wyświetlony zaktualizowany wiersz.

Tworzenie automatycznie wygenerowanych programów obsługi zdarzeń

Utwórz puste programy obsługi zdarzeń Click dla czterech przycisków w formularzu FillOrCancel, klikając dwukrotnie przyciski. Dwukrotne kliknięcie przycisków powoduje również dodanie automatycznie wygenerowanego kodu w pliku kodu Projektant, który umożliwia kliknięcie przycisku w celu wywołania zdarzenia.

Dodawanie kodu dla logiki formularza FillOrCancel

Aby ukończyć logikę formularza FillOrCancel, wykonaj następujące kroki.

1. Przełącz następujące dwie przestrzenie nazw do zakresu, aby nie trzeba było w pełni kwalifikować nazw ich elementów członkowskich.

   • C#
   • VB

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

2. Dodaj zmienną i metodę pomocnika do klasy, jak pokazano w poniższym kodzie.

   • 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. Ukończ elementy metody dla czterech procedur obsługi zdarzeń kliknięcia przycisku, jak pokazano w poniższym kodzie.

   • 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();
   }
   

Testowanie aplikacji

Uruchom aplikację i spróbuj utworzyć kilku klientów i zamówienia, aby sprawdzić, czy wszystko działa zgodnie z oczekiwaniami. Aby sprawdzić, czy baza danych została zaktualizowana wraz ze zmianami, otwórz węzeł Tabele w Eksploratorze serwera, kliknij prawym przyciskiem myszy węzły Klienci i zamówienia , a następnie wybierz polecenie Pokaż dane tabeli.

Powiązana zawartość

• Narzędzia do obsługi danych programu Visual Studio dla platformy .NET