SqlCommand Třída

Definice

Představuje příkaz Transact-SQL nebo uloženou proceduru, která se má provést v databázi SQL Server.Represents a Transact-SQL statement or stored procedure to execute against a SQL Server database. Tuto třídu nelze zdědit.This class cannot be inherited.

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
Dědičnost
SqlCommand
Dědičnost
Dědičnost
Implementuje

Příklady

Následující příklad vytvoří, a SqlConnection SqlCommand , a SqlDataReader .The following example creates a SqlConnection, a SqlCommand, and a SqlDataReader. Tento příklad čte data a zapisuje je do konzoly.The example reads through the data, writing it to the console. Nakonec příklad ukončí SqlDataReader a pak SqlConnection při ukončení Using bloků kódu.Finally, the example closes the SqlDataReader and then the SqlConnection as it exits the Using code blocks.

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

Následující příklad ukazuje, jak vytvořit a spustit různé typy objektů SqlCommand.The following sample shows how to create and execute different types of SqlCommand objects.

Nejprve musíte vytvořit ukázkovou databázi spuštěním následujícího skriptu:First you must create the sample database, by executing the following script:

USE [master]  
GO  

CREATE DATABASE [MySchool]  
GO  

USE [MySchool]  
GO  

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

GO  

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

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

GO  

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

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

END  
GO  

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

GO  

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

GO  

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

GO  

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

GO  

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

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

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

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

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

Dále zkompilujte a spusťte následující:Next, compile and execute the following:

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

Poznámky

Když SqlCommand je vytvořena instance, vlastnosti pro čtení a zápis jsou nastaveny na jejich počáteční hodnoty.When an instance of SqlCommand is created, the read/write properties are set to their initial values. Seznam těchto hodnot naleznete v SqlCommand konstruktoru.For a list of these values, see the SqlCommand constructor.

SqlCommand funkce pro spouštění příkazů ve SQL Server databázi nabízí následující metody:SqlCommand features the following methods for executing commands at a SQL Server database:

PoložkaItem PopisDescription
BeginExecuteNonQuery Inicializuje asynchronní spuštění příkazu jazyka Transact-SQL nebo uložené procedury, která je popsána v tomto tématu, což obvykle spouští příkazy, jako jsou příkazy SqlCommand INSERT, DELETE, Update a set.Initiates the asynchronous execution of the Transact-SQL statement or stored procedure that is described by this SqlCommand, generally executing commands such as INSERT, DELETE, UPDATE, and SET statements. Každé volání BeginExecuteNonQuery musí být spárováno s voláním EndExecuteNonQuery , které dokončí operaci, obvykle v samostatném vlákně.Each call to BeginExecuteNonQuery must be paired with a call to EndExecuteNonQuery which finishes the operation, typically on a separate thread.
BeginExecuteReader Inicializuje asynchronní spuštění příkazu jazyka Transact-SQL nebo uložené procedury, která je popsána tímto SqlCommand a načte jednu nebo více sad výsledků ze serveru.Initiates the asynchronous execution of the Transact-SQL statement or stored procedure that is described by this SqlCommand and retrieves one or more results sets from the server. Každé volání BeginExecuteReader musí být spárováno s voláním EndExecuteReader , které dokončí operaci, obvykle v samostatném vlákně.Each call to BeginExecuteReader must be paired with a call to EndExecuteReader which finishes the operation, typically on a separate thread.
BeginExecuteXmlReader Inicializuje asynchronní spuštění příkazu jazyka Transact-SQL nebo uložené procedury, která je popsána v tomto SqlCommand .Initiates the asynchronous execution of the Transact-SQL statement or stored procedure that is described by this SqlCommand. Každé volání BeginExecuteXmlReader musí být spárováno s voláním EndExecuteXmlReader , které dokončí operaci, obvykle v samostatném vlákně a vrátí XmlReader objekt.Each call to BeginExecuteXmlReader must be paired with a call to EndExecuteXmlReader, which finishes the operation, typically on a separate thread, and returns an XmlReader object.
ExecuteReader Spustí příkazy, které vracejí řádky.Executes commands that return rows. Pro zvýšení výkonu ExecuteReader vyvolá příkazy pomocí uložené procedury systému Transact-SQL sp_executesql .For increased performance, ExecuteReader invokes commands using the Transact-SQL sp_executesql system stored procedure. Proto ExecuteReader by neměl mít efekt, který chcete použít ke spuštění příkazů, jako jsou příkazy sady Transact-SQL.Therefore, ExecuteReader might not have the effect that you want if used to execute commands such as Transact-SQL SET statements.
ExecuteNonQuery Spouští příkazy, jako příkazy jazyka Transact-SQL INSERT, DELETE, UPDATE a SET.Executes commands such as Transact-SQL INSERT, DELETE, UPDATE, and SET statements.
ExecuteScalar Načte jednu hodnotu (například agregační hodnotu) z databáze.Retrieves a single value (for example, an aggregate value) from a database.
ExecuteXmlReader Odešle CommandText do Connection a vytvoří XmlReader objekt.Sends the CommandText to the Connection and builds an XmlReader object.

