SqlCommand Classe

Definizione

Spazio dei nomi:

Microsoft.Data.SqlClient

Assembly:

Microsoft.Data.SqlClient.dll

Pacchetto:

Microsoft.Data.SqlClient v5.2.0

Rappresenta un'istruzione Transact-SQL o una stored procedure da eseguire in relazione a un database SQL Server. La classe non può essere ereditata.

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

Ereditarietà

DbCommand

SqlCommand

Implementazioni

ICloneable

Esempio

Nell'esempio seguente viene creato un SqlConnectionoggetto , un SqlCommandoggetto e un oggetto SqlDataReader. L'esempio legge i dati, scrivendoli nella console. Infine, l'esempio chiude SqlDataReader e quindi quando SqlConnection esce dai blocchi di Using codice.

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'esempio seguente illustra come creare ed eseguire tipi diversi di oggetti SqlCommand.

Per prima cosa è necessario creare il database di esempio eseguendo lo script seguente:

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

Compilare ed eseguire quindi quanto segue:

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

Commenti

Quando viene creata un'istanza di , le proprietà di SqlCommand lettura/scrittura vengono impostate sui valori iniziali. Per un elenco di questi valori, vedere il SqlCommand costruttore.

SqlCommandinclude i metodi seguenti per l'esecuzione di comandi in un database SQL Server:

Elemento	Descrizione
BeginExecuteNonQuery	Avvia l'esecuzione asincrona dell'istruzione Transact-SQL o della stored procedure descritta da , SqlCommandin genere eseguendo comandi come INSERT, DELETE, UPDATE e SET. Ogni chiamata a BeginExecuteNonQuery deve essere associata a una chiamata a EndExecuteNonQuery cui termina l'operazione, in genere in un thread separato.
BeginExecuteReader	Avvia l'esecuzione asincrona dell'istruzione Transact-SQL o della stored procedure descritta da questo SqlCommand oggetto e recupera uno o più set di risultati dal server. Ogni chiamata a BeginExecuteReader deve essere associata a una chiamata a EndExecuteReader cui termina l'operazione, in genere in un thread separato.
BeginExecuteXmlReader	Avvia l'esecuzione asincrona dell'istruzione Transact-SQL o della stored procedure descritta da SqlCommand. Ogni chiamata a BeginExecuteXmlReader deve essere associata a una chiamata a EndExecuteXmlReader, che completa l'operazione, in genere in un thread separato e restituisce un XmlReader oggetto .
ExecuteReader	Esegue i comandi che restituiscono righe. Per migliorare le prestazioni, ExecuteReader richiama i comandi usando la stored procedure di sistema Transact-SQL sp_executesql . Pertanto, ExecuteReader potrebbe non avere l'effetto desiderato se usato per eseguire comandi come istruzioni Transact-SQL SET.
ExecuteNonQuery	Esegue comandi come istruzioni Transact-SQL INSERT, DELETE, UPDATE e SET.
ExecuteScalar	Recupera un singolo valore (ad esempio, un valore aggregato) da un database.
ExecuteXmlReader	Invia la proprietà CommandText alla proprietà Connection e compila un oggetto XmlReader.

È possibile reimpostare la CommandText proprietà e riutilizzare l'oggetto SqlCommand . Tuttavia, è necessario chiudere prima SqlDataReader di poter eseguire un comando nuovo o precedente.

Se un SqlException oggetto viene generato dal metodo che esegue un SqlCommand, rimane SqlConnection aperto quando il livello di gravità è 19 o minore. Quando il livello di gravità è 20 o superiore, il server chiude normalmente .SqlConnection L'utente può tuttavia riaprire la connessione e continuare.

Nota

I parametri senza nome, detti anche ordinali, non sono supportati dal provider di dati .NET Framework per SQL Server.

Costruttori

SqlCommand()	Inizializza una nuova istanza della classe SqlCommand.
SqlCommand(String)	Inizializza una nuova istanza della classe SqlCommand con il testo della query.
SqlCommand(String, SqlConnection)	Inizializza una nuova istanza della SqlCommand classe con il testo della query e un oggetto SqlConnection .
SqlCommand(String, SqlConnection, SqlTransaction)	Inizializza una nuova istanza della SqlCommand classe con il testo della query, un SqlConnection oggetto e .SqlTransaction
SqlCommand(String, SqlConnection, SqlTransaction, SqlCommandColumnEncryptionSetting)	Inizializza una nuova istanza della classe SqlCommand con l'impostazione specificata per il testo del comando, la connessione, la transazione e la crittografia.

