SqlCommand Clase

Definición

Representa un procedimiento almacenado o una instrucción de Transact-SQL que se ejecuta en una base de datos de SQL Server. Esta clase no puede heredarse.

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
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
type SqlCommand = class
    inherit DbCommand
type SqlCommand = class
    inherit Component
    interface IDbCommand
    interface IDisposable
    interface ICloneable
type SqlCommand = class
    inherit DbCommand
    interface 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
Herencia
SqlCommand
Herencia
Herencia
Implementaciones

Ejemplos

En el ejemplo siguiente se crea un SqlConnectionobjeto , y SqlCommand.SqlDataReader En el ejemplo se leen los datos y se escribe en la consola. Por último, el ejemplo cierra SqlDataReader y, a continuación, a SqlConnection medida que sale de los bloques de Using 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

En el ejemplo siguiente se muestra cómo crear y ejecutar diferentes tipos de objetos SqlCommand.

En primer lugar, debe crear la base de datos de ejemplo ejecutando el siguiente 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

A continuación, compile y ejecute lo siguiente:

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");
   }
}

Comentarios

Cuando se crea una instancia de , las propiedades de SqlCommand lectura y escritura se establecen en sus valores iniciales. Para obtener una lista de estos valores, consulte el SqlCommand constructor .

SqlCommandpresenta los métodos siguientes para ejecutar comandos en una base de datos de SQL Server:

Elemento Descripción
BeginExecuteNonQuery Inicia la ejecución asincrónica de la instrucción Transact-SQL o el procedimiento almacenado descrito por este SqlCommand, generalmente ejecutando comandos como instrucciones INSERT, DELETE, UPDATE y SET. Cada llamada a BeginExecuteNonQuery debe emparejarse con una llamada a la EndExecuteNonQuery que finaliza la operación, normalmente en un subproceso independiente.
BeginExecuteReader Inicia la ejecución asincrónica de la instrucción Transact-SQL o el procedimiento almacenado descrito por este SqlCommand y recupera uno o varios conjuntos de resultados del servidor. Cada llamada a BeginExecuteReader debe emparejarse con una llamada a la EndExecuteReader que finaliza la operación, normalmente en un subproceso independiente.
BeginExecuteXmlReader Inicia la ejecución asincrónica de la instrucción de Transact-SQL o del procedimiento almacenado que describe SqlCommand. Cada llamada a BeginExecuteXmlReader debe emparejarse con una llamada a EndExecuteXmlReader, que finaliza la operación, normalmente en un subproceso independiente y devuelve un XmlReader objeto .
ExecuteReader Ejecuta comandos que devuelven filas. Para aumentar el rendimiento, ExecuteReader invoca comandos mediante el procedimiento almacenado del sistema Transact-SQL sp_executesql . Por lo tanto, ExecuteReader es posible que no tenga el efecto que desea si se usa para ejecutar comandos como instrucciones SET de Transact-SQL.
ExecuteNonQuery Ejecuta comandos como instrucciones INSERT, DELETE, UPDATE y SET de Transact-SQL.
ExecuteScalar Recupera un valor único (por ejemplo, un valor agregado) de una base de datos.
ExecuteXmlReader Envía CommandText a Connection y crea un objeto XmlReader.

Puede restablecer la CommandText propiedad y reutilizar el SqlCommand objeto . Sin embargo, debe cerrar antes SqlDataReader de poder ejecutar un comando nuevo o anterior.

Si el método genera un SqlException objeto que ejecuta , SqlCommandSqlConnection permanece abierto cuando el nivel de gravedad es 19 o menos. Cuando el nivel de gravedad es 20 o superior, el servidor normalmente cierra .SqlConnection Sin embargo, el usuario puede volver a abrir la conexión y continuar.

Nota

Sin nombre, también denominado ordinal, los parámetros no son compatibles con el proveedor de datos de .NET Framework para SQL Server.

Constructores

SqlCommand()

Inicializa una nueva instancia de la clase SqlCommand.

SqlCommand(String)

Inicializa una nueva instancia de la clase SqlCommand con el texto de la consulta.

SqlCommand(String, SqlConnection)

Inicializa una nueva instancia de la clase SqlCommand con el texto de la consulta y una conexión SqlConnection.