Můžete obnovit CommandText vlastnost a znovu použít SqlCommand objekt.You can reset the CommandText property and reuse the SqlCommand object. SqlDataReaderPředtím, než můžete spustit nový nebo předchozí příkaz, je však nutné zavřít.However, you must close the SqlDataReader before you can execute a new or previous command.

Pokud SqlException je generovaný metodou SqlCommand , SqlConnection zůstane otevřené, když je úroveň závažnosti 19 nebo menší.If a SqlException is generated by the method executing a SqlCommand, the SqlConnection remains open when the severity level is 19 or less. Pokud je úroveň závažnosti 20 nebo vyšší, Server obvykle zavře SqlConnection .When the severity level is 20 or greater, the server ordinarily closes the SqlConnection. Uživatel však může připojení znovu otevřít a pokračovat.However, the user can reopen the connection and continue.

Poznámka

Nameless Zprostředkovatel dat pro SQL Server nepodporuje .NET Framework, které jsou označovány také jako ordinální, parametry.Nameless, also called ordinal, parameters are not supported by the .NET Framework Data Provider for SQL Server.

Konstruktory

SqlCommand()

Inicializuje novou instanci SqlCommand třídy.Initializes a new instance of the SqlCommand class.

SqlCommand(String)

Inicializuje novou instanci SqlCommand třídy textem dotazu.Initializes a new instance of the SqlCommand class with the text of the query.

SqlCommand(String, SqlConnection)

Inicializuje novou instanci SqlCommand třídy textem dotazu a SqlConnection .Initializes a new instance of the SqlCommand class with the text of the query and a SqlConnection.

SqlCommand(String, SqlConnection, SqlTransaction)

Inicializuje novou instanci SqlCommand třídy textem dotazu, a SqlConnection a SqlTransaction .Initializes a new instance of the SqlCommand class with the text of the query, a SqlConnection, and the SqlTransaction.

SqlCommand(String, SqlConnection, SqlTransaction, SqlCommandColumnEncryptionSetting)

Inicializuje novou instanci SqlCommand třídy se zadaným textem příkazu, připojením, transakcí a nastavením šifrování.Initializes a new instance of the SqlCommand class with specified command text, connection, transaction, and encryption setting.

Vlastnosti

CanRaiseEvents

Získá hodnotu, která označuje, zda může komponenta vyvolat událost.Gets a value indicating whether the component can raise an event.

(Zděděno od Component)
ColumnEncryptionSetting

Získá nebo nastaví nastavení šifrování sloupce pro tento příkaz.Gets or sets the column encryption setting for this command.

CommandText

Získá nebo nastaví příkaz Transact-SQL, název tabulky nebo uloženou proceduru, která má být provedena ve zdroji dat.Gets or sets the Transact-SQL statement, table name or stored procedure to execute at the data source.

CommandTimeout

Získá nebo nastaví dobu čekání (v sekundách) před ukončením pokusu o spuštění příkazu a vygenerováním chyby.Gets or sets the wait time (in seconds) before terminating the attempt to execute a command and generating an error.

CommandType

Získává nebo nastavuje hodnotu, která indikuje, jak se má CommandText vlastnost interpretovat.Gets or sets a value indicating how the CommandText property is to be interpreted.

Connection

Získá nebo nastaví SqlConnection použitou tuto instanci SqlCommand .Gets or sets the SqlConnection used by this instance of the SqlCommand.

