Procedura dettagliata: creazione di un'applicazione dati semplice mediante ADO.NET

Lo stato attivo di molte applicazioni sul recupero e la modifica dei dati archiviati in un database.L'attività come creare stringhe di connessione, connessione al database, eseguendo le istruzioni SQL, l'utilizzo di stored procedure, visualizzare i dati in un form può confondere i nuovi sviluppatori.In questo argomento viene illustrato come creare il c di applicazione e di utilizzo di Windows Form e un ADO.NET molto semplici per interagire con il database.

L'applicazione e il database vengono su semplificato per soffermarsi su codifica anziché operare istruzioni complessi JOIN e massa di controlli nei form.Per completare l'esempio, è necessario disporre di:

  • Visual Studio 2012

  • SQL Server 2012 Express LocalDB

Installare il database di esempio

Il database di esempio è costituito da due tabelle, i clienti e ordini.Le tabelle non contengono inizialmente dati, ma verranno aggiunti i dati quando si esegue l'applicazione.Il database dispone anche di cinque stored procedure semplice.Installare il piccolo database contiene uno script SQL che crea le tabelle, primario e chiavi esterne, vincoli e stored procedure.

Creare i form e aggiungere i controlli

In questa sezione, verrà creata una nuova soluzione in Visual Studio, verranno create tre form e verranno aggiunti i controlli dalla casella degli strumenti ai form.

  1. Scegliere File, Nuovo progetto.Nei modelli di c, scegliere Applicazione Windows Form.Specificare SmallDataApp nella casella di testo Nome.Scegliere OK.

  2. Salvare la soluzione.

  3. In Esplora soluzioni, scegliere Aggiungi, Windows Form dal menu di scelta rapida.Per impostazione predefinita, il file sarà denominato Form1.cs.Selezionare il file Form1.cs e scegliere Rinomina dal menu di scelta rapida.Specificare NewCustomer come nome.

    Nota di avvisoAttenzione

    Se viene chiesto se rinominare tutte le occorrenze di Form1.cs nella soluzione, risposta sì.

  4. Scegliere Progetto, Aggiungi Windows Form per creare un secondo form.Denominare il file FillOrCancel.

  5. Scegliere nuovamente Progetto, Aggiungi Windows Form e creare un terzo form.Denominare la navigazione del file.

Iniziamo con il form di NewCustomer, per creare nuovi account del cliente.L'utente un nome del cliente e selezionare il pulsante Crea account che esegue uspNewCustomer la stored procedure.Il numero di conto del cliente (CustomerID) è un valore di IDENTITY generato automaticamente da SQL Server e viene archiviato CustomerID nella colonna Cliente della tabella nel database.

Il form di NewCustomer può essere utilizzato per ordinare iniziale del cliente.Il valore CustomerID appena creato viene passato uspPlaceNewOrder alla stored procedure, con la data e la quantità ordine, quando l'utente sceglie il pulsante Esegui ordine.

In Esplora soluzioni, NewCustomer.cs selezionati e scegliere Apri nel menu di scelta rapida.

Di seguito sono i controlli da aggiungere al form e proprietà da impostare.I valori della posizione e la dimensione non devono essere precisi.Per salvare più tempo, è possibile ignorare assegnare i nomi ai controlli di groupbox e dell'etichetta.I nomi delle etichette sono forniti per chiarezza, ma non li si utilizza il codice.Per altri controlli, la proprietà del nome è fondamentale.

Controllo

Proprietà

GroupBox

Percorso: = 13 x, y = 13

Nome = GroupBox1

Dimensione: = 228 x, y = 90

Il testo = aggiunge il cliente

TextBox

Percorso: = 130 x, y = 50

Nome = txtCustomerID

In sola lettura = True

Dimensione: Width = 79, height = 20

Etichetta

Percorso: = 10 x, y = 53

Nome = lblCustomerID

Dimensione: Width = 117, height = 13

Numero ID cliente = di testo:

TextBox

Percorso: = 55 x, y = 20

Nome = txtCustomerName

Dimensione: Width = 254, height = 20

Etichetta

Percorso: = 10 x, y = 27

Nome = lblName

Dimensione: Width = 41, height = 13

Testo = nome

GroupBox

Percorso: = 13 x, y = 109

Nome = groupBox2

Dimensione: = 228 x, y =102

Il testo = creazione ordine

NumericUpdown

Percorso: = 91 x, y = 28

Massimo = 5000

Nome = numOrderAmount

Dimensione: Larghezza 99, height = 28

Etichetta

Percorso: = 10 x, y = 30

Nome = lblAmount

Dimensione: Width = 75, height = 13

Quantità di ordine = di testo:

DateTimePicker

Formato breve =

Percorso: = 91 x, y = 56

Nome = dtpOrderDate

Dimensione: Width = 94, height = 20

Etichetta

Percorso: = 10 x, y = 62

Nome = lblDate

Data dell'ordine = di testo

Button

Percorso: = 258 x, y = 188

Nome = btnPlaceOrder

Dimensione: Width = 93, height = 23

Ordine del posto = di testo

Button

Percorso: = 217 x, y = 249

Nome = btnAddAnotherCustomer

Il testo = aggiunge un altro cliente

errorProvider

Nessuno.

Trascinare il controllo da Casella degli strumenti nel form di NewCustomer.Gli eventi di convalida supporti di controllo errorProvider ma il controllo non viene visualizzato nel form.

Button

Percorso: = 52 x, y = 249

Nome = btnAddFinish

Dimensione: Width = 88, height = 23

= Di testo

Il form di FillOrCancel del riempimento e annullare gli ordini.L'utente immette un numero ordine nella casella di testo ID ordine e quindi selezionare il pulsante Trova ordine.Se l'ordine esiste, viene visualizzata nel controllo DataGridView nel form.

Per annullare l'ordine, l'utente sceglie il pulsante Annulla ordine.Questa azione modifica lo stato dell'ordine nella posizione X (annullata).

Per impostare l'ordine come soddisfatta, l'utente sceglie il pulsante Compila ordine.Questa azione modifica lo stato dell'ordine di f (riempito).

Di seguito sono i controlli da aggiungere al form di FillOrCancel e proprietà da impostare.

Controllo

Proprietà

Etichetta

Percorso: = 28 x, y = 91

Nome = lblFillDate

Dimensione: Width = 159, height = 13

Il testo = se il riempimento di un ordine, specifica la data soddisfatta:

DateTimePicker

Formato breve =

Percorso: = 193 x, y = 85

Nome = dtpFillDate

Dimensione: Width = 96, height = 20

DataGridView

Percorso: = 14 x, y = 128

Nome = dgvCustomerOrders

In sola lettura = True

RowHeaderVisible = False

Dimensione: Width = 355, height = 72

Button

Percorso: = 12 x, y = 240

Nome = btnCancelOrder

Dimensione: Width = 106, height = 23

Ordine di annullamento = di testo

Button

Percorso: = 124 x, y = 240

Nome = btnFillOrder

Dimensione: Width = 106, height = 23

Ordine di riempimento = di testo

Button

Percorso: = 286 x, y = 240

Nome = btnFinishUpdates

Dimensione: Width = 83, height = 23

= Di testo

Etichetta

Percorso: = 12 x, y = 32

Nome = lblOrderID

Dimensione: Width = 50, height = 13

Testo = ID ordine:

TextBox

Percorso: = 68 x, y = 29

Nome = txtOrderID

Dimensione: Width = 100, height = 20

Button

Percorso: = 193 x, y = 27

Nome = btnFindByOrderID

Dimensione: Width = 112, height = 23

Ordine di ricerca = di testo