SqlCommand(String, SqlConnection, SqlTransaction)

Inicializa una nueva instancia de la clase SqlCommand con el texto de la consulta, un objeto SqlConnection y el objeto SqlTransaction.

SqlCommand(String, SqlConnection, SqlTransaction, SqlCommandColumnEncryptionSetting)

Inicializa una nueva instancia de la clase SqlCommand con texto de comando especificado, conexión, transacción y configuración de cifrado.

Propiedades

CanRaiseEvents

Obtiene un valor que indica si el componente puede generar un evento.

(Heredado de Component)
ColumnEncryptionSetting

Obtiene o establece la configuración del cifrado de columnas para este comando.

CommandText

Obtiene o establece la instrucción de Transact-SQL, el nombre de tabla o el procedimiento almacenado que se ejecutan en el origen de datos.

CommandTimeout

Obtiene o establece el tiempo de espera (en segundos) hasta que se interrumpe el intento de ejecutar un comando y se genera un error.

CommandType

Obtiene o establece un valor que indica cómo se interpreta la propiedad CommandText.

Connection

Obtiene o establece la interfaz SqlConnection que usa esta instancia de SqlCommand.

Container

Obtiene la interfaz IContainer que contiene la clase Component.

(Heredado de Component)
DbConnection

Obtiene o establece el objeto DbConnection utilizado por este DbCommand.

(Heredado de DbCommand)
DbParameterCollection

Obtiene la colección de objetos DbParameter.

(Heredado de DbCommand)
DbTransaction

Obtiene o establece DbTransaction dentro del cual se ejecuta este objeto DbCommand.

(Heredado de DbCommand)
DesignMode

Obtiene un valor que indica si Component está actualmente en modo de diseño.

(Heredado de Component)
DesignTimeVisible

Obtiene o establece un valor que indica si el objeto de comando debe estar visible en un control del Diseñador de Windows Forms.

Events

Obtiene la lista de controladores de eventos asociados a Component.

(Heredado de Component)
Notification

Obtiene o establece un valor que especifica el objeto SqlNotificationRequest enlazado a este comando.

NotificationAutoEnlist

Obtiene o establece un valor que indica si la aplicación debe recibir automáticamente notificaciones de consulta de un objeto SqlDependency común.

Parameters

Obtiene la estructura SqlParameterCollection.

Site

Obtiene o establece ISite de Component.

(Heredado de Component)
Transaction

Obtiene o establece la transacción SqlTransaction en la que se ejecuta SqlCommand.

UpdatedRowSource

Obtiene o establece cómo se aplican los resultados del comando al DataRow cuando lo usa el método Update de DbDataAdapter.

Métodos

BeginExecuteNonQuery()

Inicia la ejecución asincrónica de la instrucción de Transact-SQL o del procedimiento almacenado que describe SqlCommand.

BeginExecuteNonQuery(AsyncCallback, Object)

Inicia la ejecución asincrónica de la instrucción de Transact-SQL o del procedimiento almacenado que describe SqlCommand, dados un procedimiento de devolución de llamada e información de estado.

BeginExecuteReader()

Inicia la ejecución asincrónica de la instrucción de Transact-SQL o del procedimiento almacenado que describe SqlCommand y recupera uno o varios conjuntos de resultados del servidor.

BeginExecuteReader(AsyncCallback, Object)

Inicia la ejecución asincrónica de la instrucción de Transact-SQL o del procedimiento almacenado que describe SqlCommand y recupera uno o varios conjuntos de resultados del servidor, dados un procedimiento de devolución de llamada e información de estado.

BeginExecuteReader(AsyncCallback, Object, CommandBehavior)

Inicia la ejecución asincrónica de la instrucción de Transact-SQL o del procedimiento almacenado que describe SqlCommand, utilizando uno de los valores de CommandBehavior y recuperando uno o varios conjuntos de resultados del servidor, a partir del procedimiento de devolución de llamada e información de estado dados.

BeginExecuteReader(CommandBehavior)

Inicia la ejecución asincrónica de la instrucción de Transact-SQL o del procedimiento almacenado que describe SqlCommand utilizando uno de los valores de CommandBehavior.

BeginExecuteXmlReader()

Inicia la ejecución asincrónica de la instrucción de Transact-SQL o del procedimiento almacenado que describe SqlCommand y devuelve los resultados como un objeto XmlReader.

