Condividi tramite


Creare un'applicazione dati di base usando ADO.NET

Nota

La DataSet classe e le classi correlate sono tecnologie .NET Framework legacy dei primi anni '2000 che consentono alle applicazioni di lavorare con i dati in memoria mentre le app vengono disconnesse dal database. Le tecnologie sono particolarmente utili per le app che consentono agli utenti di modificare i dati e rendere persistenti le modifiche apportate al database. Sebbene i set di dati siano una tecnologia di successo comprovata, l'approccio consigliato per le nuove applicazioni .NET consiste nell'usare Entity Framework Core. Entity Framework offre un modo più naturale per usare i dati tabulari come modelli a oggetti e dispone di un'interfaccia di programmazione più semplice.

Quando si crea un'applicazione che modifica i dati in un database, in genere si eseguono attività come la definizione di stringhe di connessione, l'inserimento di dati e l'esecuzione di stored procedure. Seguendo questo articolo, è possibile scoprire come interagire con un database dall'interno di un'applicazione Windows Form basata su dati (FOD) usando Visual C# o Visual Basic e ADO.NET. Tutte le tecnologie dati .NET, inclusi i set di dati, LINQ (Language-Integrated Query) a SQL ed Entity Framework, e infine eseguono passaggi simili a quelli illustrati in questo articolo.

Questo articolo illustra come ottenere rapidamente i dati da un database. Se l'applicazione deve modificare i dati in modi non intermedi e aggiornare il database, è consigliabile usare Entity Framework e il data binding. In questo modo i controlli dell'interfaccia utente possono eseguire automaticamente la sincronizzazione con le modifiche nei dati sottostanti.

Per accedere al codice completo per questa esercitazione, vedere il repository GitHub della documentazione di Visual Studio per C# e Visual Basic.

Importante

Per semplificare il codice, non include la gestione delle eccezioni pronta per la produzione.

Prerequisiti

  • Visual Studio con sviluppo di applicazioni desktop .NET e l'archiviazione e l'elaborazione dei dati carichi di lavoro installati. Per installarli, aprire Il programma di installazione di Visual Studio e scegliere Modifica accanto alla versione di Visual Studio da modificare.

  • SQL Server Express LocalDB. Se SQL Server Express LocalDB non è disponibile, è possibile installarlo dalla pagina di download di SQL Server .

Questo articolo presuppone che si abbia familiarità con le funzionalità di base dell'IDE di Visual Studio. Si presuppone inoltre che sia possibile creare un'applicazione Windows Form, aggiungere moduli a un progetto, aggiungere pulsanti e altri controlli ai moduli, impostare le proprietà del controllo e codificare eventi semplici. Se non si ha familiarità con queste attività, completare l'esercitazione Creare un'app Windows Form in Visual Studio con C# o l'esercitazione Creare un'app Windows Form in Visual Studio con Visual Basic prima di iniziare questa procedura dettagliata.

Configurare il database di esempio

Creare il database di esempio seguendo questa procedura:

  1. In Visual Studio, aprire la finestra Esplora Server.

  2. Fare clic con il pulsante destro del mouse su Connessioni dati e scegliere Crea nuovo database di SQL Server.

  3. In Nome server immettere (localdb)\mssqllocaldb.

  4. In Nuovo nome database immettere Sales e quindi scegliere OK.

    Visual Studio crea un database Sales vuoto nel nodo Connessioni dati in Esplora server.

  5. Fare clic con il pulsante destro del mouse sulla connessione dati Sales e scegliere Nuova query.

    Verrà visualizzata una finestra dell'editor di query.

  6. Copia lo script Sales Transact-SQL negli Appunti.

  7. Incollare lo script T-SQL nella finestra dell'editor di query e quindi selezionare Esegui.

    Dopo un breve periodo di tempo, la query termina l'esecuzione e gli oggetti di database vengono creati. Il database contiene due tabelle: Customer e Orders. Queste tabelle non contengono inizialmente dati, ma è possibile aggiungere dati quando si esegue l'applicazione creata. Il database contiene anche cinque procedure memorizzate di base.

