SqlCommand Classe

Definição

Representa uma instrução Transact-SQL ou procedimento armazenado para execução em um banco de dados SQL Server. Essa classe não pode ser herdada.

public ref class SqlCommand sealed : System::Data::Common::DbCommand, ICloneable
public ref class SqlCommand sealed : System::Data::Common::DbCommand
public ref class SqlCommand sealed : System::ComponentModel::Component, ICloneable, IDisposable, System::Data::IDbCommand
public ref class SqlCommand sealed : System::Data::Common::DbCommand, ICloneable, IDisposable
public sealed class SqlCommand : System.Data.Common.DbCommand, ICloneable
public sealed class SqlCommand : System.Data.Common.DbCommand
public sealed class SqlCommand : System.ComponentModel.Component, ICloneable, IDisposable, System.Data.IDbCommand
public sealed class SqlCommand : System.Data.Common.DbCommand, ICloneable, IDisposable
type SqlCommand = class
    inherit DbCommand
    interface ICloneable
type SqlCommand = class
    inherit DbCommand
type SqlCommand = class
    inherit Component
    interface IDbCommand
    interface IDisposable
    interface ICloneable
type SqlCommand = class
    inherit DbCommand
    interface IDbCommand
    interface ICloneable
    interface IDisposable
Public NotInheritable Class SqlCommand
Inherits DbCommand
Implements ICloneable
Public NotInheritable Class SqlCommand
Inherits DbCommand
Public NotInheritable Class SqlCommand
Inherits Component
Implements ICloneable, IDbCommand, IDisposable
Public NotInheritable Class SqlCommand
Inherits DbCommand
Implements ICloneable, IDisposable
Herança
SqlCommand
Herança
Herança
Implementações

Exemplos

O exemplo a seguir cria um SqlConnection, um SqlCommande um SqlDataReader. O exemplo lê os dados, gravando-os no console. Por fim, o exemplo fecha o SqlDataReader e, em seguida, o SqlConnection como ele sai dos Using blocos de código.

private static void ReadOrderData(string connectionString)
{
    string queryString =
        "SELECT OrderID, CustomerID FROM dbo.Orders;";
    using (SqlConnection connection = new SqlConnection(
               connectionString))
    {
        SqlCommand command = new SqlCommand(
            queryString, connection);
        connection.Open();
        using(SqlDataReader reader = command.ExecuteReader())
        {
            while (reader.Read())
            {
                Console.WriteLine(String.Format("{0}, {1}",
                    reader[0], reader[1]));
            }
        }
    }
}
Public Sub ReadOrderData(ByVal connectionString As String)
    Dim queryString As String = _
        "SELECT OrderID, CustomerID FROM dbo.Orders;"
    Using connection As New SqlConnection(connectionString)
        Dim command As New SqlCommand(queryString, connection)
        connection.Open()
        Dim reader As SqlDataReader = command.ExecuteReader()
        Try
            While reader.Read()
                Console.WriteLine(String.Format("{0}, {1}", _
                    reader(0), reader(1)))
            End While
        Finally
            ' Always call Close when done reading.
            reader.Close()
        End Try
    End Using
End Sub

O exemplo a seguir mostra como criar e executar diferentes tipos de objetos SqlCommand.

Primeiro, você deve criar o banco de dados de exemplo executando o seguinte script:

USE [master]  
GO  

CREATE DATABASE [MySchool]  
GO  

USE [MySchool]  
GO  

SET ANSI_NULLS ON  
GO  
SET QUOTED_IDENTIFIER ON  
GO  
CREATE procedure [dbo].[CourseExtInfo] @CourseId int  
as  
select c.CourseID,c.Title,c.Credits,d.Name as DepartmentName  
from Course as c left outer join Department as d on c.DepartmentID=d.DepartmentID  
where c.CourseID=@CourseId  

GO  

SET ANSI_NULLS ON  
GO  
SET QUOTED_IDENTIFIER ON  
GO  
create procedure [dbo].[DepartmentInfo] @DepartmentId int,@CourseCount int output  
as  
select @CourseCount=Count(c.CourseID)  
from course as c  
where c.DepartmentID=@DepartmentId  

select d.DepartmentID,d.Name,d.Budget,d.StartDate,d.Administrator  
from Department as d  
where d.DepartmentID=@DepartmentId  

GO  

SET ANSI_NULLS ON  
GO  
SET QUOTED_IDENTIFIER ON  
GO  
Create PROCEDURE [dbo].[GetDepartmentsOfSpecifiedYear]   
@Year int,@BudgetSum money output  
AS  
BEGIN  
        SELECT @BudgetSum=SUM([Budget])  
  FROM [MySchool].[dbo].[Department]  
  Where YEAR([StartDate])=@Year   

SELECT [DepartmentID]  
      ,[Name]  
      ,[Budget]  
      ,[StartDate]  
      ,[Administrator]  
  FROM [MySchool].[dbo].[Department]  
  Where YEAR([StartDate])=@Year  

END  
GO  