Il form di navigazione è il primo form che l'utente vedere.Contiene etichetta che indica "cosa si desidera fare?" Il form contiene tre pulsanti: Add nuovo cliente, Compila o cancella ordinie Esci.I primi due pulsanti aprono i rispettivi form come finestra di dialogo.Il pulsante Esci chiude l'applicazione.

Di seguito sono i controlli da aggiungere al form di navigazione e proprietà da impostare.

Controllo

Proprietà

Etichetta

Percorso: = 38 x, y = 35

Nome = lblQuestion

Dimensione: Width = 163, height = 15

Testo = cosa si desidera fare?

Button

Percorso: = 61 x, y = 81

Nome = btnGoToAdd

Dimensione: Width = 140, height = 23

Il testo = aggiunge un nuovo cliente.

Button

Percorso: = 75 x, y = 127

Nome = btnGoToFillOrCancel

Dimensione: Width = 111, height = 23

Orers di testo = di riempimento o annulla

Button

Percorso: = 195 x, y = 221

Nome = btnExit

Dimensione: Width = 75, height = 23

Testo = uscita

Scrivere il codice

In questa sezione, verranno create il codice che interagisce con il database per i form di FillOrCancel e di NewCustomer.Verrà inoltre creato il codice che apre le due forme dal form di navigazione.

Per i form di FillOrCancel e di NewCustomer, sarà necessario eseguire due operazioni:

  • Aggiungere la direttiva utilizzando System.Data.SqlClient all'inizio dei due file vb.Senza questa direttiva, i riferimenti a SqlConnection e SqlCommand generano errori nella finestra Elenco errori.

  • Conoscere la stringa di connessione al database.È possibile trovare questo valore selezionando il database in Esplora oggetti di SQL Server o in Esplora server e verrà visualizzata la finestra Proprietà per il database

JJ969619.collapse_all(it-it,VS.110).gifNewCustomer.cs

