Sdílet prostřednictvím

Vytvoření základní datové aplikace pomocí ADO.NET

Note

Třídy DataSet a související třídy jsou starší technologie rozhraní .NET Framework z počátku 2000, které umožňují aplikacím pracovat s daty v paměti, zatímco aplikace jsou odpojeny od databáze. Tyto technologie jsou zvláště užitečné pro aplikace, které uživatelům umožňují upravovat data a uchovávat změny zpět do databáze. I když jsou datové sady ověřenou úspěšnou technologií, doporučeným přístupem pro nové aplikace .NET je použití Entity Framework Core. Entity Framework poskytuje přirozenější způsob práce s tabulkovými daty jako objektovými modely a má jednodušší programovací rozhraní.

Když vytvoříte aplikaci, která manipuluje s daty v databázi, obvykle provádíte úlohy, jako je definování připojovacích řetězců, vkládání dat a spouštění uložených procedur. Jak budete postupovat podle tohoto článku, můžete zjistit, jak interagovat s databází z formulářů přes data (FOD) aplikace Windows Forms pomocí jazyka Visual C# nebo Visual Basic a ADO.NET. Všechny datové technologie .NET, včetně datových sad, LINQ (Language-Integrated Query) do SQL a Entity Framework, nakonec provádějí kroky podobné krokům uvedeným v tomto článku.

Tento článek ukazuje, jak rychle získat data z databáze. Pokud vaše aplikace potřebuje upravit data netriviálními způsoby a aktualizovat databázi, zvažte použití entity Framework a datové vazby. Díky tomu se ovládací prvky uživatelského rozhraní automaticky synchronizují se změnami v podkladových datech.

Pokud chcete získat přístup k kompletnímu kódu pro tento kurz, podívejte se na úložiště GitHubu sady Visual Studio pro C# a Visual Basic.

Important

Aby byl kód jednoduchý, nezahrnuje zpracování výjimek připravené pro produkční prostředí.

Prerequisites

  • Visual Studio s nainstalovanými úlohami vývoje desktopových aplikací .NET a ukládání a zpracování dat. Pokud je chcete nainstalovat, otevřete Instalační program sady Visual Studio a zvolte Upravit vedle verze sady Visual Studio, kterou chcete upravit.

  • SQL Server Express LocalDB. Pokud nemáte SQL Server Express LocalDB, můžete jej nainstalovat ze stránky pro stažení SQL Serveru .

Tento článek předpokládá, že znáte základní funkce integrovaného vývojového prostředí sady Visual Studio. Předpokládá se také, že můžete vytvořit aplikaci Windows Forms, přidat formuláře do projektu, přidat tlačítka a další ovládací prvky do formulářů, nastavit vlastnosti ovládacího prvku a jednoduché události kódu. Pokud s těmito úlohami nejste obeznámeni, před zahájením tohoto návodu dokončete kurz Vytvoření aplikace Windows Forms v sadě Visual Studio pomocí jazyka C# nebo Vytvoření aplikace Windows Forms v sadě Visual Studio pomocí visual basicu .

Nastavení ukázkové databáze

Ukázkovou databázi vytvořte následujícím postupem:

  1. V aplikaci Visual Studio otevřete okno Průzkumníka serveru.

  2. Klikněte pravým tlačítkem myši na Datová připojení a zvolte Vytvořit novou databázi SQL Serveru.

  3. Jako název serveru zadejte (localdb)\mssqllocaldb.

  4. Jako název nové databáze zadejte Sales a pak zvolte OK.

    Visual Studio vytvoří prázdnou databázi Sales v uzlu Datová připojení v Průzkumníku serveru.

  5. Klikněte pravým tlačítkem myši na datové připojení Sales (Prodej ) a vyberte New Query (Nový dotaz).

    Otevře se okno editoru dotazů.

  6. Zkopírujte skript Sales Transact-SQL do schránky.

  7. Vložte skript T-SQL do okna editoru dotazů a pak vyberte Spustit.

    Po krátké době se dotaz dokončí a vytvoří se databázové objekty. Databáze obsahuje dvě tabulky: Customer (Zákazník) a Orders (Objednávky). Tyto tabulky zpočátku neobsahují žádná data, ale data můžete přidat při spuštění aplikace, kterou vytvoříte. Databáze obsahuje také pět základních uložených procedur.