SET ANSI_NULLS ON  
GO  
SET QUOTED_IDENTIFIER ON  
GO  
CREATE TABLE [dbo].[Course]([CourseID] [nvarchar](10) NOT NULL,  
[Year] [smallint] NOT NULL,  
[Title] [nvarchar](100) NOT NULL,  
[Credits] [int] NOT NULL,  
[DepartmentID] [int] NOT NULL,  
 CONSTRAINT [PK_Course] PRIMARY KEY CLUSTERED   
(  
[CourseID] ASC,  
[Year] ASC  
)WITH (PAD_INDEX = OFF, STATISTICS_NORECOMPUTE = OFF, IGNORE_DUP_KEY = OFF, ALLOW_ROW_LOCKS = ON, ALLOW_PAGE_LOCKS = ON) ON [PRIMARY]) ON [PRIMARY]  

GO  

SET ANSI_NULLS ON  
GO  
SET QUOTED_IDENTIFIER ON  
GO  
CREATE TABLE [dbo].[Department]([DepartmentID] [int] IDENTITY(1,1) NOT NULL,  
[Name] [nvarchar](50) NOT NULL,  
[Budget] [money] NOT NULL,  
[StartDate] [datetime] NOT NULL,  
[Administrator] [int] NULL,  
 CONSTRAINT [PK_Department] PRIMARY KEY CLUSTERED   
(  
[DepartmentID] ASC  
)WITH (PAD_INDEX = OFF, STATISTICS_NORECOMPUTE = OFF, IGNORE_DUP_KEY = OFF, ALLOW_ROW_LOCKS = ON, ALLOW_PAGE_LOCKS = ON) ON [PRIMARY]) ON [PRIMARY]  

GO  

SET ANSI_NULLS ON  
GO  
SET QUOTED_IDENTIFIER ON  
GO  
CREATE TABLE [dbo].[Person]([PersonID] [int] IDENTITY(1,1) NOT NULL,  
[LastName] [nvarchar](50) NOT NULL,  
[FirstName] [nvarchar](50) NOT NULL,  
[HireDate] [datetime] NULL,  
[EnrollmentDate] [datetime] NULL,  
 CONSTRAINT [PK_School.Student] PRIMARY KEY CLUSTERED   
(  
[PersonID] ASC  
)WITH (PAD_INDEX = OFF, STATISTICS_NORECOMPUTE = OFF, IGNORE_DUP_KEY = OFF, ALLOW_ROW_LOCKS = ON, ALLOW_PAGE_LOCKS = ON) ON [PRIMARY]) ON [PRIMARY]  

GO  

SET ANSI_NULLS ON  
GO  
SET QUOTED_IDENTIFIER ON  
GO  
CREATE TABLE [dbo].[StudentGrade]([EnrollmentID] [int] IDENTITY(1,1) NOT NULL,  
[CourseID] [nvarchar](10) NOT NULL,  
[StudentID] [int] NOT NULL,  
[Grade] [decimal](3, 2) NOT NULL,  
 CONSTRAINT [PK_StudentGrade] PRIMARY KEY CLUSTERED   
(  
[EnrollmentID] ASC  
)WITH (PAD_INDEX = OFF, STATISTICS_NORECOMPUTE = OFF, IGNORE_DUP_KEY = OFF, ALLOW_ROW_LOCKS = ON, ALLOW_PAGE_LOCKS = ON) ON [PRIMARY]) ON [PRIMARY]  

GO  

SET ANSI_NULLS ON  
GO  
SET QUOTED_IDENTIFIER ON  
GO  
create view [dbo].[EnglishCourse]  
as  
select c.CourseID,c.Title,c.Credits,c.DepartmentID  
from Course as c join Department as d on c.DepartmentID=d.DepartmentID  
where d.Name=N'English'  

GO  
INSERT [dbo].[Course] ([CourseID], [Year], [Title], [Credits], [DepartmentID]) VALUES (N'C1045', 2012, N'Calculus', 4, 7)  
INSERT [dbo].[Course] ([CourseID], [Year], [Title], [Credits], [DepartmentID]) VALUES (N'C1061', 2012, N'Physics', 4, 1)  
INSERT [dbo].[Course] ([CourseID], [Year], [Title], [Credits], [DepartmentID]) VALUES (N'C2021', 2012, N'Composition', 3, 2)  
INSERT [dbo].[Course] ([CourseID], [Year], [Title], [Credits], [DepartmentID]) VALUES (N'C2042', 2012, N'Literature', 4, 2)  
SET IDENTITY_INSERT [dbo].[Department] ON   

INSERT [dbo].[Department] ([DepartmentID], [Name], [Budget], [StartDate], [Administrator]) VALUES (1, N'Engineering', 350000.0000, CAST(0x0000999C00000000 AS DateTime), 2)  
INSERT [dbo].[Department] ([DepartmentID], [Name], [Budget], [StartDate], [Administrator]) VALUES (2, N'English', 120000.0000, CAST(0x0000999C00000000 AS DateTime), 6)  
INSERT [dbo].[Department] ([DepartmentID], [Name], [Budget], [StartDate], [Administrator]) VALUES (4, N'Economics', 200000.0000, CAST(0x0000999C00000000 AS DateTime), 4)  
INSERT [dbo].[Department] ([DepartmentID], [Name], [Budget], [StartDate], [Administrator]) VALUES (7, N'Mathematics', 250024.0000, CAST(0x0000999C00000000 AS DateTime), 3)  
SET IDENTITY_INSERT [dbo].[Department] OFF  
SET IDENTITY_INSERT [dbo].[Person] ON   