Il groupbox Aggiungi cliente del form di NewCustomer utilizza una stored procedure Sale.uspNewCustomer, per aggiungere una nuova riga Sales.Customer alla tabella nel database.I risultati della stored procedure numero CustomerID come parametro di output.

  1. NewCustomer aperto in Finestra di progettazione moduli, selezionare il pulsante Crea account, aprire la finestra Proprietà e visualizzare l'elenco Eventi.Fare doppio clic sull'evento Fare clic sul pulsante per creare un gestore eventi Click vuoto.Scegliere Visualizza codice per visualizzare il gestore eventi in Editor del codice.Il codice dovrebbe risultare simile al seguente:

    private void btnCreateAccount_Click(object sender, EventArgs e)
    {
    
    }
    
  2. A questo punto verrà aggiunto il codice che verrà eseguito una stored procedure all'evento Click.La l'impostazione e l'esecuzione della stored procedure richiede questi passaggi:

  • Definire la connessione creando un oggetto di SqlConnection.Denominare i connett. la connessione.È necessario sostituire la stringa di connessione nel codice di esempio con la stringa di connessione per il database.Il simbolo @ che precede la stringa di connessione consente di non sia necessario utilizzare caratteri di escape per i caratteri barra rovesciata nel percorso.Il codice sarà simile a quello riportato di seguito:

    //define the connection
    SqlConnection conn = new SqlConnection(@"Data Source=(localdb)\Projects;Initial Catalog=MySampleUnitTestDB;Integrated Security=True");
    
  • Definire il comando ovvero l'oggetto di SqlCommand) che verrà eseguito e identificare il comando come stored procedure per l'utilizzo della proprietà di CommandType.Denominare il cmdNewCustomer dell'oggetto di SqlCommand.Specificare "Sales.uspNewCustomer" come la stored procedure da eseguire.Di seguito è riportato il codice.

    //create a SqlCommand object and identify it as a stored procedure
    SqlCommand cmdNewCustomer = new SqlCommand("Sales.uspNewCustomer", conn);
    cmdNewCustomer.CommandType = CommandType.StoredProcedure;
    
  • Aggiungere i parametri dalla stored procedure a cmdNewCustomer e specificare il tipo di dati SQL per ogni oggetto.La stored procedure contiene un parametro di input, un parametro di output e un valore restituito @@ERROR.Inoltre, individuare l'origine del valore per il parametro di input e la direzione del parametro di output e il valore restituito.Di seguito è riportato il codice.

    //add input parameter from the stored procedure and specify what to use as its value
    cmdNewCustomer.Parameters.Add(new SqlParameter("@CustomerName", SqlDbType.NVarChar, 40));
    cmdNewCustomer.Parameters["@CustomerName"].Value = txtCustomerName.Text;
    
    //add output parameter
    cmdNewCustomer.Parameters.Add(new SqlParameter("@CustomerID", SqlDbType.Int));
    cmdNewCustomer.Parameters["@CustomerID"].Direction = ParameterDirection.Output;
    
    //add parameter for stored procedure return value: @@error
    cmdNewCustomer.Parameters.Add("@@Error", SqlDbType.Int);
    cmdNewCustomer.Parameters["@@Error"].Direction = ParameterDirection.ReturnValue;
    

    [!NOTA]

    Il tipo di dati per @CustomerName è NVARCHAR con una lunghezza di 40 caratteri.Il tipo di dati per @CustomerID è INT, che non richiede le informazioni sulle dimensioni.

  • Successivamente, eseguire la stored procedure nella clausola di try di un blocco di try – catch -- finally.Il primo passaggio consiste in aprire la connessione.Quindi, poiché la stored procedure esegue un'istruzione UPDATE, anziché una query, si eseguirà la stored procedure chiamando il metodo di SqlCommand ExecuteNonQuery.

  • Un'altra sezione del form richiede il valore restituito come @CustomerID per creare un ordine, pertanto memorizzeremo tale valore in una variabile Integer, holdCustomerID.Per il vantaggio dell'utente, viene visualizzato il numero CustomerID in una casella di testo di sola lettura nel form.Per evitare alterare il valore intero in holdCustomerID, anche memorizzeremo il valore di una variabile di stringa, displayCustomerID.Queste due variabili definite come campi di classe, visualizzate nella dichiarazione di classe.

  • La clausola di catch il blocco di try – catch -- finally visualizzare una finestra di messaggio se si verifica un'eccezione.

  • Chiudiamo la connessione nella clausola di finally.Di seguito è riportato il codice per il blocco di try – catch –finally.

    try
    {
      //open the connection
        conn.Open();
    
      //execute the stored procedure specified in cmdNewCustomer
        cmdNewCustomer.ExecuteNonQuery();
    
      //The customer ID is an IDENTITY value generated by the database engine.  We want to display the value  
      //in a textbox as a string, but we also need to retain it as an int so we can pass it to another stored
      //procedure.  
        this.holdCustomerID = (int)cmdNewCustomer.Parameters["@CustomerID"].Value;
        this.displayCustomerID = Convert.ToString(holdCustomerID);
        txtCustomerID.Text = displayCustomerID;
    
    }
    catch (SqlException ex)
    {
      MessageBox.Show(ex.Message);
    }
    finally
    {
      //close the connection
        conn.Close();
    }
    

Eseguire il form per verificare la funzionalità che è stato finora.Verrà visualizzato un numero nella casella di testo in sola lettura ID cliente.Potrebbe risultare utile visualizzare i dati nella tabella Cliente nel database.

