Dela via

Skapa ett grundläggande dataprogram med hjälp av ADO.NET

Note

Klassen DataSet och relaterade klasser är äldre .NET Framework-tekniker från början av 2000-talet som gör det möjligt för program att arbeta med data i minnet medan apparna kopplas från databasen. Teknikerna är särskilt användbara för appar som gör det möjligt för användare att ändra data och spara ändringarna tillbaka till databasen. Även om datauppsättningar är en bevisad framgångsrik teknik är den rekommenderade metoden för nya .NET-program att använda Entity Framework Core. Entity Framework är ett mer naturligt sätt att arbeta med tabelldata som objektmodeller och har ett enklare programmeringsgränssnitt.

När du skapar ett program som manipulerar data i en databas utför du vanligtvis uppgifter som att definiera anslutningssträngar, infoga data och köra lagrade procedurer. När du följer den här artikeln kan du se hur du interagerar med en databas inifrån ett formulär över data (FOD) Windows Forms-program med hjälp av Visual C# eller Visual Basic och ADO.NET. Alla .NET-datatekniker, inklusive datauppsättningar, LINQ (Language-Integrated Query) till SQL och Entity Framework, utför slutligen steg som liknar de steg som visas i den här artikeln.

Den här artikeln visar hur du snabbt kan hämta data från en databas. Om ditt program behöver ändra data på icke-försöksmässiga sätt och uppdatera databasen bör du överväga att använda Entity Framework och databindning. På så sätt kan dina användargränssnittskontroller automatiskt synkroniseras med ändringar i underliggande data.

Information om hur du kommer åt den fullständiga koden för den här självstudien finns i GitHub-lagringsplatsen för Visual Studio-dokument för C# och Visual Basic.

Important

För att hålla koden enkel inkluderar den inte produktionsklar undantagshantering.

Prerequisites

  • Visual Studio med .NET-skrivbordsutveckling och datalagring och bearbetning arbetslaster installerade. Om du vill installera dem öppnar du Visual Studio Installer och väljer Ändra bredvid den version av Visual Studio som du vill ändra.

  • SQL Server Express LocalDB. Om du inte har SQL Server Express LocalDB kan du installera det från SQL Server-nedladdningssidan.

Den här artikeln förutsätter att du är bekant med de grundläggande funktionerna i Visual Studio IDE. Det förutsätter också att du kan skapa ett Windows Forms-program, lägga till formulär i ett projekt, lägga till knappar och andra kontroller i formulären, ange kontrollegenskaper och koda enkla händelser. Om du inte är nöjd med de här uppgifterna slutför du självstudien Skapa en Windows Forms-app i Visual Studio med C# eller självstudien Skapa en Windows Forms-app i Visual Studio med Visual Basic innan du påbörjar den här genomgången.

Konfigurera exempeldatabasen

Skapa exempeldatabasen genom att följa dessa steg:

  1. Öppna fönstret Server Explorer i Visual Studio.

  2. Högerklicka på Dataanslutningar och välj Skapa ny SQL Server-databas.

  3. Som Servernamn anger du (localdb)\mssqllocaldb.

  4. För Nytt databasnamn anger du Försäljning och väljer sedan OK.

    Visual Studio skapar en tom försäljningsdatabas under noden Dataanslutningar i Server Explorer.

  5. Högerklicka på dataanslutningen Försäljning och välj Ny fråga.

    Ett frågeredigerarefönster öppnas.

  6. Kopiera skriptet Sales Transact-SQL till urklipp.

  7. Klistra in T-SQL-skriptet i frågeredigerarens fönster och välj sedan Kör.

    Efter en kort tid slutförs frågan och databasobjekten skapas. Databasen innehåller två tabeller: Kund och Beställningar. Dessa tabeller innehåller inga data från början, men du kan lägga till data när du kör det program som du skapar. Databasen innehåller också fem grundläggande lagrade procedurer.