Vytvoření formulářů a přidání ovládacích prvků

  1. Vytvořte projekt jazyka C# nebo Visual Basic pomocí šablony aplikace Windows Forms (.NET Framework) a pojmenujte ho SimpleDataApp.

    Visual Studio vytvoří projekt a několik souborů, včetně prázdného formuláře Windows s názvem Form1.

  2. V Průzkumníku řešení přidejte do projektu dvě formuláře Windows, aby měly celkem tři formuláře, a pojmenujte je takto:

    • Navigation

    • NewCustomer

    • FillOrCancel

  3. Pro každý formulář přidejte textová pole, tlačítka a další ovládací prvky zobrazené na následujících ilustracích. Pro každý ovládací prvek nastavte vlastnosti, které tabulky popisují.

    Note

    Pole skupiny a ovládací prvky popisku přidávají přehlednost, ale nepoužívají se v kódu.

    Navigační formulář

    Snímek obrazovky znázorňující podrobnosti navigačního formuláře

    Ovládací prvky pro navigační formulář

    Ovládací text Typ ovládacího prvku Vlastnosti ovládacího prvku
    Přidání účtu Button Name = btnGoToAdd
    Vyplnění nebo zrušení objednávky Button Name = btnGoToFillOrCancel
    Exit Button Name = btnExit

    formulář NovýZákazník

    Snímek obrazovky znázorňující podrobnosti formuláře NewCustomer

    Ovládací prvky formuláře NewCustomer

    Text popisku/ovládacího prvku Typ ovládacího prvku Vlastnosti ovládacího prvku
    Jméno zákazníka TextBox Jméno = txtCustomerName
    ID zákazníka TextBox Název = txtCustomerID
    ReadOnly = Pravda
    Vytvoření účtu Button Name = btnVytvořitÚčet
    Částka objednávky NumericUpdown Name = čísloObjednávkovéMnožství
    Počet desetinných míst = 0
    Maximum = 5000
    Datum objednávky DateTimePicker Name = dtpOrderDate
    Formát = Krátký
    Odeslat objednávku Button Name = btnPlaceOrder
    Finish Button Name = btnAddFinish
    Přidání dalšího účtu Button Name = btnAddAnotherAccount

    formulář VyplnitNeboZrušit

    Snímek obrazovky znázorňující podrobnosti formuláře FillOrCancel

    Ovládací prvky formuláře FillOrCancel

    Text popisku/ovládacího prvku Typ ovládacího prvku Vlastnosti ovládacího prvku
    ID objednávky TextBox Název = txtOrderID
    Najít objednávku Button Name = btnFindByOrderID
    Při vyplňování objednávky... DateTimePicker Name = dtpFillDate
    Formát = Krátký
    (None) DataGridView Name = dgvCustomerOrders
    ReadOnly = Pravda
    RowHeadersVisible = Nepravda
    Zrušit objednávku Button Name = btnZrušitObjednávku
    Vyplnit objednávku Button Name = btnFillOrder
    Finish Button Name = btnFinishUpdates

Ulož připojovací řetězec

Když se aplikace pokusí otevřít připojení k databázi, musí mít aplikace přístup k připojovacímu řetězci. Abyste nemuseli řetězec zadávat ručně do každého formuláře, uložte ho do souboruApp.config v projektu. Pak vytvořte metodu, která vrátí řetězec při zavolání metody z libovolného formuláře v aplikaci.

Vyhledání připojovacího řetězce:

  1. V Průzkumníku serveru klikněte pravým tlačítkem myši na datové připojení Sales a potom zvolte Vlastnosti.

  2. Najděte parametr Připojovací řetězec a zkopírujte jeho řetězcovou hodnotu do schránky.

Uložení připojovacího řetězce v projektu:

  1. V Průzkumníku řešení proveďte jeden z následujících kroků v závislosti na typu projektu:

    • V případě projektu jazyka C# rozbalte uzel Vlastnosti v projektu a otevřete soubor Settings.settings .

    • V případě projektu jazyka Visual Basic vyberte Zobrazit všechny soubory, rozbalte uzel Můj projekt a otevřete soubor Settings.settings .

  2. Do sloupce Název zadejte connString.

  3. V seznamu Typ vyberte (Připojovací řetězec).

  4. V seznamu Obor vyberte Aplikace.

  5. Do sloupce Hodnota zadejte připojovací řetězec (bez uvozovek) a uložte provedené změny.

    Snímek obrazovky znázorňující data připojovacího řetězce v Settings.settings

Caution

V reálné aplikaci byste měli připojovací řetězec bezpečně uložit, jak je popsáno v Připojovací řetězce a konfigurační soubory. Pro zajištění nejlepšího zabezpečení použijte metodu ověřování, která nespoléhá na ukládání hesla do připojovacího řetězce. Například ověřování systému Windows pro místní databázi SQL Serveru. Další informace najdete v tématu Uložení a úprava připojovacích řetězců.

Napsání kódu pro formuláře

Tato část obsahuje stručné přehledy toho, co jednotlivé formuláře dělá. Poskytuje také kód, který definuje základní logiku při výběru tlačítka ve formuláři.

Při spuštění aplikace se otevře navigační formulář a obsahuje následující tlačítka:

  • Přidat účet: Otevře formulář NewCustomer .

  • Vyplnit nebo zrušit objednávky: Otevře formulář FillOrCancel .

  • Konec: Zavře aplikaci.