La sezione di groupbox ordine di creazione del form segue Sales.uspPlaceNewOrder la stored procedure per l'ordinamento.Creare un gestore eventi Click per il pulsante Esegui ordine, ovvero dove verrà aggiunto il codice.I passaggi sono simili a quelli nel gestore eventi che è stato appena codificato.

  1. Utilizzare SqlConnection definire la connessione.La stringa di connessione sarà identica per tutte le istruzioni di SqlConnection in questo esempio.

  2. Definire un oggetto di SqlCommand denominato cmdNewOrder e specificare Sales.uspPlaceNewOrder come la stored procedure.

  3. Aggiungere i parametri di input dalla stored procedure specifica il nome del parametro, lo SqlDbType e la lunghezza in base alle proprie esigenze.

  4. Individuare l'origine dei valori di parametro di input.

    [!NOTA]

    Il parametro del @CustomerID accetta il valore della variabile di holdCustomerID.Il controllo OrderDate è un DateTimePicker e l'importo del controllo è un controllo NumericUpDown.Si leggerà i valori per questi controlli dalla proprietà Value.Il controllo dello stato è una casella di testo.Si leggerà il valore di una casella di testo dalla proprietà Text.

  5. Eseguire lo SqlCommand in un blocco di try – catch -- finally.

    1. Aprire la connessione.

    2. Il valore di @RC è numero OrderID, che archiviamo nella variabile OrderID.Se il comando ha esito positivo, una finestra di messaggio informa l'utente che l'ordine è stato inviato.

    3. L'utente può fare clic sul pulsante Esegui ordine senza prima fare clic sul pulsante Crea account, in grado di creare un errore.La clausola di catch controlla CustomerID per verificare se un nuovo account è stato creato.Se non è, una finestra di messaggio richiesto all'utente di creare account prima di inserire un ordine.

    4. Chiudiamo la connessione nella clausola di finally.

Di seguito è riportato il codice per il gestore eventi clic sul pulsante Esegui ordine.

private void btnPlaceOrder_Click(object sender, EventArgs e)
{

  //define the connection
    SqlConnection conn = new SqlConnection(@"Data Source=(localdb)\Projects;Initial Catalog=MySampleUnitTestDB;Integrated Security=True");

    //create SqlCommand and identify it as a stored procedure
      SqlCommand cmdNewOrder = new SqlCommand("Sales.uspPlaceNewOrder", conn);
      cmdNewOrder.CommandType = CommandType.StoredProcedure;

    //add input parameters from the store procedure and specify what to use as their values
    //@CustomerID, which was an output parameter from uspNewCustomer
      cmdNewOrder.Parameters.Add(new SqlParameter("@CustomerID", SqlDbType.Int));
      cmdNewOrder.Parameters["@CustomerID"].Value = this.holdCustomerID;

    //@OrderDate
      cmdNewOrder.Parameters.Add(new SqlParameter("@OrderDate", SqlDbType.DateTime, 8));
      cmdNewOrder.Parameters["@OrderDate"].Value = dtpOrderDate.Value;

    //@Amount
      cmdNewOrder.Parameters.Add(new SqlParameter("@Amount", SqlDbType.Int));
      cmdNewOrder.Parameters["@Amount"].Value = numOrderAmount.Value;

    //@Status.  For a new order, the status is always O (open)
      cmdNewOrder.Parameters.Add(new SqlParameter("@Status", SqlDbType.Char, 1));
      cmdNewOrder.Parameters["@Status"].Value = "O";

    //add stored procedure return value, which is the OrderID
      cmdNewOrder.Parameters.Add(new SqlParameter("@RC", SqlDbType.Int));
      cmdNewOrder.Parameters["@RC"].Direction = ParameterDirection.ReturnValue;

      try
      {
        //open connection
          conn.Open();

          cmdNewOrder.ExecuteNonQuery();

          this.OrderID = (int)cmdNewOrder.Parameters["@RC"].Value;
          MessageBox.Show("Order number " + this.OrderID + " has been submitted.");
      }
      catch (Exception ex)
      {
        //Make sure new CustomerID exists before order is placed.
          string strCustomerID;
          strCustomerID = txtCustomerID.Text;
          if (strCustomerID == "")
          {
              MessageBox.Show("Please create the customer account before placing an order.");
          }
          else
          {
              MessageBox.Show(ex.Message);
          }

      }
      finally
      {
        conn.Close();
      }
}