INSERT [dbo].[Person] ([PersonID], [LastName], [FirstName], [HireDate], [EnrollmentDate]) VALUES (1, N'Hu', N'Nan', NULL, CAST(0x0000A0BF00000000 AS DateTime))  
INSERT [dbo].[Person] ([PersonID], [LastName], [FirstName], [HireDate], [EnrollmentDate]) VALUES (2, N'Norman', N'Laura', NULL, CAST(0x0000A0BF00000000 AS DateTime))  
INSERT [dbo].[Person] ([PersonID], [LastName], [FirstName], [HireDate], [EnrollmentDate]) VALUES (3, N'Olivotto', N'Nino', NULL, CAST(0x0000A0BF00000000 AS DateTime))  
INSERT [dbo].[Person] ([PersonID], [LastName], [FirstName], [HireDate], [EnrollmentDate]) VALUES (4, N'Anand', N'Arturo', NULL, CAST(0x0000A0BF00000000 AS DateTime))  
INSERT [dbo].[Person] ([PersonID], [LastName], [FirstName], [HireDate], [EnrollmentDate]) VALUES (5, N'Jai', N'Damien', NULL, CAST(0x0000A0BF00000000 AS DateTime))  
INSERT [dbo].[Person] ([PersonID], [LastName], [FirstName], [HireDate], [EnrollmentDate]) VALUES (6, N'Holt', N'Roger', CAST(0x000097F100000000 AS DateTime), NULL)  
INSERT [dbo].[Person] ([PersonID], [LastName], [FirstName], [HireDate], [EnrollmentDate]) VALUES (7, N'Martin', N'Randall', CAST(0x00008B1A00000000 AS DateTime), NULL)  
SET IDENTITY_INSERT [dbo].[Person] OFF  
SET IDENTITY_INSERT [dbo].[StudentGrade] ON   

INSERT [dbo].[StudentGrade] ([EnrollmentID], [CourseID], [StudentID], [Grade]) VALUES (1, N'C1045', 1, CAST(3.50 AS Decimal(3, 2)))  
INSERT [dbo].[StudentGrade] ([EnrollmentID], [CourseID], [StudentID], [Grade]) VALUES (2, N'C1045', 2, CAST(3.00 AS Decimal(3, 2)))  
INSERT [dbo].[StudentGrade] ([EnrollmentID], [CourseID], [StudentID], [Grade]) VALUES (3, N'C1045', 3, CAST(2.50 AS Decimal(3, 2)))  
INSERT [dbo].[StudentGrade] ([EnrollmentID], [CourseID], [StudentID], [Grade]) VALUES (4, N'C1045', 4, CAST(4.00 AS Decimal(3, 2)))  
INSERT [dbo].[StudentGrade] ([EnrollmentID], [CourseID], [StudentID], [Grade]) VALUES (5, N'C1045', 5, CAST(3.50 AS Decimal(3, 2)))  
INSERT [dbo].[StudentGrade] ([EnrollmentID], [CourseID], [StudentID], [Grade]) VALUES (6, N'C1061', 1, CAST(4.00 AS Decimal(3, 2)))  
INSERT [dbo].[StudentGrade] ([EnrollmentID], [CourseID], [StudentID], [Grade]) VALUES (7, N'C1061', 3, CAST(3.50 AS Decimal(3, 2)))  
INSERT [dbo].[StudentGrade] ([EnrollmentID], [CourseID], [StudentID], [Grade]) VALUES (8, N'C1061', 4, CAST(2.50 AS Decimal(3, 2)))  
INSERT [dbo].[StudentGrade] ([EnrollmentID], [CourseID], [StudentID], [Grade]) VALUES (9, N'C1061', 5, CAST(1.50 AS Decimal(3, 2)))  
INSERT [dbo].[StudentGrade] ([EnrollmentID], [CourseID], [StudentID], [Grade]) VALUES (10, N'C2021', 1, CAST(2.50 AS Decimal(3, 2)))  
INSERT [dbo].[StudentGrade] ([EnrollmentID], [CourseID], [StudentID], [Grade]) VALUES (11, N'C2021', 2, CAST(3.50 AS Decimal(3, 2)))  
INSERT [dbo].[StudentGrade] ([EnrollmentID], [CourseID], [StudentID], [Grade]) VALUES (12, N'C2021', 4, CAST(3.00 AS Decimal(3, 2)))  
INSERT [dbo].[StudentGrade] ([EnrollmentID], [CourseID], [StudentID], [Grade]) VALUES (13, N'C2021', 5, CAST(3.00 AS Decimal(3, 2)))  
INSERT [dbo].[StudentGrade] ([EnrollmentID], [CourseID], [StudentID], [Grade]) VALUES (14, N'C2042', 1, CAST(2.00 AS Decimal(3, 2)))  
INSERT [dbo].[StudentGrade] ([EnrollmentID], [CourseID], [StudentID], [Grade]) VALUES (15, N'C2042', 2, CAST(3.50 AS Decimal(3, 2)))  
INSERT [dbo].[StudentGrade] ([EnrollmentID], [CourseID], [StudentID], [Grade]) VALUES (16, N'C2042', 3, CAST(4.00 AS Decimal(3, 2)))  
INSERT [dbo].[StudentGrade] ([EnrollmentID], [CourseID], [StudentID], [Grade]) VALUES (17, N'C2042', 5, CAST(3.00 AS Decimal(3, 2)))  
SET IDENTITY_INSERT [dbo].[StudentGrade] OFF  
ALTER TABLE [dbo].[Course]  WITH CHECK ADD  CONSTRAINT [FK_Course_Department] FOREIGN KEY([DepartmentID])  
REFERENCES [dbo].[Department] ([DepartmentID])  
GO  
ALTER TABLE [dbo].[Course] CHECK CONSTRAINT [FK_Course_Department]  
GO  
ALTER TABLE [dbo].[StudentGrade]  WITH CHECK ADD  CONSTRAINT [FK_StudentGrade_Student] FOREIGN KEY([StudentID])  
REFERENCES [dbo].[Person] ([PersonID])  
GO  
ALTER TABLE [dbo].[StudentGrade] CHECK CONSTRAINT [FK_StudentGrade_Student]  
GO  

