Tworzenie podstawowej aplikacji danych przy użyciu ADO.NET

Podczas tworzenia aplikacji, która manipuluje danymi w bazie danych, zazwyczaj wykonujesz zadania, takie jak definiowanie parametrów połączenia, wstawianie danych i uruchamianie procedur składowanych. Korzystając z tego artykułu, możesz dowiedzieć się, jak wchodzić w interakcję z bazą danych z poziomu aplikacji Windows Forms nad danymi (FOD) przy użyciu języka Visual C# lub Visual Basic oraz ADO.NET. Wszystkie technologie danych platformy .NET, w tym zestawy danych, LINQ (Language-Integrated Query) do języka SQL i platformy Entity Framework, ostatecznie wykonują kroki podobne do tych kroków przedstawionych w tym artykule.

W tym artykule pokazano, jak szybko pobierać dane z bazy danych. Jeśli aplikacja musi modyfikować dane w sposób nietrywialny i aktualizować bazę danych, rozważ użycie struktury Entity Framework i powiązania danych. Dzięki temu kontrolki interfejsu użytkownika mogą automatycznie synchronizować zmiany w danych bazowych.

Aby uzyskać dostęp do kompletnego kodu na potrzeby tego samouczka, zobacz repozytorium GitHub dokumentów programu Visual Studio dla języka C# i Visual Basic.

Prerequisites

• Program Visual Studio z zainstalowanymi tworzeniem aplikacji klasycznych platformy .NET oraz magazynem danych i przetwarzaniem obciążeń. Aby je zainstalować, otwórz Instalatora programu Visual Studio i wybierz pozycję Modyfikuj 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 artykule założono, że znasz podstawowe funkcje środowiska IDE programu Visual Studio. Przyjęto również założenie, że można utworzyć aplikację Windows Forms, dodać formularze do projektu, dodać przyciski i inne kontrolki do formularzy, ustawić właściwości kontrolki i kodować proste zdarzenia. Jeśli nie masz pewności co do tych zadań, przed rozpoczęciem pracy z tym samouczkiem ukończ samouczek Tworzenie aplikacji Windows Forms w programie Visual Studio w języku C# lub samouczek Tworzenie aplikacji Windows Forms w programie Visual Studio w języku Visual Basic .

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 Eksploratora serwera.

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

3. W polu Nazwa serwera wprowadź (localdb)\mssqllocaldb.

4. W polu Nowa nazwa bazy danych wprowadź Sales, a następnie wybierz OK.

   Program Visual Studio tworzy pustą bazę danych Sales w węźle Połączenia danych 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 w oknie edytora zapytań, a następnie wybierz pozycję 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ż pięć podstawowych procedur składowanych.

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) i nadaj mu nazwę SimpleDataApp.

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

2. W Eksploratorze rozwiązań dodaj do projektu dwa formularze systemu Windows, aby zawierało łącznie trzy formularze i nadaj im następujące nazwy:

   • Navigation

   • NewCustomer

   • FillOrCancel

3. Dla każdego formularza dodaj pola tekstowe, przyciski i inne kontrolki pokazane na poniższych ilustracjach. Dla każdej kontrolki ustaw właściwości opisane w tabelach.

   Note

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

   formularz nawigacji

   

   Kontrolki formularza nawigacji

   Tekst kontrolki	Typ kontrolki	Właściwości kontrolki
   Dodaj konto	Button	Nazwa = btnGoToAdd
   Wypełnianie lub anulowanie zamówienia	Button	Name = btnGoToFillOrCancel
   Exit	Button	Nazwa = btnExit

   formularz NowyKlient

   

   Kontrolki formularza NewCustomer

   Tekst etykiety/elementu sterującego	Typ kontrolki	Właściwości kontrolki
   Nazwa klienta	TextBox	Nazwa = txtCustomerName
   Identyfikator klienta	TextBox	Nazwa = txtCustomerID TylkoDoOdczytu = True
   Tworzenie konta	Button	Name = btnUtwórzKonto
   Kwota zamówienia	NumericUpdown	Nazwa = numOrderAmount Liczba miejsc dziesiętnych: 0 Maksimum = 5000
   Data zamówienia	DateTimePicker	Name = dtpOrderDate Format = krótki
   Złóż zamówienie	Button	Name = btnPlaceOrder
   Finish	Button	Nazwa = btnAddFinish
   Dodawanie innego konta	Button	Nazwa = btnAddAnotherAccount

   formularz FillOrCancel

   

   Kontrolki formularza FillOrCancel

   Tekst etykiety/elementu sterującego	Typ kontrolki	Właściwości kontrolki
   Identyfikator zamówienia	TextBox	Nazwa = txtOrderID
   Znajdź kolejność	Button	Name = btnFindByOrderID
   W przypadku realizacji zamówienia...	DateTimePicker	Nazwa = dtpFillDate Format = krótki
   (None)	DataGridView	Nazwa = dgvCustomerOrders TylkoDoOdczytu = True RowHeadersVisible = Fałsz
   Anulowanie zamówienia	Button	Name = btnAnulujZamówienie
   Realizacja zlecenia	Button	Name = btnFillOrder
   Finish	Button	Name = btnFinishUpdates