Durante la verifica del form, si verificheranno errori che devono essere gestiti.Ad esempio, il nome cliente è necessario creare un account valido e l'importo di ordine viene richiesto di creare un ordine valido.È possibile utilizzare il errProvider per eseguire la convalida nella casella di testo Nome e il controllo numericupdown Importo ordine.

  1. Selezionare la casella di testo Nome e aprire la finestra Proprietà.Visualizzare l'elenco Eventi e fare doppio clic sull'evento Convalida in corso per creare un gestore eventi convalidante nel codice.

  2. In Editor del codice, aggiungere il codice riportato di seguito al gestore eventi convalidante.Il errorProvider convalidare l'input base a condizioni definite e viene visualizzata un'icona sul controllo quando la convalida non riesce.Un messaggio viene visualizzato.

    private void txtCustomerName_Validating(object sender, CancelEventArgs e)
    {
         //Make sure name has been entered.
          if (txtCustomerName.Text == "")
             errorProvider.SetError(txtCustomerName, "Name is required.");
          else
             errorProvider.SetError(txtCustomerName, "");            
    }
    
  3. Creare un gestore eventi convalidante per il controllo Importo ordine e digitare il codice riportato di seguito.

    private void numOrderAmount_Validating(object sender, CancelEventArgs e)
    {
        //Make sure order amount has been entered.
          if (numOrderAmount.Value == 0)
             errorProvider.SetError(numOrderAmount, "Amount is required.");
          else
             errorProvider.SetError(numOrderAmount, "");
    }
    
SuggerimentoSuggerimento

La convalida viene verificato quando si passa da un controllo a un altro.Il errorProvider è più efficace quando sono disponibili più controlli da passare a.È incluso in questi esempi di codice per illustrare come utilizzare il errorProvider.

Il pulsante Aggiungi un altro cliente chiama una funzione di ClearForm per cancellare l'input dal form in modo da poter aggiungere un altro cliente.Creare un gestore eventi Click per Aggiungi un altro cliente.Il gestore eventi e definizione di funzione da aggiungere all'applicazione vengono indicati di seguito.

private void btnAddAnotherCustomer_Click(object sender, EventArgs e)
{
    this.ClearForm();
}

private void ClearForm()
{
   txtCustomerName.Clear();
   txtCustomerID.Clear();
   dtpOrderDate.Value = DateTime.Now;          
   numOrderAmount.Value = 0;      
   this.holdCustomerID = 0;
   this.displayCustomerID = "";
   errorProvider.SetError(txtCustomerName, "");
}

Il pulsante Fine chiude il nuovo form del cliente.Creare un gestore eventi Click per il pulsante Fine e aggiungere il codice come illustrato di seguito.

private void btnAddFinish_Click(object sender, EventArgs e)
{
   this.Close();
}
SuggerimentoSuggerimento

Poiché il form di navigazione visualizzato il nuovo form cliente come finestra di dialogo, il metodo da chiuso il form e restituisce la finestra di navigazione, anziché chiudendo l'applicazione.

JJ969619.collapse_all(it-it,VS.110).gifFillOrCancel.cs

Il form di FillOrCancel viene utilizzato per contrassegnare gli ordini come pieno o annullato.Gli utenti accedono l'ordine specificando il numero della casella di testo ID ordine e facendo clic sul pulsante Trova ordine.ID cliente, l'ordine l'id, la data dell'ordine, ha riempito la data, stato dell'ordine e l'importo di ordine viene visualizzato in un controllo DataGridView nel form.L'utente sceglie il pulsante Annulla ordine per impostare l'ordine come (x) annullato e il pulsante Compila ordine per impostare l'ordine come riempito F).

Le contiene la casella di testo ID ordine di testi, ma OrderID la colonna del database è un Integer, ovvero input di testo deve essere convertito in un Integer.Inoltre, la casella di testo deve contenere input quando l'applicazione tenta di contrassegnare un ordine come pieno o annullato.Creare un metodo di CheckOrderID per gestire entrambi i casi.Di seguito è riportato il codice.