Proprietà

ColumnEncryptionSetting	Ottiene l'impostazione di crittografia della colonna per questo comando.
CommandText	Ottiene o imposta l'istruzione Transact-SQL, il nome di tabella o la stored procedure da eseguire all'origine dati.
CommandTimeout	Ottiene o imposta il tempo di attesa (in secondi) prima di terminare il tentativo di eseguire un comando e generare un errore. Il valore predefinito è 30 secondi.
CommandType	Ottiene o imposta un valore che indica come interpretare la proprietà CommandText.
Connection	Ottiene o imposta l'oggetto SqlConnection utilizzato da questa istanza di SqlCommand .
DesignTimeVisible	Ottiene o imposta un valore che indica se l'oggetto comando deve essere visualizzato in un controllo Progettazione Windows Form.
EnableOptimizedParameterBinding	Ottiene o imposta un valore che indica se l'oggetto comando deve ottimizzare le prestazioni dei parametri disabilitando le istruzioni di Output e InputOutput durante l'invio del comando al SQL Server.
Notification	Ottiene o imposta un valore che specifica l'oggetto SqlNotificationRequest associato a questo comando.
Parameters	Ottiene l'oggetto SqlParameterCollection .
RetryLogicProvider	Ottiene o imposta un valore che specifica l'oggetto SqlRetryLogicBaseProvider associato a questo comando.
Transaction	Ottiene o imposta l'oggetto SqlTransaction in cui viene eseguito SqlCommand.
UpdatedRowSource	Ottiene o imposta la modalità di applicazione dei risultati del comando a DataRow quando viene utilizzato dal metodo Update di DbDataAdapter.

Metodi