Container

Získá IContainer , který obsahuje Component .Gets the IContainer that contains the Component.

(Zděděno od Component)
DbConnection

Při přepsání v odvozené třídě získá nebo nastaví hodnotu DbConnection použitou tímto DbCommand .When overridden in a derived class, gets or sets the DbConnection used by this DbCommand.

(Zděděno od DbCommand)
DbParameterCollection

Při přepsání v odvozené třídě získá kolekci DbParameter objektů.When overridden in a derived class, gets the collection of DbParameter objects.

(Zděděno od DbCommand)
DbTransaction

Při přepsání v odvozené třídě získává nebo nastavuje, DbTransaction ve kterém se tento DbCommand objekt spustí.When overridden in a derived class, gets or sets the DbTransaction within which this DbCommand object executes.

(Zděděno od DbCommand)
DesignMode

Načte hodnotu, která označuje, zda Component je aktuálně v režimu návrhu.Gets a value that indicates whether the Component is currently in design mode.

(Zděděno od Component)
DesignTimeVisible

Získá nebo nastaví hodnotu označující, zda by měl být objekt příkazu viditelný v ovládacím prvku Windows Form Designer.Gets or sets a value indicating whether the command object should be visible in a Windows Form Designer control.

Events

Získá seznam obslužných rutin událostí, které jsou k tomuto typu připojeny Component .Gets the list of event handlers that are attached to this Component.

(Zděděno od Component)
Notification

Získá nebo nastaví hodnotu, která určuje SqlNotificationRequest objekt vázaný na tento příkaz.Gets or sets a value that specifies the SqlNotificationRequest object bound to this command.

NotificationAutoEnlist

Získává nebo nastavuje hodnotu, která označuje, jestli má aplikace automaticky přijímat oznámení dotazů ze společného SqlDependency objektu.Gets or sets a value indicating whether the application should automatically receive query notifications from a common SqlDependency object.

Parameters

Získá SqlParameterCollection .Gets the SqlParameterCollection.

Site

Získá nebo nastaví ISite z Component .Gets or sets the ISite of the Component.

(Zděděno od Component)
Transaction

Získá nebo nastaví, SqlTransaction ve kterém se má SqlCommand vykoná.Gets or sets the SqlTransaction within which the SqlCommand executes.

UpdatedRowSource

Získá nebo nastaví způsob, jakým jsou použity výsledky příkazu pro metodu, která je DataRow použita metodou aktualizace DbDataAdapter .Gets or sets how command results are applied to the DataRow when used by the Update method of the DbDataAdapter.

Metody

BeginExecuteNonQuery()

Inicializuje asynchronní spuštění příkazu jazyka Transact-SQL nebo uložené procedury, která je popsána v tomto SqlCommand .Initiates the asynchronous execution of the Transact-SQL statement or stored procedure that is described by this SqlCommand.

BeginExecuteNonQuery(AsyncCallback, Object)

Inicializuje asynchronní spuštění příkazu jazyka Transact-SQL nebo uložené procedury, která je popsána s SqlCommand ohledem na proceduru zpětného volání a informace o stavu.Initiates the asynchronous execution of the Transact-SQL statement or stored procedure that is described by this SqlCommand, given a callback procedure and state information.

BeginExecuteReader()

Inicializuje asynchronní spuštění příkazu jazyka Transact-SQL nebo uložené procedury, která je popsána tímto SqlCommand a načte jednu nebo více sad výsledků dotazu ze serveru.Initiates the asynchronous execution of the Transact-SQL statement or stored procedure that is described by this SqlCommand, and retrieves one or more result sets from the server.

BeginExecuteReader(AsyncCallback, Object)

Inicializuje asynchronní spuštění příkazu jazyka Transact-SQL nebo uložené procedury, která je popsána tímto SqlCommand a načte jednu nebo více sad výsledků dotazu ze serveru za základě procedury zpětného volání a informací o stavu.Initiates the asynchronous execution of the Transact-SQL statement or stored procedure that is described by this SqlCommand and retrieves one or more result sets from the server, given a callback procedure and state information.

BeginExecuteReader(AsyncCallback, Object, CommandBehavior)