private void CheckOrderID()
{
   string strOrderID;
   strOrderID = txtOrderID.Text;
   if (strOrderID == "")
     {             
       MessageBox.Show("Please specify the OrderID.");               
     }
   else
     {
       holdLookupOrderID = Int32.Parse(strOrderID);
     }
}

Creare un gestore eventi Click per il pulsante Trova ordine.Potremo fare chiamate al gestore eventi il metodo di CheckOrderID.È ora fisseremo il valore della data riempito DateTimePicker, nel caso un valore immesso in precedenza sia ancora presente.

SqlConnection è quello non aver utilizzato prima.L'oggetto di SqlCommand, cmdOrderID, esegue un'istruzione Select di una stored procedure.L'istruzione SELECT dispone di un parametro, @OrderID.

La query viene eseguita in un blocco di try – catch – finally, ma in questo caso, verrà creato uno SqlDataReader eseguendo il metodo di SqlCommand ExecuteReader.Verrà creata una tabella dati per contenere i risultati, per caricare i dati dal reader nella tabella dati e visualizzare il contenuto della tabella dati nel controllo DataGridView.Quindi, chiuderemo il lettore.Inoltre chiuderemo la connessione nella clausola di finally.Di seguito è riportato il codice per il gestore eventi clic sul pulsante Trova ordine.

private void btnFindByOrderID_Click(object sender, EventArgs e)
{
    CheckOrderID();

      //clear controls
        this.dtpFillDate.Value = DateTime.Now;

      //create connection
        SqlConnection conn = new SqlConnection(@"Data Source=(localdb)\Projects;Initial Catalog=MySampleUnitTestDB;Integrated Security=True");

      //create the query string that has a parameter for OrderID
        string sql = "select * from Sales.Orders where OrderID = @OrderID";

      //create a SqlCommand
        SqlCommand cmdOrderID = new SqlCommand(sql, conn);

      //define the @OrderID parameter and its value
        cmdOrderID.Parameters.Add(new SqlParameter("@OrderID", SqlDbType.Int));
        cmdOrderID.Parameters["@OrderID"].Value = holdLookupOrderID;

    try
    {
     //open the connection
       conn.Open();

     //Execute the command by using  SqlDataReader
       SqlDataReader rdr = cmdOrderID.ExecuteReader();

     //create a data table to hold the returned data
       DataTable dataTable = new DataTable();

     //load the data from the SqlDataReader into the data table
       dataTable.Load(rdr);

     //display the data from the data table in the datagridview
       this.dgvCustomerOrders.DataSource = dataTable;

    //close the reader
      rdr.Close();

    }
    catch (Exception ex)
    {
      MessageBox.Show(ex.Message);
    }
    finally
    {
      conn.Close();
    }
}

Creare un gestore eventi Click per il pulsante Annulla ordine.Codificheremo il gestore eventi per chiamare il metodo di CheckOrderID.Quindi definiremo uno SqlConnection e un oggetto di SqlCommand (cmdCancelOrder), che eseguiranno la stored procedure Sales.uspCancelOrder.Di seguito è riportato il codice.

private void btnCancelOrder_Click(object sender, EventArgs e)
{
      CheckOrderID();

    //create connection
      SqlConnection conn = new SqlConnection(@"Data Source=(localdb)\Projects;Initial Catalog=MySampleUnitTestDB;Integrated Security=True");

    //create command and identify it as a stored procedure
      SqlCommand cmdCancelOrder = new SqlCommand("Sales.uspCancelOrder", conn);
      cmdCancelOrder.CommandType = CommandType.StoredProcedure;

    //add input parameter from the stored procedure
      cmdCancelOrder.Parameters.Add(new SqlParameter("@OrderID", SqlDbType.Int));
      cmdCancelOrder.Parameters["@OrderID"].Value = holdLookupOrderID;

  try
  {
    //open connection
      conn.Open();

    //execute the cmdCancelOrder command
     cmdCancelOrder.ExecuteNonQuery();
  }
  catch (Exception ex)
  {
      MessageBox.Show(ex.Message);
  }
  finally
  {
      conn.Close();
  }
}