BeginExecuteXmlReader(AsyncCallback, Object)

Inicia la ejecución asincrónica de la instrucción de Transact-SQL o del procedimiento almacenado que describe SqlCommand y devuelve los resultados como un objeto XmlReader a través de un procedimiento de devolución de llamada.

Cancel()

Intenta cancelar la ejecución de un SqlCommand.

Clone()

Crea un nuevo objeto SqlCommand que es una copia de la instancia actual.

CreateDbParameter()

Crea una nueva instancia de un objeto DbParameter.

(Heredado de DbCommand)
CreateObjRef(Type)

Crea un objeto que contiene toda la información relevante necesaria para generar un proxy utilizado para comunicarse con un objeto remoto.

(Heredado de MarshalByRefObject)
CreateParameter()

Crea una nueva instancia de un objeto SqlParameter.

Dispose()

Realiza tareas definidas por la aplicación asociadas a la liberación o al restablecimiento de recursos no administrados.

(Heredado de DbCommand)
Dispose()

Libera todos los recursos que usa Component.

(Heredado de Component)
Dispose(Boolean)

Libera los recursos no administrados que usa DbCommand y, de forma opcional, libera los recursos administrados.

(Heredado de DbCommand)
Dispose(Boolean)

Libera los recursos no administrados que usa Component y, de forma opcional, libera los recursos administrados.

(Heredado de Component)
DisposeAsync()

Desecha de forma asincrónica el objeto de comando.

(Heredado de DbCommand)
EndExecuteNonQuery(IAsyncResult)

Finaliza la ejecución asincrónica de una instrucción de Transact-SQL.

EndExecuteReader(IAsyncResult)

Finaliza la ejecución asincrónica de una instrucción de Transact-SQL y devuelve el objeto SqlDataReader solicitado.

EndExecuteXmlReader(IAsyncResult)

Finaliza la ejecución asincrónica de una instrucción de Transact-SQL y devuelve los datos solicitados como XML.

Equals(Object)

Determina si el objeto especificado es igual que el objeto actual.

(Heredado de Object)
ExecuteDbDataReader(CommandBehavior)

Ejecuta el comando en su conexión y devuelve un DbDataReader objeto que se puede usar para tener acceso a los resultados.

(Heredado de DbCommand)
ExecuteDbDataReaderAsync(CommandBehavior, CancellationToken)

Los proveedores deben implementar este método para proporcionar una implementación no predeterminada para las sobrecargas de ExecuteReader.

La implementación predeterminada invoca el método sincrónico ExecuteReader() y devuelve una tarea completada, bloqueando el subproceso de llamada. La implementación predeterminada devolverá una tarea cancelada si se pasa un token de cancelación ya cancelado. Las excepciones producidas por ExecuteReader se comunicarán mediante la propiedad Task Exception devuelta.

Este método acepta un token de cancelación que se puede usar para solicitar que la operación se cancele pronto. Las implementaciones pueden omitir esta solicitud.

(Heredado de DbCommand)
ExecuteNonQuery()

Ejecuta una instrucción de Transact-SQL en la conexión y devuelve el número de filas afectadas.

ExecuteNonQueryAsync()

Una versión asincrónica de ExecuteNonQuery(), que ejecuta el comando en su objeto de conexión, devolviendo el número de filas afectadas.

Invoca ExecuteNonQueryAsync(CancellationToken) con CancellationToken.None.

(Heredado de DbCommand)
ExecuteNonQueryAsync(CancellationToken)

Una versión asincrónica de ExecuteNonQuery(), que ejecuta una instrucción Transact-SQL en la conexión y devuelve el número de filas afectadas. Token de cancelación que se puede usar para solicitar que se abandone la operación antes de que transcurra el tiempo de espera del comando. Las excepciones se mostrarán a través del objeto Task devuelto.

ExecuteNonQueryAsync(CancellationToken)

Esta es la versión asincrónica de ExecuteNonQuery(). Los proveedores lo deben reemplazar con una implementación apropiada. El token de cancelación se puede omitir opcionalmente.