Em seguida, compile e execute o seguinte:

using System;  
using System.Data;  
using System.Data.SqlClient;  
using System.Threading.Tasks;  

class Program {  

   static class SqlHelper {  
      // Set the connection, command, and then execute the command with non query.  
      public static Int32 ExecuteNonQuery(String connectionString, String commandText,  
          CommandType commandType, params SqlParameter[] parameters) {  
         using (SqlConnection conn = new SqlConnection(connectionString)) {  
            using (SqlCommand cmd = new SqlCommand(commandText, conn)) {  
               // There're three command types: StoredProcedure, Text, TableDirect. The TableDirect   
               // type is only for OLE DB.    
               cmd.CommandType = commandType;  
               cmd.Parameters.AddRange(parameters);  

               conn.Open();  
               return cmd.ExecuteNonQuery();  
            }  
         }  
      }  

      // Set the connection, command, and then execute the command and only return one value.  
      public static Object ExecuteScalar(String connectionString, String commandText,  
          CommandType commandType, params SqlParameter[] parameters) {  
         using (SqlConnection conn = new SqlConnection(connectionString)) {  
            using (SqlCommand cmd = new SqlCommand(commandText, conn)) {  
               cmd.CommandType = commandType;  
               cmd.Parameters.AddRange(parameters);  

               conn.Open();  
               return cmd.ExecuteScalar();  
            }  
         }  
      }  

      // Set the connection, command, and then execute the command with query and return the reader.  
      public static SqlDataReader ExecuteReader(String connectionString, String commandText,  
          CommandType commandType, params SqlParameter[] parameters) {  
         SqlConnection conn = new SqlConnection(connectionString);  

         using (SqlCommand cmd = new SqlCommand(commandText, conn)) {  
            cmd.CommandType = commandType;  
            cmd.Parameters.AddRange(parameters);  

            conn.Open();  
            // When using CommandBehavior.CloseConnection, the connection will be closed when the   
            // IDataReader is closed.  
            SqlDataReader reader = cmd.ExecuteReader(CommandBehavior.CloseConnection);  

            return reader;  
         }  
      }  
   }  

   static void Main(string[] args) {  
      String connectionString = "Data Source=(local);Initial Catalog=MySchool;Integrated Security=True;Asynchronous Processing=true;";  

      CountCourses(connectionString, 2012);  
      Console.WriteLine();  

      Console.WriteLine("Following result is the departments that started from 2007:");  
      GetDepartments(connectionString, 2007);  
      Console.WriteLine();  

      Console.WriteLine("Add the credits when the credits of course is lower than 4.");  
      AddCredits(connectionString, 4);  
      Console.WriteLine();  

      Console.WriteLine("Please press any key to exit...");  
      Console.ReadKey();  
   }  

   static void CountCourses(String connectionString, Int32 year) {  
      String commandText = "Select Count([CourseID]) FROM [MySchool].[dbo].[Course] Where Year=@Year";  
      SqlParameter parameterYear = new SqlParameter("@Year", SqlDbType.Int);  
      parameterYear.Value = year;  

      Object oValue = SqlHelper.ExecuteScalar(connectionString, commandText, CommandType.Text, parameterYear);  
      Int32 count;  
      if (Int32.TryParse(oValue.ToString(), out count))  
         Console.WriteLine("There {0} {1} course{2} in {3}.", count > 1 ? "are" : "is", count, count > 1 ? "s" : null, year);  
   }  

