SqlCommand Classe

Définition

Espace de noms:

Microsoft.Data.SqlClient

Assembly:

Microsoft.Data.SqlClient.dll

Paquet:

Microsoft.Data.SqlClient v5.2.0

Représente une instruction Transact-SQL ou une procédure stockée à exécuter par rapport à une base de données SQL Server. Cette classe ne peut pas être héritée.

public ref class SqlCommand sealed : System::Data::Common::DbCommand, ICloneable

public sealed class SqlCommand : System.Data.Common.DbCommand, ICloneable

type SqlCommand = class
    inherit DbCommand
    interface ICloneable

Public NotInheritable Class SqlCommand
Inherits DbCommand
Implements ICloneable

Héritage

DbCommand

SqlCommand

Implémente

ICloneable

Exemples

L’exemple suivant crée un SqlConnection, un SqlCommandet un SqlDataReader. L’exemple lit les données et les écrit dans la console. Enfin, l’exemple ferme le SqlDataReader , puis le SqlConnection à mesure qu’il quitte les blocs de Using code.

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


namespace SqlCommandCS
{
    class Program
    {
        static void Main()
        {
            string str = "Data Source=(local);Initial Catalog=Northwind;"
                + "Integrated Security=SSPI";
            ReadOrderData(str);

        }

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

L’exemple suivant montre comment créer et exécuter différents types d’objets SqlCommand.

Tout d’abord, vous devez créer l’exemple de base de données en exécutant le script suivant :

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

Ensuite, compilez et exécutez les opérations suivantes :

using System;
using System.Data;
using Microsoft.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;";

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

Remarques

Lorsqu’une instance de SqlCommand est créée, les propriétés en lecture/écriture sont définies sur leurs valeurs initiales. Pour obtenir la liste de ces valeurs, consultez le SqlCommand constructeur.

SqlCommandpropose les méthodes suivantes pour exécuter des commandes sur une base de données SQL Server :

Élément	Description
BeginExecuteNonQuery	Lance l’exécution asynchrone de l’instruction Transact-SQL ou de la procédure stockée décrite par ce SqlCommand, en exécutant généralement des commandes telles que les instructions INSERT, DELETE, UPDATE et SET. Chaque appel à BeginExecuteNonQuery doit être associé à un appel à EndExecuteNonQuery qui termine l’opération, généralement sur un thread distinct.
BeginExecuteReader	Lance l’exécution asynchrone de l’instruction Transact-SQL ou de la procédure stockée décrite par et SqlCommand récupère un ou plusieurs jeux de résultats du serveur. Chaque appel à BeginExecuteReader doit être associé à un appel à EndExecuteReader qui termine l’opération, généralement sur un thread distinct.
BeginExecuteXmlReader	Lance l’exécution asynchrone de l’instruction Transact-SQL ou de la procédure stockée qui est décrite par ce SqlCommand. Chaque appel à BeginExecuteXmlReader doit être associé à un appel à EndExecuteXmlReader, ce qui termine l’opération, généralement sur un thread distinct, et retourne un XmlReader objet .
ExecuteReader	Exécute des commandes qui retournent des lignes. Pour améliorer les performances, ExecuteReader appelle des commandes à l’aide de la procédure stockée système Transact-SQL sp_executesql . Par conséquent, ExecuteReader peut ne pas avoir l’effet souhaité si utilisé pour exécuter des commandes telles que des instructions Transact-SQL SET.
ExecuteNonQuery	Exécute des commandes telles que les instructions Transact-SQL INSERT, DELETE, UPDATE et SET.
ExecuteScalar	Récupère une valeur unique (par exemple, une valeur d’agrégation) à partir d’une base de données.
ExecuteXmlReader	Envoie CommandText à Connection et génère un objet XmlReader.

Vous pouvez réinitialiser la CommandText propriété et réutiliser l’objet SqlCommand . Toutefois, vous devez fermer avant de SqlDataReader pouvoir exécuter une nouvelle commande ou une commande précédente.

Si un SqlException est généré par la méthode exécutant un SqlCommand, le SqlConnection reste ouvert lorsque le niveau de gravité est inférieur ou égal à 19. Lorsque le niveau de gravité est égal ou supérieur à 20, le serveur ferme généralement le SqlConnection. L'utilisateur peut toutefois rouvrir la connexion et continuer.

Notes

Les paramètres sans nom, également appelés ordinal, ne sont pas pris en charge par le fournisseur de données .NET Framework pour SQL Server.

Constructeurs

SqlCommand()	Initialise une nouvelle instance de la classe SqlCommand.
SqlCommand(String)	Initialise une nouvelle instance de la classe SqlCommand avec le texte de la requête.
SqlCommand(String, SqlConnection)	Initialise une nouvelle instance de la SqlCommand classe avec le texte de la requête et un SqlConnection .
SqlCommand(String, SqlConnection, SqlTransaction)	Initialise une nouvelle instance de la SqlCommand classe avec le texte de la requête, un SqlConnection et le SqlTransaction .
SqlCommand(String, SqlConnection, SqlTransaction, SqlCommandColumnEncryptionSetting)	Initialise une nouvelle instance de la classe SqlCommand avec le texte de commande, la connexion, la transaction et le paramètre de chiffrement spécifiés.

Propriétés

ColumnEncryptionSetting	Obtient le paramètre de chiffrement de colonne pour cette commande.
CommandText	Obtient ou définit l'instruction Transact-SQL, le nom de table ou la procédure stockée à exécuter au niveau de la source de données.
CommandTimeout	Obtient ou définit le délai d’attente (en secondes) avant de mettre fin à la tentative d’exécution d’une commande et de générer une erreur. La valeur par défaut est 30 secondes.
CommandType	Obtient ou définit une valeur indiquant la manière dont la propriété CommandText doit être interprétée.
Connection	Obtient ou définit le SqlConnection utilisé par cette instance du SqlCommand .
DesignTimeVisible	Obtient ou définit une valeur indiquant si l'objet command doit être visible dans un contrôle du concepteur Windows Form.
EnableOptimizedParameterBinding	Obtient ou définit une valeur indiquant si l’objet de commande doit optimiser les performances des paramètres en désactivant les directions Output et InputOutput lors de l’envoi de la commande au SQL Server.
Notification	Obtient ou définit une valeur qui spécifie l’objet SqlNotificationRequest lié à cette commande.
Parameters	Obtient le SqlParameterCollection .
RetryLogicProvider	Obtient ou définit une valeur qui spécifie l’objet SqlRetryLogicBaseProvider lié à cette commande.
Transaction	Obtient ou définit l'objet SqlTransaction dans lequel SqlCommand s'exécute.
UpdatedRowSource	Obtient ou définit la manière dont les résultats des commandes sont appliqués à DataRow quand ils sont utilisés par la méthode Update de DbDataAdapter.

Méthodes

BeginExecuteNonQuery()	Lance l’exécution asynchrone de l’instruction Transact-SQL ou de la procédure stockée décrite par ce SqlCommand .
BeginExecuteNonQuery(AsyncCallback, Object)	Lance l’exécution asynchrone de l’instruction Transact-SQL ou de la procédure stockée décrite par ce SqlCommand , en fonction d’une procédure de rappel et d’informations d’état.
BeginExecuteReader()	Lance l’exécution asynchrone de l’instruction Transact-SQL ou de la procédure stockée décrite par ce SqlCommand et retourne les résultats sous forme d’objet XmlReader.
BeginExecuteReader(AsyncCallback, Object)	Lance l’exécution asynchrone de l’instruction Transact-SQL ou de la procédure stockée qui est décrite par cet SqlCommand et retourne les résultats en tant qu’objet XmlReader à l’aide d’une procédure de rappel.
BeginExecuteReader(AsyncCallback, Object, CommandBehavior)	Lance l’exécution asynchrone de l’instruction Transact-SQL ou de la procédure stockée décrite par ce SqlCommand , à l’aide de l’un des élémentsCommandBehavior et la récupération d’un ou plusieurs jeux de résultats à partir du serveur, en fonction d’une procédure de rappel et d’informations d’état.
BeginExecuteReader(CommandBehavior)	Lance l’exécution asynchrone de l’instruction Transact-SQL ou de la procédure stockée qui est décrite par ce SqlCommand à l’aide de l’une des valeurs de CommandBehavior.
BeginExecuteXmlReader()	Lance l’exécution asynchrone de l’instruction Transact-SQL ou de la procédure stockée décrite par ce SqlCommand et retourne les résultats sous forme d’objet XmlReader.
BeginExecuteXmlReader(AsyncCallback, Object)	Lance l’exécution asynchrone de l’instruction Transact-SQL ou de la procédure stockée qui est décrite par cet SqlCommand et retourne les résultats en tant qu’objet XmlReader à l’aide d’une procédure de rappel.
Cancel()	Tente d’annuler l’exécution d’un SqlCommand .
Clone()	Crée un nouvel objet SqlCommand qui est une copie de l'instance actuelle.
CreateParameter()	Crée une nouvelle instance d'un objet SqlParameter.
EndExecuteNonQuery(IAsyncResult)	Termine l'exécution asynchrone d'une instruction Transact-SQL.
EndExecuteReader(IAsyncResult)	Termine l’exécution asynchrone d’une instruction Transact-SQL, en retournant le demandé SqlDataReader .
EndExecuteXmlReader(IAsyncResult)	Termine l'exécution asynchrone d'une instruction Transact-SQL en retournant les données demandées en XML.
ExecuteNonQuery()	Exécute une instruction Transact-SQL sur la connexion et retourne le nombre de lignes affectées.
ExecuteNonQueryAsync(CancellationToken)	Version asynchrone de ExecuteNonQuery() , qui exécute une instruction Transact-SQL sur la connexion et retourne le nombre de lignes affectées. Le jeton d'annulation peut être utilisé pour demander que l'opération soit abandonnée avant que le délai d'attente de commande s'écoule. Les exceptions seront signalées via l’objet Task retourné.
ExecuteReader()	Envoie à CommandText et Connection génère un SqlDataReader .
ExecuteReader(CommandBehavior)	Envoie à CommandText et Connection génère un SqlDataReader à l’aide de l’une CommandBehavior des valeurs .
ExecuteReaderAsync()	Version asynchrone de ExecuteReader() , qui envoie le CommandText à et Connection génère un SqlDataReader . Les exceptions seront signalées via l’objet Task retourné.
ExecuteReaderAsync(CancellationToken)	Version asynchrone de ExecuteReader() , qui envoie le CommandText à et Connection génère un SqlDataReader . Le jeton d'annulation peut être utilisé pour demander que l'opération soit abandonnée avant que le délai d'attente de commande s'écoule. Les exceptions seront signalées via l’objet Task retourné.
ExecuteReaderAsync(CommandBehavior)	Une version asynchrone de ExecuteReader(CommandBehavior) , qui envoie le CommandText à et Connection génère un SqlDataReader . Les exceptions seront signalées via l’objet Task retourné.
ExecuteReaderAsync(CommandBehavior, CancellationToken)	Une version asynchrone de , qui envoie le CommandText à et Connection génère un SqlDataReader jeton d’annulation Peut être utilisée pour demander l’abandon de ExecuteReader(CommandBehavior) l’opération avant l’expiration du délai d’expiration de la commande. Les exceptions seront signalées via l’objet Task retourné.
ExecuteScalar()	Exécute la requête et retourne la première colonne de la première ligne dans le jeu de résultats retourné par la requête. Les colonnes ou lignes supplémentaires sont ignorées.
ExecuteScalarAsync(CancellationToken)	Version asynchrone de ExecuteScalar() , qui exécute la requête de manière asynchrone et retourne la première colonne de la première ligne du jeu de résultats retourné par la requête. Les colonnes ou lignes supplémentaires sont ignorées. Le jeton d'annulation peut être utilisé pour demander que l'opération soit abandonnée avant que le délai d'attente de commande s'écoule. Les exceptions seront signalées via l’objet Task retourné.
ExecuteXmlReader()	Envoie CommandText à Connection et génère un objet XmlReader.
ExecuteXmlReaderAsync()	Version asynchrone de ExecuteXmlReader() , qui envoie le CommandText à et Connection génère un XmlReader objet . Les exceptions seront signalées via l’objet Task retourné.
ExecuteXmlReaderAsync(CancellationToken)	Version asynchrone de ExecuteXmlReader() , qui envoie le CommandText à et Connection génère un XmlReader objet . Le jeton d'annulation peut être utilisé pour demander que l'opération soit abandonnée avant que le délai d'attente de commande s'écoule. Les exceptions seront signalées via l’objet Task retourné.
Prepare()	Crée une version préparée de la commande sur une instance de SQL Server.
RegisterColumnEncryptionKeyStoreProvidersOnCommand(IDictionary<String,SqlColumnEncryptionKeyStoreProvider>)	Inscrit les fournisseurs de magasins de clés de chiffrement sur l’instance SqlCommand . Si cette fonction a été appelée, tous les fournisseurs inscrits à l’aide des RegisterColumnEncryptionKeyStoreProviders(IDictionary<String,SqlColumnEncryptionKeyStoreProvider>) méthodes ou RegisterColumnEncryptionKeyStoreProvidersOnConnection(IDictionary<String,SqlColumnEncryptionKeyStoreProvider>) sont ignorés. Cette fonction peut être appelée plusieurs fois. Cette opération effectue une copie superficielle du dictionnaire afin que l’application ne puisse pas modifier la liste des fournisseurs personnalisés une fois qu’elle a été définie.
ResetCommandTimeout()	Rétablit la valeur par défaut de la propriété CommandTimeout.

Événements

StatementCompleted

Se produit quand l'exécution d'une instruction Transact-SQL se termine.

Implémentations d’interfaces explicites

ICloneable.Clone()

Représente une instruction Transact-SQL ou une procédure stockée à exécuter par rapport à une base de données SQL Server. Cette classe ne peut pas être héritée.