La implementación predeterminada invoca el método sincrónico ExecuteNonQuery() y devuelve una tarea completada, bloqueando el subproceso de llamada. La implementación predeterminada devolverá una tarea cancelada si se pasa un token de cancelación ya cancelado. Las excepciones producidas por ExecuteNonQuery() se comunicarán mediante la propiedad Task Exception devuelta.

No invoque otros métodos y propiedades del objeto DbCommand hasta que se haya completado la tarea devuelta.

(Heredado de DbCommand)
ExecuteReader()

Envía la propiedad CommandText a Connection y crea un objeto SqlDataReader.

ExecuteReader(CommandBehavior)

Envía CommandText a Connection y crea un SqlDataReader mediante uno de los valores de CommandBehavior.

ExecuteReaderAsync()

Una versión asincrónica de ExecuteReader(), que envía la propiedad CommandText a la propiedad Connection y compila SqlDataReader. Las excepciones se mostrarán a través del objeto Task devuelto.

ExecuteReaderAsync()

Una versión asincrónica de ExecuteReader, que ejecuta el comando en su conexión, que devuelve un DbDataReader objeto que se puede usar para acceder a los resultados.

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

(Heredado de DbCommand)
ExecuteReaderAsync(CancellationToken)

Una versión asincrónica de ExecuteReader(), que envía la propiedad CommandText a la propiedad Connection y compila SqlDataReader.

Token de cancelación que se puede usar para solicitar que se abandone la operación antes de que transcurra el tiempo de espera del comando. Las excepciones se mostrarán a través del objeto Task devuelto.

ExecuteReaderAsync(CancellationToken)

Una versión asincrónica de ExecuteReader, que ejecuta el comando en su conexión, que devuelve un DbDataReader objeto que se puede usar para acceder a los resultados.

Invoca ExecuteDbDataReaderAsync(CommandBehavior, CancellationToken).

(Heredado de DbCommand)
ExecuteReaderAsync(CommandBehavior)

Versión asincrónica de ExecuteReader(CommandBehavior), que envía la propiedad CommandText a la propiedad Connection y compila SqlDataReader. Las excepciones se mostrarán a través del objeto Task devuelto.

ExecuteReaderAsync(CommandBehavior)

Una versión asincrónica de ExecuteReader, que ejecuta el comando en su conexión, que devuelve un DbDataReader objeto que se puede usar para acceder a los resultados.

Invoca ExecuteDbDataReaderAsync(CommandBehavior, CancellationToken).

(Heredado de DbCommand)
ExecuteReaderAsync(CommandBehavior, CancellationToken)

Versión asincrónica de ExecuteReader(CommandBehavior), que envía la propiedad CommandText a la propiedad Connection y compila SqlDataReader

Token de cancelación que se puede usar para solicitar que se abandone la operación antes de que transcurra el tiempo de espera del comando. Las excepciones se mostrarán a través del objeto Task devuelto.

ExecuteReaderAsync(CommandBehavior, CancellationToken)

Invoca ExecuteDbDataReaderAsync(CommandBehavior, CancellationToken).

(Heredado de DbCommand)
ExecuteScalar()

Ejecuta la consulta y devuelve la primera columna de la primera fila del conjunto de resultados devueltos por la consulta. Las demás columnas o filas no se tienen en cuenta.

ExecuteScalarAsync()

Una versión asincrónica de ExecuteScalar(), que ejecuta el comando y devuelve la primera columna de la primera fila del primer conjunto de resultados devuelto. Todas las demás columnas, filas y conjuntos de resultados se omiten.

Invoca ExecuteScalarAsync(CancellationToken) con CancellationToken.None.

(Heredado de DbCommand)
ExecuteScalarAsync(CancellationToken)

Versión asincrónica de ExecuteScalar() que ejecuta la consulta asincrónicamente y devuelve la primera columna de la primera fila del conjunto de resultados que devuelve la consulta. Las demás columnas o filas no se tienen en cuenta.

Token de cancelación que se puede usar para solicitar que se abandone la operación antes de que transcurra el tiempo de espera del comando. Las excepciones se mostrarán a través del objeto Task devuelto.

ExecuteScalarAsync(CancellationToken)

Esta es la versión asincrónica de ExecuteScalar(). Los proveedores lo deben reemplazar con una implementación apropiada. El token de cancelación se puede omitir opcionalmente.