Inicializuje asynchronní spuštění příkazu jazyka Transact-SQL nebo uložené procedury, které jsou popsány pomocí SqlCommand jedné z CommandBehavior hodnot a načítají jednu nebo více sad výsledků dotazu ze serveru, a to s ohledem na proceduru zpětného volání a informace o stavu.Initiates the asynchronous execution of the Transact-SQL statement or stored procedure that is described by this SqlCommand, using one of the CommandBehavior values, and retrieving one or more result sets from the server, given a callback procedure and state information.

BeginExecuteReader(CommandBehavior)

Inicializuje asynchronní spuštění příkazu jazyka Transact-SQL nebo uložené procedury, která je popsána SqlCommand pomocí jedné z CommandBehavior hodnot.Initiates the asynchronous execution of the Transact-SQL statement or stored procedure that is described by this SqlCommand using one of the CommandBehavior values.

BeginExecuteXmlReader()

Inicializuje asynchronní spuštění příkazu jazyka Transact-SQL nebo uložené procedury, která je popsána tímto SqlCommand a vrátí výsledky jako XmlReader objekt.Initiates the asynchronous execution of the Transact-SQL statement or stored procedure that is described by this SqlCommand and returns results as an XmlReader object.

BeginExecuteXmlReader(AsyncCallback, Object)

Inicializuje asynchronní spuštění příkazu jazyka Transact-SQL nebo uložené procedury, která je popsána tímto SqlCommand a vrátí výsledky jako XmlReader objekt pomocí procedury zpětného volání.Initiates the asynchronous execution of the Transact-SQL statement or stored procedure that is described by this SqlCommand and returns results as an XmlReader object, using a callback procedure.

Cancel()

Pokusí se zrušit provádění SqlCommand .Tries to cancel the execution of a SqlCommand.

Clone()

Vytvoří nový SqlCommand objekt, který je kopií aktuální instance.Creates a new SqlCommand object that is a copy of the current instance.

CreateDbParameter()

Při přepsání v odvozené třídě vytvoří novou instanci DbParameter objektu.When overridden in a derived class, creates a new instance of a DbParameter object.

(Zděděno od DbCommand)
CreateObjRef(Type)

Vytvoří objekt, který obsahuje všechny relevantní informace požadované pro vygenerování proxy serveru, který se používá ke komunikaci se vzdáleným objektem.Creates an object that contains all the relevant information required to generate a proxy used to communicate with a remote object.

(Zděděno od MarshalByRefObject)
CreateParameter()

Vytvoří novou instanci SqlParameter objektu.Creates a new instance of a SqlParameter object.

Dispose()

Provede aplikací definované úlohy spojené s uvolněním nebo resetováním nespravovaných prostředků.Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.

(Zděděno od DbCommand)
Dispose()

Uvolní všechny prostředky, které používá Component .Releases all resources used by the Component.

(Zděděno od Component)
Dispose(Boolean)

Uvolní nespravované prostředky používané DbCommand a volitelně uvolňuje spravované prostředky.Releases the unmanaged resources used by the DbCommand and optionally releases the managed resources.

(Zděděno od DbCommand)
Dispose(Boolean)

Uvolní nespravované prostředky používané Component a volitelně uvolňuje spravované prostředky.Releases the unmanaged resources used by the Component and optionally releases the managed resources.

(Zděděno od Component)
DisposeAsync()

Asynchronně vynutí objekt příkazu.Asynchronously diposes the command object.

(Zděděno od DbCommand)
EndExecuteNonQuery(IAsyncResult)

Dokončí asynchronní provádění příkazu jazyka Transact-SQL.Finishes asynchronous execution of a Transact-SQL statement.

EndExecuteReader(IAsyncResult)

Dokončení asynchronního spuštění příkazu jazyka Transact-SQL, který vrátí požadovanou hodnotu SqlDataReader .Finishes asynchronous execution of a Transact-SQL statement, returning the requested SqlDataReader.

EndExecuteXmlReader(IAsyncResult)

Provede asynchronní spuštění příkazu jazyka Transact-SQL, který vrátí požadovaná data jako XML.Finishes asynchronous execution of a Transact-SQL statement, returning the requested data as XML.

Equals(Object)

