Lição 3 - The SqlCommand Object

[ÐλяkFeλя]

Lição 3 - The SqlCommand Object

Esta lição descreve o objeto SqlCommand e como usá-lo para
interagir com um banco de dados. Aqui estão os objectivos do presente
lição:

Saiba que um objeto é um comando.
Saiba como usar o método ExecuteReader a consulta de dados.
Saiba como usar o método ExecuteNonQuery para inserir e apagar
dados.
Saiba como usar o método ExecuteScalar para retornar um único
valor.

Introdução

Um objeto SqlCommand permite especificar que tipo de
interação que pretende executar com uma base de dados. Por exemplo,
você pode fazer selecionar, inserir, modificar e apagar comandos em linhas de
dados em um banco de dados tabela. SqlCommand O objeto pode ser usado para
apoio desembraiado cenários de gerenciamento de dados, mas neste
lição que vamos usar apenas o objeto SqlCommand sozinho. Uma tarde
lição sobre o SqlDataAdapter irá explicar como implementar um
aplicação que utiliza dados desconectado. Esta lição também
mostrar-lhe como obter um valor único a partir de uma base de dados, tais como
o número de registros em uma tabela.

Criar um objeto SqlCommand

Semelhante a outros objetos C #, você instanciar um objeto SqlCommand
através da nova instância declaração, como se segue:

SqlCommand cmd = new SqlCommand("select CategoryName from
Categories", conn);

A linha acima é típico para instantiating um objeto SqlCommand.
Demora uma string parâmetro que detém o comando que você quer
executar e uma referência a um objeto SqlConnection. SqlCommand
tem algumas sobrecargas, o que você verá nos exemplos deste
tutorial.

Busca de dados

Quando usar um comando SQL SELECT, você vai obter um conjunto de dados para
visualização. Para conseguir isso com um objeto SqlCommand, você teria que 
utilizar o método ExecuteReader, que retorna um SqlDataReader
objeto. Iremos discutir o SqlDataReader mas pra frente. O
exemplo abaixo mostra como usar o objeto SqlCommand para obter um
SqlDataReader objeto:


// 1. Instantiate a new command with a query and connection
SqlCommand cmd = new SqlCommand("select CategoryName from Categories", conn);

// 2. Call Execute reader to get query results
SqlDataReader rdr = cmd.ExecuteReader();

No exemplo acima, nós instanciamos um objeto SqlCommand, passando o comando string e conexão objeto para o construtor. Então, obtemos um objeto SqlDataReader chamando a ExecuteReader método do objeto SqlCommand, cmd.

Este código é parte do método de ReadData Lista 1, vanos Colocá-lo Todos Juntos posteriormente nesta lição.

Inserindo Dados

Para inserir dados em um banco de dados, utilize o método ExecuteNonQuery do objeto SqlCommand. O código a seguir mostra como inserir dados em uma tabela de dados:

// prepare command string
string insertString = @"
     insert into Categories
     (CategoryName, Description)
     values ('Miscellaneous', 'Whatever doesn''t fit elsewhere')";

// 1. Instantiate a new command with a query and connection
SqlCommand cmd = new SqlCommand(insertString, conn);

// 2. Call ExecuteNonQuery to send command
cmd.ExecuteNonQuery();

As SqlCommand instanciação é um pouco diferente do que você tenha visto antes, mas é basicamente o mesmo. Em vez de uma string literal como o primeiro parâmetro do construtor SqlCommand, estamos usando uma variável, insertString. O insertString variável é declarado um pouco acima do SqlCommand declaração.

Observe os dois apóstrofos ('') insertString no texto a palavra "doesn''t". Isto é como você escapar o apóstrofo para obter a seqüência coluna para preencher corretamente.

Outra observação a fazer sobre o comando é que inserir explicitamente especificadas as colunas categoryname e Descrição. Categorias A tabela tem uma chave primária campo nomeado CategoryID. Deixamos esta fora da lista porque o SQL Server irá adicionar este campo em si. tentando adicionar um valor a uma chave primária campo, tais como CategoryID, irá gerar uma exceção.

Para executar este comando, é simplesmente chamar o método ExecuteNonQuery sobre o SqlCommand exemplo, cmd.

Atualizar Dados

O ExecuteNonQuery método também é utilizado para atualizar os dados. O código a seguir mostra como atualizar dados:

// prepare command string
string updateString = @"
     update Categories
     set CategoryName = 'Other'
     where CategoryName = 'Miscellaneous'";

// 1. Instantiate a new command with command text only
SqlCommand cmd = new SqlCommand(updateString);

// 2. Set the Connection property
cmd.Connection = conn;

// 3. Call ExecuteNonQuery to send command
cmd.ExecuteNonQuery();

Novamente, nós pusemos o comando SQL em uma string variável, mas desta vez usamos um outro construtor SqlCommand que leva apenas o comando. Na etapa 2, vamos atribuir o objeto SqlConnection, conn, a propriedade Connection do objeto SqlCommand, cmd.

Isto poderia ter sido feito com o mesmo construtor utilizado para inserir o comando, com dois parâmetros. Ela demonstra que você pode mudar a ligação objeto atribuído a um comando, a qualquer momento.

O método ExecuteNonQuery comando executa a atualização.

Apagando Dados

Você também pode apagar os dados usando o método ExecuteNonQuery. O seguinte exemplo mostra como excluir um registro de um banco de dados com o método ExecuteNonQuery:

// prepare command string
string deleteString = @"
     delete from Categories
     where CategoryName = 'Other'";

// 1. Instantiate a new command
SqlCommand cmd = new SqlCommand();

// 2. Set the CommandText property
cmd.CommandText = deleteString;

// 3. Set the Connection property
cmd.Connection = conn;

// 4. Call ExecuteNonQuery to send command
cmd.ExecuteNonQuery();

Este exemplo utiliza o SqlCommand construtor sem parâmetros. Em vez disso, estabelece explicitamente a ligação CommandText e propriedades do objeto SqlCommand, cmd.

Poderíamos ter usado também uma das duas anteriores SqlCommand construtor sobrecargas, usada para inserir ou atualizar o comando, com o mesmo resultado. Isto demonstra que você pode mudar tanto o comando texto eo contexto objeto a qualquer momento.

O método ExecuteNonQuery chamada envia o comando para o banco de dados.

Como Único valores

Às vezes, tudo que você precisa de um banco de dados é um valor único, que poderia ser uma contagem, soma, média, ou outro valor agregado a partir de um conjunto de dados. Realizando um ExecuteReader e calcular o resultado do seu código não é a forma mais eficiente de fazer isso. A melhor opção é deixar o banco de dados executar o trabalho e retornar apenas o valor único que você precisa. O seguinte exemplo mostra como fazer isso com o método ExecuteScalar:

// 1. Instantiate a new command
SqlCommand cmd = new SqlCommand("select count(*) from Categories", conn);

// 2. Call ExecuteNonQuery to send command
int count = (int)cmd.ExecuteScalar();

A consulta no construtor SqlCommand obtiver a contagem de todos os registos da tabela Categories. Esta consulta irá devolver apenas um único valor. O método ExecuteScalar no passo 2 retorna este valor. Desde o tipo de retorno ExecuteScalar é do tipo objeto, usamos um operador cast para converter o valor para int.

Colocá-lo Todos Juntos

Por questões de simplicidade, que mostrou fragmentos de código nas secções anteriores para demonstrar as técnicas aplicáveis. É também útil ter um código inteiro lista para ver como este código é usado em um programa de trabalho. Listagem 1 mostra todo o código usado neste exemplo, junto com um "motorista" no principal método para produzir resultado formatado.

Listagem 1 - SqlConnection Demo

Code Select Expand

using System;
using System.Data;
using System.Data.SqlClient;

/// <summary>
/// Demonstrates how to work with SqlCommand objects
/// </summary>
class SqlCommandDemo
{
     SqlConnection conn;

     public SqlCommandDemo()
     {
         // Instantiate the connection
         conn = new SqlConnection(
            "Data Source=(local);Initial Catalog=Northwind;Integrated Security=SSPI");
     }

     // call methods that demo SqlCommand capabilities
     static void Main()
     {
         SqlCommandDemo scd = new SqlCommandDemo();

         Console.WriteLine();
         Console.WriteLine("Categories Before Insert");
         Console.WriteLine("------------------------");

         // use ExecuteReader method
         scd.ReadData();

         // use ExecuteNonQuery method for Insert
         scd.Insertdata();
         Console.WriteLine();
         Console.WriteLine("Categories After Insert");
         Console.WriteLine("------------------------------");

        scd.ReadData();

         // use ExecuteNonQuery method for Update
         scd.UpdateData();

         Console.WriteLine();
         Console.WriteLine("Categories After Update");
         Console.WriteLine("------------------------------");

         scd.ReadData();

         // use ExecuteNonQuery method for Delete
         scd.DeleteData();

         Console.WriteLine();
         Console.WriteLine("Categories After Delete");
         Console.WriteLine("------------------------------");

         scd.ReadData();

         // use ExecuteScalar method
         int numberOfRecords = scd.GetNumberOfRecords();

         Console.WriteLine();
         Console.WriteLine("Number of Records: {0}", numberOfRecords);
     }

     /// <summary>
     /// use ExecuteReader method
     /// </summary>
     public void ReadData()
     {
        SqlDataReader rdr = null;

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

             // 1. Instantiate a new command with a query and connection
             SqlCommand cmd = new SqlCommand("select CategoryName from Categories", conn);

             // 2. Call Execute reader to get query results
             rdr = cmd.ExecuteReader();

             // print the CategoryName of each record
             while (rdr.Read())
             {
                 Console.WriteLine(rdr[0]);
             }
         }
         finally
         {
             // close the reader
             if (rdr != null)
             {
                 rdr.Close();
             }

             // Close the connection
             if (conn != null)
             {
                 conn.Close();
             }
         }
     }

     /// <summary>
     /// use ExecuteNonQuery method for Insert
     /// </summary>
     public void Insertdata()
     {
         try
         {
             // Open the connection
             conn.Open();

             // prepare command string
             string insertString = @"
                 insert into Categories
                 (CategoryName, Description)
                 values ('Miscellaneous', 'Whatever doesn''t fit elsewhere')";

             // 1. Instantiate a new command with a query and connection
             SqlCommand cmd = new SqlCommand(insertString, conn);

             // 2. Call ExecuteNonQuery to send command
             cmd.ExecuteNonQuery();
         }
         finally
         {
             // Close the connection
             if (conn != null)
             {
                 conn.Close();
             }
         }
     }

     /// <summary>
     /// use ExecuteNonQuery method for Update
     /// </summary>
     public void UpdateData()
     {
         try
         {
             // Open the connection
             conn.Open();

             // prepare command string
             string updateString = @"
                 update Categories
                 set CategoryName = 'Other'
                 where CategoryName = 'Miscellaneous'";

             // 1. Instantiate a new command with command text only
             SqlCommand cmd = new SqlCommand(updateString);

             // 2. Set the Connection property
             cmd.Connection = conn;

             // 3. Call ExecuteNonQuery to send command
             cmd.ExecuteNonQuery();
        }
         finally
         {
             // Close the connection
             if (conn != null)
             {
                 conn.Close();
             }
         }
     }

     /// <summary>
     /// use ExecuteNonQuery method for Delete
     /// </summary>
     public void DeleteData()
     {
         try
         {
             // Open the connection
             conn.Open();

             // prepare command string
             string deleteString = @"
                 delete from Categories
                 where CategoryName = 'Other'";

             // 1. Instantiate a new command
             SqlCommand cmd = new SqlCommand();

             // 2. Set the CommandText property
             cmd.CommandText = deleteString;

             // 3. Set the Connection property
             cmd.Connection = conn;

             // 4. Call ExecuteNonQuery to send command
             cmd.ExecuteNonQuery();
         }
         finally
         {
             // Close the connection
             if (conn != null)
             {
                 conn.Close();
             }
         }
     }

     /// <summary>
     /// use ExecuteScalar method
     /// </summary>
     /// <returns>number of records</returns>
     public int GetNumberOfRecords()
     {
         int count = -1;

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

             // 1. Instantiate a new command
             SqlCommand cmd = new SqlCommand("select count(*) from Categories", conn);

             // 2. Call ExecuteScalar to send command
             count = (int)cmd.ExecuteScalar();
         }
         finally
         {
            // Close the connection
             if (conn != null)
             {
                 conn.Close();
             }
         }
         return count;
     }
}

Na Listagem 1, o SqlConnection objeto é instanciado na SqlCommandDemo estrutura. Isso é certo, porque o próprio objeto será limpo quando o CLR lixo coletor executa. O que é importante é que fechar a ligação quando estamos a usá-lo feito. Este programa abre a conexão em um bloco try e fecha-lo em um último bloco de cada método.

O método ReadData exibe o conteúdo do categoryname coluna da tabela Categorias. Usamos lo várias vezes para o método principal para mostrar o estado atual da tabela Categorias, que muda depois de os inserir, atualizar e excluir comandos. Devido a isto, é conveniente para a reutilização de lhe mostrar os efeitos após cada método chamada.

Resumo

Um objeto SqlCommand lhe permite consultar e enviar comandos para uma base de dados. Tem métodos que são especializados para diferentes comandos. ExecuteReader O método retorna um objeto SqlDataReader para visualização dos resultados de uma consulta seleção. Para inserir, atualizar e excluir comandos SQL, você usa o método ExecuteNonQuery. Se você só precisa de um único valor agregado a partir de uma consulta, o ExecuteScalar é a melhor escolha.


CoNTiNUA Na ProxiMA....


By: FEAR




OBSERVAÇÃO: Há mais duas lições além dessa...