Creare i moduli e aggiungere controlli

  1. Creare un progetto C# o Visual Basic con il modello App Windows Forms (.NET Framework) e denominarlo SimpleDataApp.

    Visual Studio crea il progetto e diversi file, incluso un modulo Windows vuoto denominato Form1.

  2. In Esplora soluzioni aggiungere due Windows Form al progetto in modo che abbia un totale di tre moduli e assegnare i nomi seguenti:

    • Navigazione

    • NuovoCliente

    • FillOrCancel

  3. Per ogni modulo, aggiungere le caselle di testo, i pulsanti e altri controlli illustrati nelle illustrazioni seguenti. Per ogni controllo, impostare le proprietà descritte dalle tabelle.

    Nota

    La casella di gruppo e i controlli di etichetta aggiungono chiarezza, ma non sono utilizzati nel codice.

    modulo di navigazione

    Screenshot che mostra i dettagli del modulo di navigazione.

    Controlli per il modulo di spostamento

    Testo del controllo Tipo di controllo Proprietà del controllo
    Aggiungi un account Pulsante Name = btnGoToAdd
    Compilare o annullare un ordine Pulsante Name = btnGoToFillOrCancel
    Uscita Pulsante Name = btnExit

    modulo NuovoCliente

    Screenshot che mostra i dettagli del modulo NewCustomer.

    Controlli per il modulo NewCustomer

    Testo etichetta e controllo Tipo di controllo Proprietà del controllo
    Nome cliente Casella di testo Name = txtCustomerName
    ID cliente Casella di testo Name = txtCustomerID
    Sola lettura = Vero
    Creare un account Pulsante Name = btnCreateAccount
    Importo dell'ordine Selettore Numerico Name = numOrderAmount
    DecimalPlaces = 0
    Massimo = 5000
    Data ordine DateTimePicker Nome = dtpOrderDate
    Format = Short
    Effettuare l'ordine Pulsante Name = btnPlaceOrder
    Finire Pulsante Name = btnAddFinish
    Aggiungere un altro account Pulsante Name = btnAddAnotherAccount

    modulo CompilaOAnnulla

    Screenshot che mostra i dettagli del modulo FillOrCancel.

    Controlli per il modulo FillOrCancel

    Testo etichetta e controllo Tipo di controllo Proprietà del controllo
    ID ordine Casella di testo Name = txtOrderID
    Trova l'ordine Pulsante Name = btnCercaPerIDOrdine
    Se si effettua un ordine... DateTimePicker Name = dtpFillDate
    Format = Short
    (Nessuno) DataGridView Nome = dgvCustomerOrders
    Sola lettura = Vero
    RowHeadersVisible = False
    Annullare l'ordine Pulsante Name = btnCancelOrder
    Ordine di riempimento Pulsante Name = btnFillOrder
    Finire Pulsante Name = btnFinishUpdates

Archiviare la stringa di connessione

Quando l'applicazione tenta di aprire una connessione al database, l'applicazione deve avere accesso alla stringa di connessione. Per evitare la necessità di immettere manualmente la stringa in ogni modulo, archiviare la stringa nel file App.config nel progetto. Creare quindi un metodo che restituisca la stringa quando il metodo viene chiamato da qualsiasi modulo nell'applicazione.

Per trovare la stringa di connessione:

  1. In Esplora server fare clic con il pulsante destro del mouse sulla connessione dati Sales e quindi scegliere Proprietà.

  2. Individuare la proprietà Stringa di connessione e copiarne il valore della stringa negli Appunti.

Per archiviare la stringa di connessione nel progetto:

  1. In Esplora soluzioni eseguire una delle operazioni seguenti, a seconda del tipo di progetto:

    • Per un progetto C#, espandere il nodo Proprietà nel progetto e quindi aprire il file Settings.settings .

    • Per un progetto di Visual Basic, selezionare Mostra tutti i file, espandere il nodo Progetto personale e quindi aprire il file Settings.settings .

  2. Nella colonna Nome immettere connString.

  3. Nell'elenco Tipo selezionare (Stringa di connessione).

  4. Nell'elenco Ambito, selezionare Applicazione.

  5. Nella colonna valore immettere la stringa di connessione (senza virgolette esterne) e quindi salvare le modifiche.

    Screenshot che mostra i dati della stringa di connessione in Settings.settings.

Cautela

In un'applicazione reale è necessario archiviare la stringa di connessione in modo sicuro, come descritto in Stringhe di connessione e file di configurazione. Per una maggiore sicurezza, usare un metodo di autenticazione che non si basa sull'archiviazione di una password nella stringa di connessione. Ad esempio, Autenticazione di Windows per un database DI SQL Server locale. Per altre informazioni, vedere Salvare e modificare le stringhe di connessione.

Scrivere il codice per i moduli

Questa sezione contiene brevi panoramiche sulle operazioni di ogni modulo. Fornisce inoltre il codice che definisce la logica sottostante quando si seleziona un pulsante nel modulo.

Il modulo Di spostamento viene aperto quando si esegue l'applicazione e sono inclusi i pulsanti seguenti:

  • Aggiungi un account: apre il modulo NewCustomer .

  • Compilare o annullare gli ordini: apre il modulo FillOrCancel .

  • Exit: chiude l'applicazione.