Určí, zda se zadaný objekt rovná aktuálnímu objektu.Determines whether the specified object is equal to the current object.

(Zděděno od Object)
ExecuteDbDataReader(CommandBehavior)

Při přepsání v odvozené třídě spustí text příkazu proti připojení.When overridden in a derived class, executes the command text against the connection.

(Zděděno od DbCommand)
ExecuteDbDataReaderAsync(CommandBehavior, CancellationToken)

Poskytovatelé by měli implementovat tuto metodu, aby poskytovala nevýchozí implementaci pro ExecuteReader přetížení.Providers should implement this method to provide a non-default implementation for ExecuteReader overloads.

Výchozí implementace vyvolá synchronní ExecuteReader() metodu a vrátí dokončenou úlohu, která blokuje volající vlákno.The default implementation invokes the synchronous ExecuteReader() method and returns a completed task, blocking the calling thread. Výchozí implementace vrátí zrušenou úlohu, je-li předána již zrušený token zrušení.The default implementation will return a cancelled task if passed an already cancelled cancellation token. Výjimky vyvolané funkcí ExecuteReader budou sděleny prostřednictvím vrácené vlastnosti Exception úlohy.Exceptions thrown by ExecuteReader will be communicated via the returned Task Exception property.

Tato metoda přijímá token zrušení, který lze použít k žádosti o zrušení operace, která bude brzy zrušena.This method accepts a cancellation token that can be used to request the operation to be cancelled early. Implementace mohou tuto žádost ignorovat.Implementations may ignore this request.

(Zděděno od DbCommand)
ExecuteNonQuery()

Provede příkaz Transact-SQL pro připojení a vrátí počet ovlivněných řádků.Executes a Transact-SQL statement against the connection and returns the number of rows affected.

ExecuteNonQueryAsync()

Asynchronní verze nástroje ExecuteNonQuery() , která spouští příkaz SQL pro objekt připojení.An asynchronous version of ExecuteNonQuery(), which executes a SQL statement against a connection object.

Vyvolá ExecuteNonQueryAsync(CancellationToken) se s CancellationToken. None.Invokes ExecuteNonQueryAsync(CancellationToken) with CancellationToken.None.

(Zděděno od DbCommand)
ExecuteNonQueryAsync(CancellationToken)

Asynchronní verze ExecuteNonQuery() , která spustí příkaz Transact-SQL pro připojení a vrátí počet ovlivněných řádků.An asynchronous version of ExecuteNonQuery(), which executes a Transact-SQL statement against the connection and returns the number of rows affected. Token zrušení lze použít k vyžádání, že operace bude opuštěna před uplynutím časového limitu příkazu.The cancellation token can be used to request that the operation be abandoned before the command timeout elapses. Výjimky budou hlášeny prostřednictvím vráceného objektu Task.Exceptions will be reported via the returned Task object.

ExecuteNonQueryAsync(CancellationToken)

Toto je asynchronní verze ExecuteNonQuery() .This is the asynchronous version of ExecuteNonQuery(). Poskytovatelé by měli přepsat příslušnou implementací.Providers should override with an appropriate implementation. Token zrušení se může volitelně ignorovat.The cancellation token may optionally be ignored.

Výchozí implementace vyvolá synchronní ExecuteNonQuery() metodu a vrátí dokončenou úlohu, která blokuje volající vlákno.The default implementation invokes the synchronous ExecuteNonQuery() method and returns a completed task, blocking the calling thread. Výchozí implementace vrátí zrušenou úlohu, je-li předána již zrušený token zrušení.The default implementation will return a cancelled task if passed an already cancelled cancellation token. Výjimky vyvolané nástrojem ExecuteNonQuery() budou sděleny přes vrácenou vlastnost Exception úlohy.Exceptions thrown by ExecuteNonQuery() will be communicated via the returned Task Exception property.

Nevolejte jiné metody a vlastnosti DbCommand objektu, dokud není vrácen dokončený úkol.Do not invoke other methods and properties of the DbCommand object until the returned Task is complete.

(Zděděno od DbCommand)
ExecuteReader()

Odešle CommandText do Connection a sestavení a SqlDataReader .Sends the CommandText to the Connection and builds a SqlDataReader.

ExecuteReader(CommandBehavior)