Przechowaj ciąg połączenia

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

Aby znaleźć parametry połączenia:

1. W Eksploratorze serwera kliknij prawym przyciskiem myszy połączenie danych Sprzedaż, a następnie wybierz Właściwości.

2. Znajdź właściwość Łańcuch połączenia i skopiuj jej wartość do schowka.

Aby zapisać parametry połączenia w projekcie:

1. W Eksploratorze rozwiązań wykonaj jedną z następujących czynności, w zależności od typu projektu:

   • W przypadku projektu w języku C# rozwiń węzeł Właściwości w projekcie, a następnie otwórz plik Settings.settings .

   • W przypadku projektu Visual Basic wybierz pozycję Pokaż wszystkie pliki, rozwiń węzeł Mój projekt , a następnie otwórz plik Settings.settings .

2. W kolumnie Nazwa wprowadź ciąg connString.

3. Na liście Typ wybierz pozycję (Parametry połączenia).

4. Na liście Zakres wybierz Application.

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ę podczas wybierania przycisku w formularzu.

Formularz nawigacji

Formularz nawigacji zostanie otwarty po uruchomieniu aplikacji i zawiera następujące przyciski:

• Dodaj konto: otwiera formularz NewCustomer .

• Wypełnij lub anuluj zamówienia: otwiera formularz FillOrCancel .

• Zakończ: zamyka aplikację.

Ustaw formularz nawigacyjny jako formularz startowy

W przypadku projektów w języku C#:

1. W Eksploratorze rozwiązań otwórz Program.cs.

2. Zmień wiersz Application.Run na Application.Run(new Navigation());.

W przypadku projektów Visual Basic:

1. W Eksploratorze rozwiązań kliknij prawym przyciskiem myszy projekt i wybierz polecenie Właściwości.

2. W projektancie projektów wybierz kartę Aplikacja , a następnie wybierz pozycję Nawigacja na liście Obiektów uruchamiania .

Tworzenie automatycznie wygenerowanych programów obsługi zdarzeń dla formularza nawigacji

Aby utworzyć puste metody obsługi zdarzeń, kliknij dwukrotnie każdy z trzech przycisków w formularzu nawigacji. Dwukrotne kliknięcie przycisku powoduje dodanie automatycznie wygenerowanego kodu w pliku kodu projektanta, co umożliwia wybranie przycisku w celu wywołania zdarzenia.

Jeśli zdecydujesz się skopiować i wkleić kod bezpośrednio do plików kodu zamiast akcji dwukrotnego kliknięcia w projektancie, upewnij się, że program obsługi zdarzeń został ustawiony na właściwą metodę:

1. W oknie Właściwości pliku kodu formularza przejdź do karty Zdarzenia, używając przycisku paska narzędzi z symbolem błyskawicy.

2. Wyszukaj właściwość Click i sprawdź, czy jej wartość jest prawidłową metodą obsługi zdarzeń.

Dodawanie kodu dla logiki formularza nawigacji

Na stronie kodowej formularza nawigacji wypełnij elementy metody dla trzech procedur obsługi zdarzeń wybierania przycisków, 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 NowyKlient

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, a następnie wybierając przycisk Złożyć zamówienie .

Tworzenie automatycznie wygenerowanych programów obsługi zdarzeń dla formularza NewCustomer

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

Dodawanie kodu dla logiki formularza NewCustomer

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

1. Ustaw przestrzeń nazw System.Data.SqlClient w zakresie, aby nie trzeba było w pełni określać nazw jej członków.

   • C#
   • VB

   using System.Data.SqlClient;
   

2. Dodaj kilka zmiennych i metod pomocnika do klasy.

   • 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 jednostki metod dla czterech procedur obsługi zdarzeń wybierania przycisków.

   • 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 WypełnijLubAnuluj

Formularz FillOrCancel uruchamia zapytanie, aby zwrócić zamówienie po wprowadzeniu identyfikatora zamówienia, a następnie wybierz przycisk Znajdź zamówienie . Zwrócony wiersz jest wyświetlany w tabeli 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ź zamówienie , zostanie wyświetlony zaktualizowany wiersz.

Tworzenie automatycznie wygenerowanych procedur obsługi zdarzeń dla formularza FillOrCancel

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

Dodawanie kodu dla logiki formularza FillOrCancel

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

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

   • C#
   • VB

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

2. Dodaj zmienną i metodę pomocnika do klasy.

   • 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 jednostki metod dla czterech procedur obsługi zdarzeń wybierania przycisków.

   • 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 o zmiany:

1. Otwórz węzeł Tabele w Eksploratorze serwera.

2. Kliknij prawym przyciskiem myszy węzły Klienci i Zamówienia , a następnie wybierz polecenie Pokaż dane tabeli.

Treści powiązane

• narzędzia danych programu Visual Studio dla platformy .NET