Skapa formulären och lägg till kontroller

  1. Skapa ett C#- eller Visual Basic-projekt med mallen Windows Forms App (.NET Framework) och ge det namnet SimpleDataApp.

    Visual Studio skapar projektet och flera filer, inklusive ett tomt Windows-formulär med namnet Form1.

  2. I Solution Explorer lägger du till två Windows-formulär i projektet så att det har totalt tre formulär och ger dem följande namn:

    • Navigation

    • NewCustomer

    • FillOrCancel

  3. För varje formulär lägger du till textrutor, knappar och andra kontroller som visas i följande illustrationer. För varje kontroll anger du de egenskaper som tabellerna beskriver.

    Note

    Grupprutan och etikettkontrollerna ger klarhet, men används inte i koden.

    Navigeringsformulär

    Skärmbild som visar information om navigeringsformuläret.

    Kontroller för navigeringsformuläret

    Kontrollera text Kontrolltyp Kontrollegenskaper
    Lägga till ett konto Button Namn = btnGoToAdd
    Fyll i eller avbryt en beställning Button Namn = btnGoToFillOrCancel
    Exit Button Namn = btnExit

    Nykundformulär

    Skärmbild som visar formulärinformation för NewCustomer.

    Kontroller för formuläret NewCustomer

    Etikett/kontrolltext Kontrolltyp Kontrollegenskaper
    Kundnamn TextBox Namn = txtCustomerName
    Kund-ID TextBox Namn = txtCustomerID
    Skrivskyddad = True
    Skapa ett konto Button Namn = btnCreateAccount
    Orderbelopp NumericUpdown Namn = numOrderAmount
    DecimalPlaces = 0
    Maximalt = 5 000
    Orderdatum DateTimePicker Namn = dtpOrderDate
    Format = Kort
    Lägg order Button Namn = btnPlaceOrder
    Finish Button Namn = btnAddFinish
    Lägga till ett annat konto Button Namn = btnAddAnotherAccount

    FillOrCancel-formulär

    Skärmbild som visar information om FillOrCancel-formuläret.

    Kontroller för formuläret FillOrCancel

    Etikett/kontrolltext Kontrolltyp Kontrollegenskaper
    Ordernummer TextBox Namn = txtOrderID
    Hitta ordning Button Namn = btnFindByOrderID
    Om du fyller i en beställning... DateTimePicker Namn = dtpFillDate
    Format = Kort
    (None) DataGridView Namn = dgvCustomerOrders
    Skrivskyddad = True
    RowHeadersVisible = Falskt
    Avbryt beställning Button Namn = btnCancelOrder
    Orderhantering Button Namn = btnFillOrder
    Finish Button Namn = btnFinishUpdates

Lagra anslutningssträngen

När programmet försöker öppna en anslutning till databasen måste programmet ha åtkomst till anslutningssträngen. Om du vill undvika behovet av att ange strängen manuellt i varje formulär lagrar du strängen i filenApp.config i projektet. Skapa sedan en metod som returnerar strängen när metoden anropas från valfritt formulär i ditt program.

Så här hittar du anslutningssträngen:

  1. I Server Explorer högerklickar du på dataanslutningen Försäljning och väljer sedan Egenskaper.

  2. Hitta egenskapen Anslutningssträng och kopiera dess värde till urklipp.

Så här lagrar du anslutningssträngen i projektet:

  1. I Solution Explorer gör du något av följande steg, beroende på projekttypen:

    • För ett C#-projekt expanderar du noden Egenskaper under projektet och öppnar sedan filen Settings.settings .

    • För ett Visual Basic-projekt väljer du Visa alla filer, expanderar noden Mitt projekt och öppnar sedan filen Settings.settings .

  2. I kolumnen Namn anger du connString.

  3. I listan Typ väljer du (Anslutningssträng).

  4. I listan Omfång väljer du Applikation.

  5. I kolumnen Value anger du anslutningssträngen (utan några externa citattecken) och sparar sedan ändringarna.

    Skärmbild som visar data för anslutningssträngen i Settings.settings.

Caution

I ett riktigt program bör du lagra anslutningssträngen på ett säkert sätt, enligt beskrivningen i Anslutningssträngar och konfigurationsfiler. För bästa säkerhet använder du en autentiseringsmetod som inte förlitar sig på att lagra ett lösenord i anslutningssträngen. Till exempel Windows-autentisering för en lokal SQL Server-databas. Mer information finns i Spara och redigera anslutningssträngar.

Skriva koden för formulären

Det här avsnittet innehåller korta översikter över vad varje formulär gör. Den innehåller också den kod som definierar den underliggande logiken när du väljer en knapp i formuläret.

Navigeringsformuläret öppnas när du kör programmet och innehåller följande knappar:

  • Lägg till ett konto: Öppnar formuläret NewCustomer .

  • Fyll i eller avbryt beställningar: Öppnar formuläret FillOrCancel .

  • Avsluta: Stänger programmet.

