SqlCommand Classe

Definizione

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 ref class SqlCommand sealed : System::Data::Common::DbCommand
public ref class SqlCommand sealed : System::ComponentModel::Component, ICloneable, IDisposable, System::Data::IDbCommand
public ref class SqlCommand sealed : System::Data::Common::DbCommand, ICloneable, IDisposable
public sealed class SqlCommand : System.Data.Common.DbCommand, ICloneable
public sealed class SqlCommand : System.Data.Common.DbCommand
public sealed class SqlCommand : System.ComponentModel.Component, ICloneable, IDisposable, System.Data.IDbCommand
public sealed class SqlCommand : System.Data.Common.DbCommand, ICloneable, IDisposable
type SqlCommand = class
    inherit DbCommand
    interface ICloneable
type SqlCommand = class
    inherit DbCommand
type SqlCommand = class
    inherit Component
    interface IDbCommand
    interface IDisposable
    interface ICloneable
type SqlCommand = class
    inherit DbCommand
    interface IDbCommand
    interface ICloneable
    interface IDisposable
Public NotInheritable Class SqlCommand
Inherits DbCommand
Implements ICloneable
Public NotInheritable Class SqlCommand
Inherits DbCommand
Public NotInheritable Class SqlCommand
Inherits Component
Implements ICloneable, IDbCommand, IDisposable
Public NotInheritable Class SqlCommand
Inherits DbCommand
Implements ICloneable, IDisposable
Ereditarietà
SqlCommand
Ereditarietà
Ereditarietà
Implementazioni

Esempio

Nell'esempio seguente vengono creati SqlConnection un oggetto , un oggetto e un oggetto SqlCommand SqlDataReader . L'esempio legge i dati, scrivendoli nella console. Infine, l'esempio chiude SqlDataReader e quindi SqlConnection l'oggetto quando esce da blocchi Using di codice.

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

L'esempio seguente illustra come creare ed eseguire diversi tipi di oggetti SqlCommand.

Prima di tutto è 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  

Successivamente, compilare ed eseguire quanto segue:

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

Commenti

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

SqlCommandsono disponibili i metodi seguenti per l'esecuzione di comandi in SQL Server database:

Elemento Descrizione
BeginExecuteNonQuery Avvia l'esecuzione asincrona dell'istruzione Transact-SQL o del stored procedure descritto da , in genere eseguendo comandi quali SqlCommand istruzioni INSERT, DELETE, UPDATE e SET. Ogni chiamata a BeginExecuteNonQuery deve essere associata a una chiamata a EndExecuteNonQuery che termina l'operazione, in genere in un thread separato.
BeginExecuteReader Avvia l'esecuzione asincrona dell'istruzione Transact-SQL o stored procedure descritta da questo oggetto e recupera uno o più set di SqlCommand risultati dal server. Ogni chiamata a BeginExecuteReader deve essere associata a una chiamata a EndExecuteReader che 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 deve essere associata a una chiamata a , che completa l'operazione, in genere su un BeginExecuteXmlReader EndExecuteXmlReader thread separato, e restituisce un oggetto XmlReader .
ExecuteReader Esegue i comandi che restituiscono righe. Per migliorare le prestazioni, ExecuteReader richiama i comandi usando l'SQL transact-stored procedure. sp_executesql Pertanto, potrebbe non avere l'effetto desiderato se usato per eseguire comandi come ExecuteReader transact-SQL istruzioni SET.
ExecuteNonQuery Esegue comandi quali 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 SqlDataReader prima di poter eseguire un comando nuovo o precedente.

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

Nota

I parametri senza nome, detti anche ordinali, non sono supportati dal .NET Framework provider di dati 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 classe SqlCommand con il testo della query e un oggetto SqlConnection.

SqlCommand(String, SqlConnection, SqlTransaction)

Inizializza una nuova istanza della classe SqlCommand con il testo della query, un oggetto SqlConnection e l'oggetto 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à

CanRaiseEvents

Ottiene un valore che indica se il componente può generare un evento.

(Ereditato da Component)
ColumnEncryptionSetting

Ottiene o imposta l'impostazione di crittografia delle colonne 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.

CommandType

Ottiene o imposta un valore che indica come interpretare la proprietà CommandText.

Connection

Ottiene o imposta l'oggetto SqlConnection usato da questa istanza dell'oggetto SqlCommand.

Container