La implementación predeterminada invoca el método sincrónico ExecuteScalar() y devuelve una tarea completada, bloqueando el subproceso de llamada. La implementación predeterminada devolverá una tarea cancelada si se pasa un token de cancelación ya cancelado. Las excepciones producidas por ExecuteScalar se comunicarán mediante la propiedad Task Exception devuelta.

No invoque otros métodos y propiedades del objeto DbCommand hasta que se haya completado la tarea devuelta.

(Heredado de DbCommand)
ExecuteXmlReader()

Envía CommandText a Connection y crea un objeto XmlReader.

ExecuteXmlReaderAsync()

Una versión asincrónica de ExecuteXmlReader(), que envía la propiedad CommandText a la propiedad Connection y compila un objeto XmlReader.

Las excepciones se mostrarán a través del objeto Task devuelto.

ExecuteXmlReaderAsync(CancellationToken)

Una versión asincrónica de ExecuteXmlReader(), que envía la propiedad CommandText a la propiedad Connection y compila un objeto XmlReader.

Token de cancelación que se puede usar para solicitar que se abandone la operación antes de que transcurra el tiempo de espera del comando. Las excepciones se mostrarán a través del objeto Task devuelto.

GetHashCode()

Sirve como la función hash predeterminada.

(Heredado de Object)
GetLifetimeService()
Obsoletos.

Recupera el objeto de servicio de duración actual que controla la directiva de duración de esta instancia.

(Heredado de MarshalByRefObject)
GetService(Type)

Devuelve un objeto que representa el servicio suministrado por Component o por Container.

(Heredado de Component)
GetType()

Obtiene el Type de la instancia actual.

(Heredado de Object)
InitializeLifetimeService()
Obsoletos.

Obtiene un objeto de servicio de duración para controlar la directiva de duración de esta instancia.

(Heredado de MarshalByRefObject)
MemberwiseClone()

Crea una copia superficial del Object actual.

(Heredado de Object)
MemberwiseClone(Boolean)

Crea una copia superficial del objeto MarshalByRefObject actual.

(Heredado de MarshalByRefObject)
Prepare()

Crea una versión preparada del comando en una instancia de SQL Server.

PrepareAsync(CancellationToken)

Crea de forma asincrónica una versión preparada (o compilada) del comando en el origen de datos.

(Heredado de DbCommand)
ResetCommandTimeout()

Restablece el valor predeterminado de la propiedad CommandTimeout.

ToString()

Devuelve una cadena que representa el objeto actual.

(Heredado de Object)
ToString()

Devuelve una String que contiene el nombre del Component, si existe. Este método no se debe invalidar.

(Heredado de Component)

Eventos

Disposed

Tiene lugar cuando una llamada elimina el componente mediante una llamada al método Dispose().

(Heredado de Component)
StatementCompleted

Se produce cuando finaliza la ejecución de una instrucción Transact-SQL.

Implementaciones de interfaz explícitas

ICloneable.Clone()

Crea un nuevo objeto SqlCommand que es una copia de la instancia actual.

IDbCommand.Connection

Obtiene o establece la interfaz IDbConnection que usa esta instancia de IDbCommand.

(Heredado de DbCommand)
IDbCommand.CreateParameter()

Crea una nueva instancia de un objeto SqlParameter.

IDbCommand.CreateParameter()

Crea una nueva instancia de un objeto IDbDataParameter .

(Heredado de DbCommand)
IDbCommand.ExecuteReader()

Envía la propiedad CommandText a la propiedad Connection y compila un objeto SqlDataReader.

IDbCommand.ExecuteReader()

Ejecuta CommandText contra Connection y genera IDataReader.

(Heredado de DbCommand)
IDbCommand.ExecuteReader(CommandBehavior)

Envía CommandText a Connection y crea un SqlDataReader mediante uno de los valores de CommandBehavior.

IDbCommand.ExecuteReader(CommandBehavior)

Ejecuta CommandText contra Connection y genera IDataReader mediante uno de los valores de CommandBehavior.

(Heredado de DbCommand)
IDbCommand.Parameters

Obtiene la estructura IDataParameterCollection.

(Heredado de DbCommand)
IDbCommand.Transaction

Obtiene o establece DbTransaction dentro del cual se ejecuta este objeto DbCommand.

(Heredado de DbCommand)

Se aplica a

Consulte también