   // Display the Departments that start from the specified year.  
   static void GetDepartments(String connectionString, Int32 year) {  
      String commandText = "dbo.GetDepartmentsOfSpecifiedYear";  

      // Specify the year of StartDate  
      SqlParameter parameterYear = new SqlParameter("@Year", SqlDbType.Int);  
      parameterYear.Value = year;  

      // When the direction of parameter is set as Output, you can get the value after   
      // executing the command.  
      SqlParameter parameterBudget = new SqlParameter("@BudgetSum", SqlDbType.Money);  
      parameterBudget.Direction = ParameterDirection.Output;  

      using (SqlDataReader reader = SqlHelper.ExecuteReader(connectionString, commandText,  
          CommandType.StoredProcedure, parameterYear, parameterBudget)) {  
         Console.WriteLine("{0,-20}{1,-20}{2,-20}{3,-20}", "Name", "Budget", "StartDate",  
             "Administrator");  
         while (reader.Read()) {  
            Console.WriteLine("{0,-20}{1,-20:C}{2,-20:d}{3,-20}", reader["Name"],  
                reader["Budget"], reader["StartDate"], reader["Administrator"]);  
         }  
      }  
      Console.WriteLine("{0,-20}{1,-20:C}", "Sum:", parameterBudget.Value);  
   }  

   // If credits of course is lower than the certain value, the method will add the credits.  
   static void AddCredits(String connectionString, Int32 creditsLow) {  
      String commandText = "Update [MySchool].[dbo].[Course] Set Credits=Credits+1 Where Credits<@Credits";  

      SqlParameter parameterCredits = new SqlParameter("@Credits", creditsLow);  

      Int32 rows = SqlHelper.ExecuteNonQuery(connectionString, commandText, CommandType.Text, parameterCredits);  

      Console.WriteLine("{0} row{1} {2} updated.", rows, rows > 1 ? "s" : null, rows > 1 ? "are" : "is");  
   }  
}  

Comentários

Quando uma instância é criada, as propriedades de SqlCommand leitura/gravação são definidas como seus valores iniciais. Para obter uma lista desses valores, consulte o SqlCommand construtor.

SqlCommandapresenta os seguintes métodos para executar comandos em um banco de dados SQL Server:

Item Descrição
BeginExecuteNonQuery Inicia a execução assíncrona da instrução Transact-SQL ou do procedimento armazenado descrito por issoSqlCommand, geralmente executando comandos como instruções INSERT, DELETE, UPDATE e SET. Cada chamada deve BeginExecuteNonQuery ser emparelhada com uma chamada para a EndExecuteNonQuery qual termina a operação, normalmente em um thread separado.
BeginExecuteReader Inicia a execução assíncrona da instrução Transact-SQL ou do procedimento armazenado descrito por isso SqlCommand e recupera um ou mais conjuntos de resultados do servidor. Cada chamada deve BeginExecuteReader ser emparelhada com uma chamada para a EndExecuteReader qual termina a operação, normalmente em um thread separado.
BeginExecuteXmlReader Inicia a execução assíncrona da instrução Transact-SQL ou procedimento armazenado que é descrito por este SqlCommand. Cada chamada deve BeginExecuteXmlReader ser emparelhada com uma chamada para EndExecuteXmlReader, que termina a operação, normalmente em um thread separado, e retorna um XmlReader objeto.
ExecuteReader Executa comandos que retornam linhas. Para aumentar o desempenho, ExecuteReader invoca comandos usando o procedimento armazenado do sistema Transact-SQLsp_executesql. Portanto, ExecuteReader talvez não tenha o efeito desejado se usado para executar comandos como instruções SET SQL Transact.
ExecuteNonQuery Executa comandos como instruções INSERT, DELETE, UPDATE e SET do Transact-SQL.
ExecuteScalar Recupera um único valor (por exemplo, um valor agregado) de um banco de dados.
ExecuteXmlReader Envia o CommandText para o Connection e cria um objeto XmlReader.

Você pode redefinir a CommandText propriedade e reutilizar o SqlCommand objeto. No entanto, você deve fechar antes SqlDataReader de executar um comando novo ou anterior.

Se um SqlException for gerado pelo método que executa um SqlCommand, ele SqlConnection permanecerá aberto quando o nível de gravidade for 19 ou menos. Quando o nível de gravidade é 20 ou maior, o servidor normalmente fecha o SqlConnection. No entanto, o usuário pode reabrir a conexão e continuar.

Observação

Parâmetros ordinais, também chamados de ordinais, não são suportados pelo .NET Framework Provedor de Dados para SQL Server.

Construtores

SqlCommand()

Inicializa uma nova instância da classe SqlCommand.

SqlCommand(String)

Inicializa uma nova instância da classe SqlCommand com o texto da consulta.

SqlCommand(String, SqlConnection)

Inicializa uma nova instância da classe SqlCommand com o texto da consulta e um SqlConnection.

SqlCommand(String, SqlConnection, SqlTransaction)

Inicializa uma nova instância da classe SqlCommand com o texto da consulta, um SqlConnection e o SqlTransaction.

SqlCommand(String, SqlConnection, SqlTransaction, SqlCommandColumnEncryptionSetting)

Inicializa uma nova instância da classe SqlCommand com texto de comando especificado, conexões, transações e configuração de criptografia.

Propriedades

CanRaiseEvents

Obtém um valor que indica se o componente pode acionar um evento.

(Herdado de Component)
ColumnEncryptionSetting

Obtém ou define a configuração de criptografia de coluna desse comando.

CommandText

Obtém ou define a instrução Transact-SQL, nome da tabela ou procedimento armazenado a ser executado na fonte de dados.

CommandTimeout

Obtém ou define o tempo de espera (em segundos) antes de encerrar a tentativa de executar um comando e antes de gerar um erro.