Ottiene l'oggetto IContainer che contiene Component.

(Ereditato da Component)
DbConnection

In caso di override in una classe derivata, ottiene o imposta la DbConnection usata da questo DbCommand.

(Ereditato da DbCommand)
DbParameterCollection

In caso di override in una classe derivata, ottiene la raccolta di oggetti DbParameter.

(Ereditato da DbCommand)
DbTransaction

In caso di override in una classe derivata, ottiene o imposta la DbTransaction all'interno della quale viene eseguito questo oggetto DbCommand.

(Ereditato da DbCommand)
DesignMode

Ottiene un valore che indica se il Component si trova in modalità progettazione.

(Ereditato da Component)
DesignTimeVisible

Ottiene o imposta un valore che indica se l'oggetto comando deve essere visualizzato in un controllo Progettazione Windows Form.

Events

Ottiene l'elenco dei gestori eventi allegati a questo Component.

(Ereditato da Component)
Notification

Ottiene o imposta un valore che specifica l'oggetto SqlNotificationRequest associato a questo comando.

NotificationAutoEnlist

Ottiene o imposta un valore che indica se l'applicazione deve ricevere automaticamente le notifiche di query da un oggetto SqlDependency comune.

Parameters

Ottiene l'oggetto SqlParameterCollection.

Site

Ottiene o imposta l'oggetto ISite di Component.

(Ereditato da Component)
Transaction

Ottiene o imposta l'oggetto SqlTransaction in cui viene eseguito SqlCommand.

UpdatedRowSource

Ottiene o imposta la modalità di applicazione dei risultati del comando all'oggetto quando DataRow 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 dall'oggetto SqlCommand, in base a una routine di callback e alle informazioni sullo stato.

BeginExecuteReader()

Avvia l'esecuzione asincrona dell'istruzione Transact-SQL o della stored procedure descritta da SqlCommand e recupera uno o più set di risultati dal server.

BeginExecuteReader(AsyncCallback, Object)

Avvia l'esecuzione asincrona dell'istruzione Transact-SQL o della stored procedure descritta dall'oggetto SqlCommand e recupera uno o più set di risultati dal server, in base alla routine di callback e alle informazioni sullo stato.

BeginExecuteReader(AsyncCallback, Object, CommandBehavior)

Avvia l'esecuzione asincrona dell'istruzione o della stored procedure Transact-SQL descritta da SqlCommand, usando uno dei valori di CommandBehavior e recuperando uno o più set di risultati dal server, in base a una routine di callback e alle 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()

Prova ad annullare l'esecuzione di SqlCommand.

Clone()

Crea un nuovo oggetto SqlCommand che è una copia dell'istanza corrente.

CreateDbParameter()

In caso di override in una classe derivata, crea una nuova istanza di un oggetto DbParameter.

(Ereditato da DbCommand)
CreateObjRef(Type)

Consente di creare un oggetto che contiene tutte le informazioni rilevanti necessarie per la generazione del proxy utilizzato per effettuare la comunicazione con un oggetto remoto.

(Ereditato da MarshalByRefObject)
CreateParameter()

Crea una nuova istanza di un oggetto SqlParameter.

Dispose()

Esegue attività definite dall'applicazione, come rilasciare o reimpostare risorse non gestite.

(Ereditato da DbCommand)
Dispose()

Rilascia tutte le risorse usate da Component.

(Ereditato da Component)
Dispose(Boolean)

Rilascia le risorse non gestite usate da DbCommand e, facoltativamente, le risorse gestite.

(Ereditato da DbCommand)
Dispose(Boolean)

Rilascia le risorse non gestite usate da Component e, facoltativamente, le risorse gestite.

(Ereditato da Component)
DisposeAsync()

Elimina in modo asincrono l'oggetto comando.

(Ereditato da DbCommand)
EndExecuteNonQuery(IAsyncResult)

Completa l'esecuzione asincrona di un'istruzione Transact-SQL.

EndExecuteReader(IAsyncResult)

Completa 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.

Equals(Object)

Determina se l'oggetto specificato è uguale all'oggetto corrente.

(Ereditato da Object)
ExecuteDbDataReader(CommandBehavior)

In caso di override in una classe derivata, esegue il testo del comando sulla connessione.

(Ereditato da DbCommand)
ExecuteDbDataReaderAsync(CommandBehavior, CancellationToken)