Odešle do a sestaví CommandText Connection SqlDataReader pomocí jedné z CommandBehavior hodnot.Sends the CommandText to the Connection, and builds a SqlDataReader using one of the CommandBehavior values.

ExecuteReaderAsync()

Asynchronní verze nástroje ExecuteReader() , která odesílá CommandText do Connection a sestavení a SqlDataReader .An asynchronous version of ExecuteReader(), which sends the CommandText to the Connection and builds a SqlDataReader. Výjimky budou hlášeny prostřednictvím vráceného objektu Task.Exceptions will be reported via the returned Task object.

ExecuteReaderAsync()

Asynchronní verze nástroje ExecuteReader , která provede příkaz s CommandText Connection a vrátí DbDataReader .An asynchronous version of ExecuteReader, which executes the CommandText against the Connection and returns a DbDataReader.

Vyvolá ExecuteDbDataReaderAsync(CommandBehavior, CancellationToken) se s CancellationToken. None.Invokes ExecuteDbDataReaderAsync(CommandBehavior, CancellationToken) with CancellationToken.None.

(Zděděno od DbCommand)
ExecuteReaderAsync(CancellationToken)

Asynchronní verze nástroje ExecuteReader() , která odesílá CommandText do Connection a sestavení a SqlDataReader .An asynchronous version of ExecuteReader(), which sends the CommandText to the Connection and builds a SqlDataReader.

Token zrušení lze použít k vyžádání, že operace bude opuštěna před uplynutím časového limitu příkazu.The cancellation token can be used to request that the operation be abandoned before the command timeout elapses. Výjimky budou hlášeny prostřednictvím vráceného objektu Task.Exceptions will be reported via the returned Task object.

ExecuteReaderAsync(CancellationToken)

Asynchronní verze nástroje ExecuteReader , která provede příkaz s CommandText Connection a vrátí DbDataReader .An asynchronous version of ExecuteReader, which executes the CommandText against the Connection and returns a DbDataReader. Tato metoda šíří oznámení, že operace by se měly zrušit.This method propagates a notification that operations should be canceled.

Vyvolá ExecuteDbDataReaderAsync(CommandBehavior, CancellationToken) .Invokes ExecuteDbDataReaderAsync(CommandBehavior, CancellationToken).

(Zděděno od DbCommand)
ExecuteReaderAsync(CommandBehavior)

Asynchronní verze nástroje ExecuteReader(CommandBehavior) , která odesílá CommandText do Connection a sestavení a SqlDataReader .An asynchronous version of ExecuteReader(CommandBehavior), which sends the CommandText to the Connection, and builds a SqlDataReader. Výjimky budou hlášeny prostřednictvím vráceného objektu Task.Exceptions will be reported via the returned Task object.

ExecuteReaderAsync(CommandBehavior)

Asynchronní verze nástroje ExecuteReader , která provede příkaz s CommandText Connection a vrátí DbDataReader .An asynchronous version of ExecuteReader, which executes the CommandText against the Connection and returns a DbDataReader.

Vyvolá ExecuteDbDataReaderAsync(CommandBehavior, CancellationToken) .Invokes ExecuteDbDataReaderAsync(CommandBehavior, CancellationToken).

(Zděděno od DbCommand)
ExecuteReaderAsync(CommandBehavior, CancellationToken)

Asynchronní verze nástroje ExecuteReader(CommandBehavior) , která odesílá do a CommandText Connection sestavení SqlDataReaderAn asynchronous version of ExecuteReader(CommandBehavior), which sends the CommandText to the Connection, and builds a SqlDataReader

Token zrušení lze použít k vyžádání, že operace bude opuštěna před uplynutím časového limitu příkazu.The cancellation token can be used to request that the operation be abandoned before the command timeout elapses. Výjimky budou hlášeny prostřednictvím vráceného objektu Task.Exceptions will be reported via the returned Task object.

ExecuteReaderAsync(CommandBehavior, CancellationToken)

Vyvolá ExecuteDbDataReaderAsync(CommandBehavior, CancellationToken) .Invokes ExecuteDbDataReaderAsync(CommandBehavior, CancellationToken).

(Zděděno od DbCommand)
ExecuteScalar()