CommandType

Obtém ou define um valor que indica como a propriedade CommandText deve ser interpretada.

Connection

Obtém ou define o SqlConnection usado por essa instância do SqlCommand.

Container

Obtém o IContainer que contém o Component.

(Herdado de Component)
DbConnection

Obtém ou define o DbConnection usado pelo DbCommand.

(Herdado de DbCommand)
DbParameterCollection

Obtém a coleção de objetos DbParameter.

(Herdado de DbCommand)
DbTransaction

Obtém ou define o DbCommand em que este objeto DbTransaction é executado.

(Herdado de DbCommand)
DesignMode

Obtém um valor que indica se o Component está no modo de design no momento.

(Herdado de Component)
DesignTimeVisible

Obtém ou define um valor que indica se o objeto de comando deve estar visível em um controle do Windows Form Designer.

Events

Obtém a lista de manipuladores de eventos que estão anexados a este Component.

(Herdado de Component)
Notification

Obtém ou define um valor que especifica o objeto SqlNotificationRequest associado a este comando.

NotificationAutoEnlist

Obtém ou define um valor que indica se o aplicativo deve receber notificações de consulta automaticamente de um objeto SqlDependency comum.

Parameters

Obtém o SqlParameterCollection.

Site

Obtém ou define o ISite do Component.

(Herdado de Component)
Transaction

Obtém ou define o SqlCommand em que o SqlTransaction é executado.

UpdatedRowSource

Obtém ou define como os resultados do comando são aplicados ao DataRow quando usado pelo método Update do DbDataAdapter.

Métodos

BeginExecuteNonQuery()

Inicia a execução assíncrona da instrução Transact-SQL ou procedimento armazenado que é descrito por este SqlCommand.

BeginExecuteNonQuery(AsyncCallback, Object)

Inicia a execução assíncrona da instrução Transact-SQL ou do procedimento armazenado descrito por esse SqlCommand, dado um procedimento de retorno de chamada e informações sobre o estado.

BeginExecuteReader()

Inicia a execução assíncrona da instrução Transact-SQL ou procedimento armazenado descrito por SqlCommand e recupera um ou mais conjuntos de resultados do servidor.

BeginExecuteReader(AsyncCallback, Object)

Inicia a execução assíncrona da instrução Transact-SQL ou procedimento armazenado descrito por esse SqlCommand e recupera um ou mais conjuntos de resultado do servidor, dado um procedimento de retorno de chamada e informações sobre o estado.

BeginExecuteReader(AsyncCallback, Object, CommandBehavior)

Inicia a execução assíncrona da instrução Transact-SQL ou procedimento armazenado descrito por esse SqlCommand, usando um dos valores CommandBehavior e recuperando um ou mais conjuntos de resultados do servidor, dado um procedimento de retorno de chamada e informações sobre o estado.

BeginExecuteReader(CommandBehavior)

Inicia a execução assíncrona da instrução Transact-SQL ou do procedimento armazenado descrito por este SqlCommand usando um dos valores CommandBehavior.

BeginExecuteXmlReader()

Inicia a execução assíncrona da instrução Transact-SQL ou do procedimento armazenado descrito por este SqlCommand e retorna resultados como um objeto XmlReader.

BeginExecuteXmlReader(AsyncCallback, Object)

Inicia a execução assíncrona da instrução Transact-SQL ou do procedimento armazenado descrito por este SqlCommand e retorna resultados como um objeto XmlReader usando um procedimento de retorno de chamada.

Cancel()

Tenta cancelar a execução de um SqlCommand.

Clone()

Cria um novo objeto SqlCommand que é uma cópia da instância atual.

CreateDbParameter()

Cria uma nova instância de um objeto DbParameter.

(Herdado de DbCommand)
CreateObjRef(Type)

Cria um objeto que contém todas as informações relevantes necessárias para gerar um proxy usado para se comunicar com um objeto remoto.

(Herdado de MarshalByRefObject)
CreateParameter()

Cria uma nova instância de um objeto SqlParameter.

Dispose()

Realiza tarefas definidas pelo aplicativo associadas à liberação ou à redefinição de recursos não gerenciados.

(Herdado de DbCommand)
Dispose()

Libera todos os recursos usados pelo Component.

(Herdado de Component)
Dispose(Boolean)

Libera os recursos não gerenciados usados pelo DbCommand e opcionalmente libera os recursos gerenciados.

(Herdado de DbCommand)
Dispose(Boolean)

Libera os recursos não gerenciados usados pelo Component e opcionalmente libera os recursos gerenciados.

(Herdado de Component)
DisposeAsync()

Descarta de forma assíncrona o objeto de comando.

(Herdado de DbCommand)
EndExecuteNonQuery(IAsyncResult)

Termina a execução assíncrona de uma instrução Transact-SQL.

EndExecuteReader(IAsyncResult)

Conclui a execução assíncrona de uma instrução Transact-SQL, retornando o SqlDataReader solicitado.

EndExecuteXmlReader(IAsyncResult)

Conclui a execução assíncrona de uma instrução Transact-SQL e retorna os dados solicitados como XML.

Equals(Object)

Determina se o objeto especificado é igual ao objeto atual.