I provider devono implementare questo metodo per fornire un'implementazione non predefinita per gli overload di ExecuteReader .

L'implementazione predefinita richiama il metodo sincrono ExecuteReader() e restituisce un'attività completata, bloccando il thread chiamante. L'implementazione predefinita restituirà un'attività annullata se viene passato un token di annullamento già annullato. Le eccezioni generate da ExecuteReader verranno passate mediante la proprietà Task Exception restituita.

Questo metodo accetta un token di annullamento che può essere utilizzato per richiedere che l'operazione venga annullata in anticipo. Le implementazioni possono ignorare la richiesta.

(Ereditato da DbCommand)
ExecuteNonQuery()

Permette di eseguire un'istruzione Transact-SQL in base alla connessione e restituisce un numero di righe modificate.

ExecuteNonQueryAsync()

Versione asincrona di ExecuteNonQuery(), che esegue un'istruzione SQL a fronte di un oggetto di connessione.

Richiama ExecuteNonQueryAsync(CancellationToken) con CancellationToken.None.

(Ereditato da DbCommand)
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.

ExecuteNonQueryAsync(CancellationToken)

Si tratta della versione asincrona di ExecuteNonQuery(). I provider devono eseguire l'override con un'implementazione appropriata. Il token di annullamento può facoltativamente essere ignorato.

L'implementazione predefinita richiama il metodo sincrono ExecuteNonQuery() e restituisce un'attività completata, bloccando il thread chiamante. L'implementazione predefinita restituirà un'attività annullata se viene passato un token di annullamento già annullato. Le eccezioni generate da ExecuteNonQuery() verranno passate mediante la proprietà Task Exception restituita.

Non richiamare altri metodi e proprietà dell'oggetto DbCommand finché l'attività restituita non viene completata.

(Ereditato da DbCommand)
ExecuteReader()

Invia CommandText a Connection e compila SqlDataReader.

ExecuteReader(CommandBehavior)

Invia CommandText a Connection e compila SqlDataReader mediante uno dei valori di CommandBehavior.

ExecuteReaderAsync()

Versione asincrona di ExecuteReader(), che invia CommandText a Connection e compila un oggetto SqlDataReader. Le eccezioni verranno segnalate tramite l'oggetto attività restituito.

ExecuteReaderAsync()

Versione asincrona di ExecuteReader, che esegue CommandText in un Connection e restituisce un DbDataReader

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

(Ereditato da DbCommand)
ExecuteReaderAsync(CancellationToken)

Versione asincrona di ExecuteReader(), che invia CommandText a Connection 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(CancellationToken)

Versione asincrona di ExecuteReader, che esegue CommandText in un Connection e restituisce un DbDataReader Questo metodo propaga la notifica di richiesta di annullamento delle operazioni.

Richiama ExecuteDbDataReaderAsync(CommandBehavior, CancellationToken).

(Ereditato da DbCommand)
ExecuteReaderAsync(CommandBehavior)

Versione asincrona di ExecuteReader(CommandBehavior), che invia CommandText a Connection e compila un oggetto SqlDataReader. Le eccezioni verranno segnalate tramite l'oggetto attività restituito.

ExecuteReaderAsync(CommandBehavior)

Versione asincrona di ExecuteReader, che esegue CommandText in un Connection e restituisce un DbDataReader

Richiama ExecuteDbDataReaderAsync(CommandBehavior, CancellationToken).

(Ereditato da DbCommand)
ExecuteReaderAsync(CommandBehavior, CancellationToken)

Versione asincrona di ExecuteReader(CommandBehavior), che invia CommandText a Connection 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, CancellationToken)

Richiama ExecuteDbDataReaderAsync(CommandBehavior, CancellationToken).

(Ereditato da DbCommand)
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()

Una versione asincrona di ExecuteScalar() che esegue la query e restituisce la prima colonna della prima riga nel set di risultati restituito dalla query. Tutte le altre righe e colonne vengono ignorate.

Richiama ExecuteScalarAsync(CancellationToken) con CancellationToken.None.

(Ereditato da DbCommand)
ExecuteScalarAsync(CancellationToken)

Versione asincrona di ExecuteScalar(), che esegue la query in modo asincrono e restituisce la prima colonna della prima riga nel set di 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.

ExecuteScalarAsync(CancellationToken)

Si tratta della versione asincrona di ExecuteScalar(). I provider devono eseguire l'override con un'implementazione appropriata. Il token di annullamento può facoltativamente essere ignorato.