Creare un gestore eventi Click per il pulsante Compila ordine.Il codice per il gestore eventi sarà simile al gestore eventi per il pulsante Annulla ordine.Questo codice esegue la stored procedure Sales.uspFillOrder di, che presenta due parametri.Di seguito è riportato il codice.

private void btnFillOrder_Click(object sender, EventArgs e)
{
      CheckOrderID();

    //create connection
      SqlConnection conn = new SqlConnection(@"Data Source=(localdb)\Projects;Initial Catalog=MySampleUnitTestDB;Integrated Security=True");

    //create command and identify it as a stored procedure
      SqlCommand cmdFillOrder = new SqlCommand("Sales.uspFillOrder", conn);
      cmdFillOrder.CommandType = CommandType.StoredProcedure;

    //add input parameter from the stored procedure
      cmdFillOrder.Parameters.Add(new SqlParameter("@OrderID", SqlDbType.Int));
      cmdFillOrder.Parameters["@OrderID"].Value = holdLookupOrderID;

      cmdFillOrder.Parameters.Add(new SqlParameter("@FilledDate", SqlDbType.DateTime, 8));
      cmdFillOrder.Parameters["@FilledDate"].Value = dtpFillDate.Value;

   try
   {
      //open connection
        conn.Open();

      //execute the cmdFillOrder command 
        cmdFillOrder.ExecuteNonQuery();
   }
   catch (Exception ex)
   {
        MessageBox.Show(ex.Message);
   }
   finally
   {
        conn.Close();
   }
}

Si noti che dopo avere scelto il pulsante Compila ordine o Annulla ordine, è possibile scegliere nuovamente il pulsante Trova ordine.Il valore aggiornato di stato verrà visualizzato il risultato.

Creare un gestore eventi Click per il pulsante Fine, che viene chiuso il form.Di seguito è riportato il codice.

private void btnFinishUpdates_Click(object sender, EventArgs e)
{
   this.Close();
}

Eseguire il form per verificare la funzionalità.Aprire Program.cs in Esplora soluzionie specificare FillOrCancel come form per l'esecuzione.Il codice dovrebbe risultare simile al seguente.

Application.Run(new FillOrCancel());

JJ969619.collapse_all(it-it,VS.110).gifNavigation.cs

Il form di navigazione è il punto di ingresso per l'applicazione e controlla l'accesso alle altre finestre.

  1. Aprire Program.cs in Esplora soluzionie specificare la navigazione come form per l'esecuzione.Il codice dovrebbe risultare simile al seguente.

    Application.Run(new Navigation());
    
  2. Creare un evento Click a ogni pulsante nel form di navigazione.

  3. Il codice eventi per il clic su un pulsante di GoToFill e di GoToAdd per aprire i rispettivi form come finestra di dialogo.

  4. Il codice del gestore eventi del pulsante di uscita per chiudere l'applicazione.

Di seguito è riportato il codice per il form.

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;

namespace SimpleDataApp
{
    public partial class Navigation : Form
    {
        public Navigation()
        {
            InitializeComponent();
        }

        private void btnGoToAdd_Click(object sender, EventArgs e)
        {
            Form frm = new NewCustomer();
            frm.Show();
        }
        private void btnGoToFillOrCancel_Click(object sender, EventArgs e)
        {
            Form frm = new FillOrCancel();
            frm.ShowDialog();
        }
        private void btnExit_Click(object sender, EventArgs e)
        {
            this.Close();
        }
    }
}

Dopo avere completato tutti e tre i queste forme, verificare l'intera applicazione.È possibile provare a creare più form per sperimentare ulteriori funzionalità.