Spustí dotaz a vrátí první sloupec prvního řádku v sadě výsledků dotazu vráceným dotazem.Executes the query, and returns the first column of the first row in the result set returned by the query. Další sloupce nebo řádky jsou ignorovány.Additional columns or rows are ignored.

ExecuteScalarAsync()

Asynchronní verze ExecuteScalar() , která spustí dotaz a vrátí první sloupec prvního řádku v sadě výsledků dotazu vráceného dotazem.An asynchronous version of ExecuteScalar(), which executes the query and returns the first column of the first row in the result set returned by the query. Všechny ostatní sloupce a řádky jsou ignorovány.All other columns and rows are ignored.

Vyvolá ExecuteScalarAsync(CancellationToken) se s CancellationToken. None.Invokes ExecuteScalarAsync(CancellationToken) with CancellationToken.None.

(Zděděno od DbCommand)
ExecuteScalarAsync(CancellationToken)

Asynchronní verze ExecuteScalar() , která provede asynchronní dotaz a vrátí první sloupec prvního řádku v sadě výsledků dotazu vráceným dotazem.An asynchronous version of ExecuteScalar(), which executes the query asynchronously and returns the first column of the first row in the result set returned by the query. Další sloupce nebo řádky jsou ignorovány.Additional columns or rows are ignored.

Token zrušení lze použít k vyžádání, že operace bude opuštěna před uplynutím časového limitu příkazu.The cancellation token can be used to request that the operation be abandoned before the command timeout elapses. Výjimky budou hlášeny prostřednictvím vráceného objektu Task.Exceptions will be reported via the returned Task object.

ExecuteScalarAsync(CancellationToken)

Toto je asynchronní verze ExecuteScalar() .This is the asynchronous version of ExecuteScalar(). Poskytovatelé by měli přepsat příslušnou implementací.Providers should override with an appropriate implementation. Token zrušení se může volitelně ignorovat.The cancellation token may optionally be ignored.

Výchozí implementace vyvolá synchronní ExecuteScalar() metodu a vrátí dokončenou úlohu, která blokuje volající vlákno.The default implementation invokes the synchronous ExecuteScalar() method and returns a completed task, blocking the calling thread. Výchozí implementace vrátí zrušenou úlohu, je-li předána již zrušený token zrušení.The default implementation will return a cancelled task if passed an already cancelled cancellation token. Výjimky vyvolané funkcí ExecuteScalar budou sděleny prostřednictvím vrácené vlastnosti Exception úlohy.Exceptions thrown by ExecuteScalar will be communicated via the returned Task Exception property.

Nevolejte jiné metody a vlastnosti DbCommand objektu, dokud není vrácen dokončený úkol.Do not invoke other methods and properties of the DbCommand object until the returned Task is complete.

(Zděděno od DbCommand)
ExecuteXmlReader()

Odešle CommandText do Connection a vytvoří XmlReader objekt.Sends the CommandText to the Connection and builds an XmlReader object.

ExecuteXmlReaderAsync()

Asynchronní verze nástroje ExecuteXmlReader() , která odesílá CommandText do Connection a vytvoří XmlReader objekt.An asynchronous version of ExecuteXmlReader(), which sends the CommandText to the Connection and builds an XmlReader object.

Výjimky budou hlášeny prostřednictvím vráceného objektu Task.Exceptions will be reported via the returned Task object.

ExecuteXmlReaderAsync(CancellationToken)

Asynchronní verze nástroje ExecuteXmlReader() , která odesílá CommandText do Connection a vytvoří XmlReader objekt.An asynchronous version of ExecuteXmlReader(), which sends the CommandText to the Connection and builds an XmlReader object.

Token zrušení lze použít k vyžádání, že operace bude opuštěna před uplynutím časového limitu příkazu.The cancellation token can be used to request that the operation be abandoned before the command timeout elapses. Výjimky budou hlášeny prostřednictvím vráceného objektu Task.Exceptions will be reported via the returned Task object.

GetHashCode()

Slouží jako výchozí funkce hash.Serves as the default hash function.

(Zděděno od Object)
GetLifetimeService()
Zastaralé.

Načte aktuální objekt služby životnosti, který řídí zásady životního cyklu pro tuto instanci.Retrieves the current lifetime service object that controls the lifetime policy for this instance.