L'implementazione predefinita richiama il metodo sincrono ExecuteScalar() e restituisce un'attività completata, bloccando il thread chiamante. L'implementazione predefinita restituirà un'attività annullata se viene passato un token di annullamento già annullato. Le eccezioni generate da ExecuteScalar verranno passate mediante la proprietà Task Exception restituita.

Non richiamare altri metodi e proprietà dell'oggetto DbCommand finché l'attività restituita non viene completata.

(Ereditato da DbCommand)
ExecuteXmlReader()

Invia la proprietà CommandText alla proprietà Connection e compila un oggetto XmlReader.

ExecuteXmlReaderAsync()

Versione asincrona di ExecuteXmlReader(), che invia CommandText a Connection e compila un oggetto XmlReader.

Le eccezioni verranno segnalate tramite l'oggetto attività restituito.

ExecuteXmlReaderAsync(CancellationToken)

Versione asincrona di ExecuteXmlReader(), che invia CommandText a Connection e compila un oggetto XmlReader.

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.

GetHashCode()

Funge da funzione hash predefinita.

(Ereditato da Object)
GetLifetimeService()
Obsoleta.

Consente di recuperare l'oggetto servizio di durata corrente per controllare i criteri di durata per l'istanza.

(Ereditato da MarshalByRefObject)
GetService(Type)

Consente di restituire un oggetto che rappresenta un servizio fornito da Component o dal relativo Container.

(Ereditato da Component)
GetType()

Ottiene l'oggetto Type dell'istanza corrente.

(Ereditato da Object)
InitializeLifetimeService()
Obsoleta.

Ottiene un oggetto servizio di durata per controllare i criteri di durata per questa istanza.

(Ereditato da MarshalByRefObject)
MemberwiseClone()

Crea una copia superficiale dell'oggetto Object corrente.

(Ereditato da Object)
MemberwiseClone(Boolean)

Crea una copia dei riferimenti dell'oggetto MarshalByRefObject corrente.

(Ereditato da MarshalByRefObject)
Prepare()

Crea una versione preparata del comando in un'istanza di SQL Server.

PrepareAsync(CancellationToken)

Crea una versione preparata (o compilata) del comando nell'origine dati in modo asincrono.

(Ereditato da DbCommand)
ResetCommandTimeout()

Reimposta il valore predefinito della proprietà CommandTimeout.

ToString()

Restituisce una stringa che rappresenta l'oggetto corrente.

(Ereditato da Object)
ToString()

Restituisce un oggetto String che contiene il nome dell'eventuale oggetto Component. Questo metodo non deve essere sottoposto a override.

(Ereditato da Component)

Eventi

Disposed

Si verifica quando il componente viene eliminato da una chiamata al metodo Dispose().

(Ereditato da Component)
StatementCompleted

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

Implementazioni dell'interfaccia esplicita

ICloneable.Clone()

Crea un nuovo oggetto SqlCommand che è una copia dell'istanza corrente.

IDbCommand.Connection

Ottiene o imposta l'oggetto IDbConnection usato da questa istanza dell'oggetto IDbCommand.

(Ereditato da DbCommand)
IDbCommand.CreateParameter()

Crea una nuova istanza di un oggetto SqlParameter.

IDbCommand.CreateParameter()

Crea una nuova istanza di un oggetto IDbDataParameter .

(Ereditato da DbCommand)
IDbCommand.ExecuteReader()

Invia l'oggetto CommandText all'oggetto Connection e compila un oggetto SqlDataReader.

IDbCommand.ExecuteReader()

Esegue la proprietà CommandText su Connection e compila IDataReader.

(Ereditato da DbCommand)
IDbCommand.ExecuteReader(CommandBehavior)

Invia CommandText a Connection e compila SqlDataReader mediante uno dei valori di CommandBehavior.

IDbCommand.ExecuteReader(CommandBehavior)

Esegue la proprietà CommandText su Connection e compila IDataReader usando uno dei valori di CommandBehavior.

(Ereditato da DbCommand)
IDbCommand.Parameters

Ottiene l'oggetto IDataParameterCollection.

(Ereditato da DbCommand)
IDbCommand.Transaction

Ottiene o imposta la proprietà DbTransaction in cui viene eseguito questo oggetto DbCommand.

(Ereditato da DbCommand)

Si applica a

Vedi anche