Impostare il modulo di navigazione come modulo di avvio

Per i progetti C#:

  1. In Esplora soluzioni , apri Program.cs.

  2. Modificare la riga Application.Run in: Application.Run(new Navigation());

Per i progetti Visual Basic:

  1. In Esplora soluzioni fare clic con il pulsante destro del mouse sul progetto e scegliere Proprietà.

  2. In Progettazione progetti selezionare la scheda Applicazione e quindi selezionare Navigazione nell'elenco Oggetti di avvio .

Creare gestori eventi generati automaticamente per il modulo di spostamento

Per creare metodi del gestore eventi vuoti, fare doppio clic su ognuno dei tre pulsanti nel modulo di navigazione. Facendo doppio clic su un pulsante viene aggiunto il codice generato automaticamente nel file di codice della finestra di progettazione, che consente a una selezione di un pulsante di generare un evento.

Se si decide di copiare e incollare il codice direttamente nei file di codice anziché usare l'azione di doppio clic nella finestra di progettazione, assicurarsi di impostare il gestore eventi sul metodo corretto:

  1. Nella finestra Proprietà del file di codice per il modulo passare alla scheda Eventi usando il pulsante della barra degli strumenti del fulmine.

  2. Cercare la proprietà Click e verificare che il relativo valore sia il metodo corretto del gestore eventi.

Aggiungere codice per la logica del form di navigazione

Nella pagina del codice del modulo di navigazione, completare i corpi dei metodi per i tre gestori degli eventi di selezione dei pulsanti, come illustrato nel codice seguente.

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

Modulo NewCustomer

Quando si immette un nome cliente e quindi si seleziona il pulsante Crea account , il modulo NewCustomer crea un account cliente e SQL Server restituisce un valore IDENTITY come nuovo ID cliente. È quindi possibile effettuare un ordine per il nuovo account specificando un importo e una data dell'ordine e selezionando il pulsante Inserisci ordine .

Creare gestori eventi generati automaticamente per il modulo NewCustomer

Creare un gestore eventi Click vuoto per ogni pulsante nel modulo NewCustomer facendo doppio clic su ognuno dei quattro pulsanti. Facendo doppio clic sui pulsanti, viene aggiunto anche il codice generato automaticamente nel file di codice del Designer, che consente a un pulsante selezionato di generare un evento.

Aggiungere codice per la logica del modulo NewCustomer

Per completare la logica del modulo NewCustomer, seguire questa procedura:

  1. Porta lo spazio dei nomi System.Data.SqlClient nell'ambito in modo che non sia necessario qualificare completamente i nomi dei suoi membri.

    using System.Data.SqlClient;
    

  1. Aggiungere alcune variabili e metodi helper alla classe .

    // 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. Completare i corpi dei metodi per i quattro gestori di eventi button-select.

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

Modulo "FillOrCancel"

Il modulo FillOrCancel esegue una query per restituire un ordine quando si immette un ID ordine e quindi selezionare il pulsante Trova ordine . La riga restituita viene visualizzata in una griglia di dati di sola lettura. È possibile contrassegnare l'ordine come annullato (X) se si seleziona il pulsante Annulla ordine oppure è possibile contrassegnare l'ordine come riempito (F) se si seleziona il pulsante Riempi ordine . Se si seleziona di nuovo il pulsante Trova ordine , viene visualizzata la riga aggiornata.

Creare gestori eventi generati automaticamente per il modulo FillOrCancel

Creare gestori eventi Click vuoti per i quattro pulsanti sul modulo FillOrCancel facendo doppio clic sui pulsanti. Facendo doppio clic sui pulsanti viene aggiunto anche il codice generato automaticamente nel file di codice del Designer che consente al selezionamento di un pulsante di generare un evento.

Aggiungere codice per la logica del modulo FillOrCancel

Per completare la logica del modulo FillOrCancel, seguire questa procedura.

  1. Portare i seguenti due namespace nell'ambito così non è necessario completamente qualificare i nomi dei loro membri.

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

  1. Aggiungere una variabile e un metodo helper alla classe .

    // 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. Completare i corpi del metodo per i quattro gestori eventi button-select.

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

Testare l'applicazione

Eseguire l'applicazione e provare a creare alcuni clienti e ordini per verificare che tutto funzioni come previsto.

Per verificare che il database venga aggiornato con le modifiche apportate:

  1. Aprire il nodo Tabelle in Esplora server.

  2. Fare clic con il pulsante destro del mouse sui nodi Clienti e Ordini e scegliere Mostra dati tabella.