Nastavení formuláře navigace jako spouštěcího formuláře

Pro projekty jazyka C#:

  1. V Průzkumníku řešení otevřete Program.cs.

  2. Změňte řádek Application.Run na: Application.Run(new Navigation());

Pro projekty Jazyka Visual Basic:

  1. V Průzkumníku řešení klikněte pravým tlačítkem myši na projekt a zvolte Vlastnosti.

  2. V Návrháři projektu vyberte kartu Aplikace a pak v seznamu spouštěné objekty vyberte Navigaci.

Vytvoření automaticky vygenerovaných obslužných rutin událostí pro navigační formulář

Pokud chcete vytvořit prázdné metody obslužné rutiny událostí, poklikejte na každé ze tří tlačítek na navigačním formuláři. Poklikáním na tlačítko přidáte automaticky vygenerovaný kód do souboru kódu Návrháře, který umožňuje výběru tlačítka vyvolat událost.

Pokud se rozhodnete kopírovat a vkládat kód přímo do souborů kódu namísto použití akce poklikání v návrháři, ujistěte se, že jste nastavili obslužnou rutinu události na správnou metodu:

  1. V okně Vlastnosti souboru kódu formuláře přepněte na kartu Události pomocí tlačítka panelu nástrojů blesku.

  2. Vyhledejte vlastnost Click a ověřte, že její hodnota je správná metoda obslužné rutiny události.

Přidání kódu pro logiku navigačního formuláře

Na stránce kódu navigačního formuláře doplňte těla metod pro tři obslužné rutiny událostí výběru tlačítek, jak je znázorněno v následujícím kódu.

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

Formulář NewCustomer

Když zadáte jméno zákazníka a pak vyberete tlačítko Vytvořit účet , formulář NewCustomer vytvoří účet zákazníka a SQL Server vrátí hodnotu IDENTITY jako nové ID zákazníka. Objednávku nového účtu pak můžete zadat zadáním částky a data objednávky a výběrem tlačítka Odeslat objednávku .

Vytvoření automaticky vygenerovaných obslužných rutin událostí pro formulář NewCustomer

Vytvořte prázdnou obslužnou rutinu události Click pro každé tlačítko ve formuláři NewCustomer dvojím kliknutím na každé ze čtyř tlačítek. Poklikáním na tlačítka přidáte do souboru kódu Návrháře také automaticky vygenerovaný kód, který umožňuje vybrat tlačítko pro vyvolání události.

Přidání kódu pro logiku formuláře NewCustomer

K dokončení logiky formuláře NewCustomer postupujte takto:

  1. Zahrňte jmenný prostor do rozsahu, abyste nemuseli plně kvalifikovat názvy jeho členů.

    using System.Data.SqlClient;

  1. Přidejte do třídy některé proměnné a pomocné metody.

    // 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. Dokončete těla metod pro čtyři obslužné rutiny událostí pro výběr tlačítka.

    /// <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ář FillOrCancel

Formulář FillOrCancel spustí dotaz, který vrátí objednávku při zadání ID objednávky a pak vybere tlačítko Najít objednávku . Vrácený řádek se zobrazí v datové mřížce jen pro čtení. Objednávku můžete označit jako zrušenou (X), pokud vyberete tlačítko Zrušit objednávku , nebo můžete objednávku označit jako vyplněnou (F), pokud vyberete tlačítko Vyplnit objednávku . Pokud znovu vyberete tlačítko Najít objednávku , zobrazí se aktualizovaný řádek.

Vytvoření automaticky vygenerovaných obslužných rutin událostí pro formulář FillOrCancel

Vytvořte prázdné obslužné rutiny události Click pro čtyři tlačítka ve formuláři FillOrCancel dvojitým kliknutím na tlačítka. Poklikáním na tlačítka přidáte do souboru kódu Návrháře také automaticky vygenerovaný kód, který umožňuje vybrat tlačítko pro vyvolání události.

Přidání kódu pro logiku formuláře FillOrCancel

Chcete-li dokončit logiku formuláře FillOrCancel, postupujte takto.

  1. Zahrňte následující dva obory názvů, takže nemusíte plně kvalifikovat jména jejich členů.

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

  1. Přidejte do třídy proměnnou a pomocnou metodu.

    // 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. Dokončete těla metod pro čtyři obslužné rutiny událostí pro výběr tlačítka.

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

Otestování aplikace

Spusťte aplikaci a zkuste vytvořit několik zákazníků a objednávek, abyste ověřili, že všechno funguje podle očekávání.

Ověření aktualizace databáze pomocí změn:

  1. Otevřete uzel Tabulky v Průzkumníku serveru.

  2. Klikněte pravým tlačítkem myši na uzly Zákazníci a Objednávky a zvolte Zobrazit data tabulky.

Související obsah

  • Last updated on