(Zděděno od MarshalByRefObject)
GetService(Type)

Vrátí objekt, který představuje službu poskytnutou Component nebo podle jeho Container .Returns an object that represents a service provided by the Component or by its Container.

(Zděděno od Component)
GetType()

Získá Type aktuální instanci.Gets the Type of the current instance.

(Zděděno od Object)
InitializeLifetimeService()
Zastaralé.

Získá objekt služby životnosti, který řídí zásady životního cyklu pro tuto instanci.Obtains a lifetime service object to control the lifetime policy for this instance.

(Zděděno od MarshalByRefObject)
MemberwiseClone()

Vytvoří kopii aktuálního seznamu Object .Creates a shallow copy of the current Object.

(Zděděno od Object)
MemberwiseClone(Boolean)

Vytvoří kopii aktuálního objektu bez podstruktury MarshalByRefObject .Creates a shallow copy of the current MarshalByRefObject object.

(Zděděno od MarshalByRefObject)
Prepare()

Vytvoří připravenou verzi příkazu na instanci SQL Server.Creates a prepared version of the command on an instance of SQL Server.

PrepareAsync(CancellationToken)

Asynchronně vytvoří připravené (nebo kompilované) verze příkazu na zdroji dat.Asynchronously creates a prepared (or compiled) version of the command on the data source.

(Zděděno od DbCommand)
ResetCommandTimeout()

Obnoví CommandTimeout výchozí hodnotu vlastnosti.Resets the CommandTimeout property to its default value.

ToString()

Vrátí řetězec, který představuje aktuální objekt.Returns a string that represents the current object.

(Zděděno od Object)
ToString()

Vrátí hodnotu String obsahující název Component , pokud existuje.Returns a String containing the name of the Component, if any. Tato metoda by neměla být přepsána.This method should not be overridden.

(Zděděno od Component)

Události

Disposed

Nastane, pokud je komponenta uvolněna voláním Dispose() metody.Occurs when the component is disposed by a call to the Dispose() method.

(Zděděno od Component)
StatementCompleted

Nastane, pokud se dokončí provádění příkazu jazyka Transact-SQL.Occurs when the execution of a Transact-SQL statement completes.

Explicitní implementace rozhraní

ICloneable.Clone()

Vytvoří nový SqlCommand objekt, který je kopií aktuální instance.Creates a new SqlCommand object that is a copy of the current instance.

IDbCommand.Connection

Získá nebo nastaví IDbConnection použitou tuto instanci IDbCommand .Gets or sets the IDbConnection used by this instance of the IDbCommand.

(Zděděno od DbCommand)
IDbCommand.CreateParameter()

Vytvoří novou instanci SqlParameter objektu.Creates a new instance of a SqlParameter object.

IDbCommand.CreateParameter()

Vytvoří novou instanci IDbDataParameter objektu.Creates a new instance of an IDbDataParameter object.

(Zděděno od DbCommand)
IDbCommand.ExecuteReader()

Odešle CommandText do Connection , a vytvoří SqlDataReader .Sends the CommandText to the Connection, and builds a SqlDataReader.

IDbCommand.ExecuteReader()

Provede CommandText Connection a vytvoří IDataReader .Executes the CommandText against the Connection and builds an IDataReader.

(Zděděno od DbCommand)
IDbCommand.ExecuteReader(CommandBehavior)

Odešle do a sestaví CommandText Connection SqlDataReader pomocí jedné z CommandBehavior hodnot.Sends the CommandText to the Connection, and builds a SqlDataReader using one of the CommandBehavior values.

IDbCommand.ExecuteReader(CommandBehavior)

Provede CommandText Connection a vytvoří IDataReader pomocí jedné z CommandBehavior hodnot.Executes the CommandText against the Connection, and builds an IDataReader using one of the CommandBehavior values.

(Zděděno od DbCommand)
IDbCommand.Parameters

Získá IDataParameterCollection .Gets the IDataParameterCollection.

(Zděděno od DbCommand)
IDbCommand.Transaction

Získá nebo nastaví, DbTransaction ve kterém se tento DbCommand objekt spustí.Gets or sets the DbTransaction within which this DbCommand object executes.

(Zděděno od DbCommand)

Platí pro