(Herdado de Object)
ExecuteDbDataReader(CommandBehavior)

Executa o comando em sua conexão, retornando um DbDataReader que pode ser usado para acessar os resultados.

(Herdado de DbCommand)
ExecuteDbDataReaderAsync(CommandBehavior, CancellationToken)

Os provedores devem implementar esse método para fornecer uma implementação não padrão para sobrecargas ExecuteReader.

A implementação padrão invoca o método ExecuteReader() síncrono e retorna uma tarefa concluída, bloqueando o thread de chamada. A implementação padrão retornará uma tarefa cancelada se já tiver passado um token de cancelamento. Exceções geradas por ExecuteReader serão comunicadas por meio da propriedade Exceção de Tarefa retornada.

Esse método aceita um token de cancelamento que pode ser usado para solicitar a operação a ser cancelada no início. As implementações podem ignorar essa solicitação.

(Herdado de DbCommand)
ExecuteNonQuery()

Executa uma instrução Transact-SQL na conexão e retorna o número de linhas afetadas.

ExecuteNonQueryAsync()

Uma versão assíncrona de ExecuteNonQuery(), que executa o comando em seu objeto de conexão, retornando o número de linhas afetadas.

Invoca ExecuteNonQueryAsync(CancellationToken) com CancellationToken.None.

(Herdado de DbCommand)
ExecuteNonQueryAsync(CancellationToken)

Uma versão assíncrona de ExecuteNonQuery(), que executa uma instrução Transact-SQL na conexão e retorna o número de linhas afetadas. O token de cancelamento pode ser usado para solicitar que a operação seja abandonada antes de expirar o tempo limite do comando. As exceções serão relatadas por meio do objeto de tarefa.

ExecuteNonQueryAsync(CancellationToken)

Essa é a versão assíncrona de ExecuteNonQuery(). Provedores devem substituir com uma implementação apropriada. Opcionalmente, o token de cancelamento pode ser ignorado.

A implementação padrão invoca o método ExecuteNonQuery() síncrono e retorna uma tarefa concluída, bloqueando o thread de chamada. A implementação padrão retornará uma tarefa cancelada se já tiver passado um token de cancelamento. Exceções geradas por ExecuteNonQuery() serão comunicadas por meio da propriedade Exceção de Tarefa retornada.

Não invoque outros métodos e propriedades do objeto DbCommand até a Tarefa retornada ser concluída.

(Herdado de DbCommand)
ExecuteReader()

Envia o CommandText para o Connection e cria um SqlDataReader.

ExecuteReader(CommandBehavior)

Envia o CommandText para o Connection e cria um SqlDataReader usando um dos valores de CommandBehavior.

ExecuteReaderAsync()

Uma versão assíncrona de ExecuteReader(), que envia o CommandText para o Connection e cria um SqlDataReader. As exceções serão relatadas por meio do objeto de tarefa.

ExecuteReaderAsync()

Uma versão assíncrona de ExecuteReader, que executa o comando em relação à sua conexão, retornando uma DbDataReader que pode ser usada para acessar os resultados.

Invoca ExecuteDbDataReaderAsync(CommandBehavior, CancellationToken) com CancellationToken.None.

(Herdado de DbCommand)
ExecuteReaderAsync(CancellationToken)

Uma versão assíncrona de ExecuteReader(), que envia o CommandText para o Connection e cria um SqlDataReader.

O token de cancelamento pode ser usado para solicitar que a operação seja abandonada antes de expirar o tempo limite do comando. As exceções serão relatadas por meio do objeto de tarefa.

ExecuteReaderAsync(CancellationToken)

Uma versão assíncrona de ExecuteReader, que executa o comando em relação à sua conexão, retornando uma DbDataReader que pode ser usada para acessar os resultados.

Invoca ExecuteDbDataReaderAsync(CommandBehavior, CancellationToken).

(Herdado de DbCommand)
ExecuteReaderAsync(CommandBehavior)

Uma versão assíncrona de ExecuteReader(CommandBehavior), que envia o CommandText para o Connection e cria um SqlDataReader. As exceções serão relatadas por meio do objeto de tarefa.

ExecuteReaderAsync(CommandBehavior)

Uma versão assíncrona de ExecuteReader, que executa o comando em relação à sua conexão, retornando uma DbDataReader que pode ser usada para acessar os resultados.

Invoca ExecuteDbDataReaderAsync(CommandBehavior, CancellationToken).

(Herdado de DbCommand)
ExecuteReaderAsync(CommandBehavior, CancellationToken)

Uma versão assíncrona de ExecuteReader(CommandBehavior), que envia o CommandText para o Connection e cria um SqlDataReader

O token de cancelamento pode ser usado para solicitar que a operação seja abandonada antes de expirar o tempo limite do comando. As exceções serão relatadas por meio do objeto de tarefa.

ExecuteReaderAsync(CommandBehavior, CancellationToken)

Invoca ExecuteDbDataReaderAsync(CommandBehavior, CancellationToken).

(Herdado de DbCommand)
ExecuteScalar()

Executa a consulta e retorna a primeira coluna da primeira linha no conjunto de resultados retornado pela consulta. Colunas ou linhas adicionais são ignoradas.

ExecuteScalarAsync()