BeginExecuteNonQuery()	Avvia l'esecuzione asincrona dell'istruzione Transact-SQL o della stored procedure descritta da .SqlCommand
BeginExecuteNonQuery(AsyncCallback, Object)	Avvia l'esecuzione asincrona dell'istruzione Transact-SQL o della stored procedure descritta da , SqlCommand in base a una routine di callback e informazioni sullo stato.
BeginExecuteReader()	Avvia l'esecuzione asincrona dell'istruzione Transact-SQL o della stored procedure descritta dall'oggetto SqlCommand e restituisce i risultati come oggetto XmlReader.
BeginExecuteReader(AsyncCallback, Object)	Avvia l'esecuzione asincrona dell'istruzione Transact-SQL o della stored procedure descritta dall'oggetto SqlCommand e restituisce i risultati come oggetto XmlReader usando una routine di callback.
BeginExecuteReader(AsyncCallback, Object, CommandBehavior)	Avvia l'esecuzione asincrona dell'istruzione Transact-SQL o della stored procedure descritta da , SqlCommand utilizzando uno deiCommandBehavior valori e recupero di uno o più set di risultati dal server, in base a una routine di callback e informazioni sullo stato.
BeginExecuteReader(CommandBehavior)	Avvia l'esecuzione asincrona dell'istruzione Transact-SQL o della stored procedure descritta dall'oggetto SqlCommand usando uno dei valori CommandBehavior.
BeginExecuteXmlReader()	Avvia l'esecuzione asincrona dell'istruzione Transact-SQL o della stored procedure descritta dall'oggetto SqlCommand e restituisce i risultati come oggetto XmlReader.
BeginExecuteXmlReader(AsyncCallback, Object)	Avvia l'esecuzione asincrona dell'istruzione Transact-SQL o della stored procedure descritta dall'oggetto SqlCommand e restituisce i risultati come oggetto XmlReader usando una routine di callback.
Cancel()	Tenta di annullare l'esecuzione di un oggetto SqlCommand .
Clone()	Crea un nuovo oggetto SqlCommand che è una copia dell'istanza corrente.
CreateParameter()	Crea una nuova istanza di un oggetto SqlParameter.
EndExecuteNonQuery(IAsyncResult)	Completa l'esecuzione asincrona di un'istruzione Transact-SQL.
EndExecuteReader(IAsyncResult)	Termina l'esecuzione asincrona di un'istruzione Transact-SQL, restituendo l'oggetto SqlDataReader richiesto.
EndExecuteXmlReader(IAsyncResult)	Completa l'esecuzione asincrona di un'istruzione Transact-SQL, restituendo i dati richiesti in formato XML.
ExecuteNonQuery()	Permette di eseguire un'istruzione Transact-SQL in base alla connessione e restituisce un numero di righe modificate.
ExecuteNonQueryAsync(CancellationToken)	Versione asincrona di ExecuteNonQuery() , che esegue un'istruzione Transact-SQL sulla connessione e restituisce il numero di righe interessate. Il token di annullamento può essere utilizzato per richiedere che l'operazione venga abbandonata prima del timeout del comando. Le eccezioni verranno segnalate tramite l'oggetto attività restituito.
ExecuteReader()	Invia a CommandTextConnection e compila un oggetto SqlDataReader .
ExecuteReader(CommandBehavior)	Invia a CommandTextConnection e compila un SqlDataReader oggetto utilizzando uno dei CommandBehavior valori .
ExecuteReaderAsync()	Versione asincrona di ExecuteReader() , che invia a ConnectionCommandText e compila un oggetto SqlDataReader . Le eccezioni verranno segnalate tramite l'oggetto attività restituito.
ExecuteReaderAsync(CancellationToken)	Versione asincrona di ExecuteReader() , che invia a ConnectionCommandText e compila un oggetto SqlDataReader . Il token di annullamento può essere utilizzato per richiedere che l'operazione venga abbandonata prima del timeout del comando. Le eccezioni verranno segnalate tramite l'oggetto attività restituito.
ExecuteReaderAsync(CommandBehavior)	Una versione asincrona di ExecuteReader(CommandBehavior) , che invia all'oggetto CommandTextConnection e compila un oggetto SqlDataReader . Le eccezioni verranno segnalate tramite l'oggetto attività restituito.
ExecuteReaderAsync(CommandBehavior, CancellationToken)	Una versione asincrona di ExecuteReader(CommandBehavior) , che invia all'oggetto CommandTextConnection e compila un SqlDataReader token di annullamento può essere usato per richiedere che l'operazione venga abbandonata prima del timeout del comando. Le eccezioni verranno segnalate tramite l'oggetto attività restituito.
ExecuteScalar()	Esegue la query e restituisce la prima colonna della prima riga nel set di risultati restituito dalla query. Eventuali colonne o righe aggiuntive vengono ignorate.
ExecuteScalarAsync(CancellationToken)	Versione asincrona di , che esegue la query in modo asincrono e restituisce la prima colonna della prima riga nel set di ExecuteScalar() risultati restituito dalla query. Eventuali colonne o righe aggiuntive vengono ignorate. Il token di annullamento può essere utilizzato per richiedere che l'operazione venga abbandonata prima del timeout del comando. Le eccezioni verranno segnalate tramite l'oggetto attività restituito.
ExecuteXmlReader()	Invia la proprietà CommandText alla proprietà Connection e compila un oggetto XmlReader.
ExecuteXmlReaderAsync()	Versione asincrona di ExecuteXmlReader() , che invia a ConnectionCommandText e compila un XmlReader oggetto . Le eccezioni verranno segnalate tramite l'oggetto attività restituito.
ExecuteXmlReaderAsync(CancellationToken)	Versione asincrona di ExecuteXmlReader() , che invia a ConnectionCommandText e compila un XmlReader oggetto . Il token di annullamento può essere utilizzato per richiedere che l'operazione venga abbandonata prima del timeout del comando. Le eccezioni verranno segnalate tramite l'oggetto attività restituito.
Prepare()	Crea una versione preparata del comando in un'istanza di SQL Server.
RegisterColumnEncryptionKeyStoreProvidersOnCommand(IDictionary<String,SqlColumnEncryptionKeyStoreProvider>)	Registra i provider dell'archivio chiavi di crittografia nell'istanza SqlCommand di . Se questa funzione è stata chiamata, tutti i provider registrati utilizzando i RegisterColumnEncryptionKeyStoreProviders(IDictionary<String,SqlColumnEncryptionKeyStoreProvider>) metodi o RegisterColumnEncryptionKeyStoreProvidersOnConnection(IDictionary<String,SqlColumnEncryptionKeyStoreProvider>) verranno ignorati. Questa funzione può essere chiamata più volte. Questa operazione esegue una copia superficiale del dizionario in modo che l'app non possa modificare l'elenco di provider personalizzato dopo che è stato impostato.
ResetCommandTimeout()	Reimposta il valore predefinito della proprietà CommandTimeout.

Eventi

StatementCompleted

Si verifica al completamento dell'esecuzione di un'istruzione Transact-SQL.

Implementazioni dell'interfaccia esplicita

ICloneable.Clone()

Rappresenta un'istruzione Transact-SQL o una stored procedure da eseguire in relazione a un database SQL Server. La classe non può essere ereditata.