Gör navigeringsformuläret till startformulär

För C#-projekt:

  1. Öppna Program.cs i Solution Explorer.

  2. Ändra raden Application.Run till: Application.Run(new Navigation());

För Visual Basic-projekt:

  1. Högerklicka på projektet i Solution Explorer och välj Egenskaper.

  2. I Projektdesignern väljer du fliken Program och sedan Navigering i listan Startobjekt .

Skapa automatiskt genererade händelsehanterare för navigeringsformuläret

Om du vill skapa tomma händelsehanterarmetoder dubbelklickar du på var och en av de tre knapparna i navigeringsformuläret. Om du dubbelklickar på en knapp läggs automatiskt genererad kod i kodfilen Designer, vilket gör att ett knappval kan generera en händelse.

Om du bestämmer dig för att kopiera och klistra in kod direkt i kodfilerna i stället för att använda dubbelklicksåtgärden i designern kontrollerar du att du ställer in händelsehanteraren på rätt metod:

  1. I fönstret Egenskaper i kodfilen för formuläret växlar du till fliken Händelser med hjälp av verktygsfältsknappen blixt.

  2. Sök efter egenskapen Klicka och kontrollera att dess värde är rätt händelsehanterarmetod.

Lägga till kod för logiken för navigeringsformulär

På kodsidan för navigeringsformuläret fyller du i metodkropparna för de tre knappvalshändelsehanterare som visas i följande kod.

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

NewCustomer-formulär

När du anger ett kundnamn och sedan väljer knappen Skapa konto skapar formuläret NewCustomer ett kundkonto och SQL Server returnerar ett IDENTITY-värde som det nya kund-ID:t. Du kan sedan göra en beställning för det nya kontot genom att ange ett belopp och ett orderdatum och välja knappen Placera beställning .

Skapa automatiskt genererade händelsehanterare för formuläret NewCustomer

Skapa en tom Click-händelsehanterare för varje knapp i formuläret NewCustomer genom att dubbelklicka på var och en av de fyra knapparna. Om du dubbelklickar på knapparna läggs även automatiskt genererad kod i kodfilen Designer som aktiverar ett knappval för att skapa en händelse.

Lägga till kod för newcustomer-formulärlogik

Följ dessa steg för att slutföra newcustomer-formulärlogik:

  1. Placera System.Data.SqlClient namnområdet i omfånget så att du inte behöver ange namnen på dess medlemmar fullständigt.

    using System.Data.SqlClient;

  1. Lägg till några variabler och hjälpmetoder i klassen.

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

  1. Slutför metodkropparna för de fyra knappvalshändelsehantarna.

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

FillOrCancel-formulär

Formuläret FillOrCancel kör en fråga för att returnera en order när du anger ett order-ID och väljer sedan knappen Sök order . Den returnerade raden visas i en skrivskyddad datamatris. Du kan markera beställningen som avbruten (X) om du väljer knappen Avbryt beställning , eller så kan du markera beställningen som fylld (F) om du väljer knappen Fyll i ordning . Om du väljer knappen Sök order igen visas den uppdaterade raden.

Skapa automatiskt genererade händelsehanterare för formuläret FillOrCancel

Skapa tomma klick-händelsehanterare för de fyra knapparna i formuläret FillOrCancel genom att dubbelklicka på knapparna. Om du dubbelklickar på knapparna läggs även automatiskt genererad kod i kodfilen Designer som aktiverar ett knappval för att skapa en händelse.

Lägga till kod för FillOrCancel-formulärlogik

Följ dessa steg för att slutföra FillOrCancel-formulärlogik.

  1. Ta med följande två namnområden i omfånget så att du inte helt behöver kvalificera namnen på deras medlemmar.

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

  1. Lägg till en variabel och hjälpmetod i klassen.

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

  1. Slutför metodkropparna för de fyra knappvalshändelsehantarna.

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

Testa ditt program

Kör programmet och försök att skapa några kunder och beställningar för att kontrollera att allt fungerar som förväntat.

Så här kontrollerar du att databasen har uppdaterats med dina ändringar:

  1. Öppna noden Tabeller i ServerUtforskaren.

  2. Högerklicka på noderna Kunder och Beställningar och välj Visa tabelldata.

Relaterat innehåll

  • Last updated on