Uma versão assíncrona da ExecuteScalar()qual executa o comando e retorna a primeira coluna da primeira linha no primeiro conjunto de resultados retornado. Todas as outras colunas, linhas e conjuntos de resultados são ignorados.

Invoca ExecuteScalarAsync(CancellationToken) com CancellationToken.None.

(Herdado de DbCommand)
ExecuteScalarAsync(CancellationToken)

Uma versão assíncrona de ExecuteScalar(), que executa a consulta de forma assíncrona e retorna a primeira coluna da primeira linha no conjunto de resultados retornado pela consulta. Colunas ou linhas adicionais são ignoradas.

O token de cancelamento pode ser usado para solicitar que a operação seja abandonada antes de expirar o tempo limite do comando. As exceções serão relatadas por meio do objeto de tarefa.

ExecuteScalarAsync(CancellationToken)

Essa é a versão assíncrona de ExecuteScalar(). Provedores devem substituir com uma implementação apropriada. Opcionalmente, o token de cancelamento pode ser ignorado.

A implementação padrão invoca o método ExecuteScalar() síncrono e retorna uma tarefa concluída, bloqueando o thread de chamada. A implementação padrão retornará uma tarefa cancelada se já tiver passado um token de cancelamento. Exceções geradas por ExecuteScalar serão comunicadas por meio da propriedade Exceção de Tarefa retornada.

Não invoque outros métodos e propriedades do objeto DbCommand até a Tarefa retornada ser concluída.

(Herdado de DbCommand)
ExecuteXmlReader()

Envia o CommandText para o Connection e cria um objeto XmlReader.

ExecuteXmlReaderAsync()

Uma versão assíncrona de ExecuteXmlReader(), que envia o CommandText para o Connection e cria um objeto XmlReader.

As exceções serão relatadas por meio do objeto de tarefa.

ExecuteXmlReaderAsync(CancellationToken)

Uma versão assíncrona de ExecuteXmlReader(), que envia o CommandText para o Connection e cria um objeto XmlReader.

O token de cancelamento pode ser usado para solicitar que a operação seja abandonada antes de expirar o tempo limite do comando. As exceções serão relatadas por meio do objeto de tarefa.

GetHashCode()

Serve como a função de hash padrão.

(Herdado de Object)
GetLifetimeService()
Obsoleto.

Recupera o objeto de serviço de tempo de vida atual que controla a política de ciclo de vida para esta instância.

(Herdado de MarshalByRefObject)
GetService(Type)

Retorna um objeto que representa um serviço fornecido pelo Component ou pelo seu Container.

(Herdado de Component)
GetType()

Obtém o Type da instância atual.

(Herdado de Object)
InitializeLifetimeService()
Obsoleto.

Obtém um objeto de serviço de tempo de vida para controlar a política de tempo de vida para essa instância.

(Herdado de MarshalByRefObject)
MemberwiseClone()

Cria uma cópia superficial do Object atual.

(Herdado de Object)
MemberwiseClone(Boolean)

Cria uma cópia superficial do objeto MarshalByRefObject atual.

(Herdado de MarshalByRefObject)
Prepare()

Cria uma versão preparada do comando em uma instância do SQL Server.

PrepareAsync(CancellationToken)

Cria de maneira assíncrona uma versão preparada (ou compilada) do comando na fonte de dados.

(Herdado de DbCommand)
ResetCommandTimeout()

Redefine a propriedade CommandTimeout para seu valor padrão.

ToString()

Retorna uma cadeia de caracteres que representa o objeto atual.

(Herdado de Object)
ToString()

Retorna um String que contém o nome do Component, se houver. Esse método não deve ser substituído.

(Herdado de Component)

Eventos

Disposed

Ocorre quando o componente é disposto por uma chamada ao método Dispose().

(Herdado de Component)
StatementCompleted

Ocorre quando a execução de uma instrução Transact-SQL é concluída.

Implantações explícitas de interface

ICloneable.Clone()

Cria um novo objeto SqlCommand que é uma cópia da instância atual.

IDbCommand.Connection

Obtém ou define o IDbConnection usado por essa instância do IDbCommand.

(Herdado de DbCommand)
IDbCommand.CreateParameter()

Cria uma nova instância de um objeto SqlParameter.

IDbCommand.CreateParameter()

Cria uma nova instância de um objeto IDbDataParameter.

(Herdado de DbCommand)
IDbCommand.ExecuteReader()

Envia o CommandText para o Connection e cria um SqlDataReader.

IDbCommand.ExecuteReader()

Executa o CommandText no Connection e compila um IDataReader.

(Herdado de DbCommand)
IDbCommand.ExecuteReader(CommandBehavior)

Envia o CommandText para o Connection e cria um SqlDataReader usando um dos valores de CommandBehavior.

IDbCommand.ExecuteReader(CommandBehavior)

Executa o CommandText para o Connection e cria um IDataReader usando um dos valores de CommandBehavior.

(Herdado de DbCommand)
IDbCommand.Parameters

Obtém o IDataParameterCollection.

(Herdado de DbCommand)
IDbCommand.Transaction

Obtém ou define o DbCommand em que este objeto DbTransaction é executado.

(Herdado de DbCommand)

Aplica-se a

Confira também