SqlCommand.BeginExecuteReader SqlCommand.BeginExecuteReader SqlCommand.BeginExecuteReader SqlCommand.BeginExecuteReader Method

Definition

Initiiert die asynchrone Ausführung der Transact-SQL-Anweisung oder der gespeicherten Prozedur, die von diesem SqlCommand beschrieben wird, und ruft ein oder mehrere Resultsets vom Server ab.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.

Überlädt

BeginExecuteReader() BeginExecuteReader() BeginExecuteReader() BeginExecuteReader()

Initiiert die asynchrone Ausführung der Transact-SQL-Anweisung oder der gespeicherten Prozedur, die von diesem SqlCommand beschrieben wird, und ruft ein oder mehrere Resultsets vom Server ab.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(CommandBehavior) BeginExecuteReader(CommandBehavior) BeginExecuteReader(CommandBehavior) BeginExecuteReader(CommandBehavior)

Initiiert die asynchrone Ausführung der Transact-SQL-Anweisung oder der gespeicherten Prozedur, die von diesem SqlCommand unter Verwendung eines der CommandBehavior-Werte beschrieben wird.Initiates the asynchronous execution of the Transact-SQL statement or stored procedure that is described by this SqlCommand using one of the CommandBehavior values.

BeginExecuteReader(AsyncCallback, Object) BeginExecuteReader(AsyncCallback, Object) BeginExecuteReader(AsyncCallback, Object) BeginExecuteReader(AsyncCallback, Object)

Initiiert die asynchrone Ausführung der Transact-SQL-Anweisung oder der gespeicherten Prozedur, die von diesem SqlCommand beschrieben wird, und ruft ein oder mehrere Resultsets vom Server ab, wenn eine Rückrufprozedur und Zustandsinformationen verfügbar sind.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) BeginExecuteReader(AsyncCallback, Object, CommandBehavior) BeginExecuteReader(AsyncCallback, Object, CommandBehavior) BeginExecuteReader(AsyncCallback, Object, CommandBehavior)

Initiiert die asynchrone Ausführung der Transact-SQL-Anweisung oder der gespeicherten Prozedur, die von diesem SqlCommand beschrieben wird, wobei einer der CommandBehavior-Werte verwendet wird und ein oder mehrere Resultsets vom Server abgerufen werden, wenn eine Rückrufprozedur und Zustandsinformationen verfügbar sind.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() BeginExecuteReader() BeginExecuteReader() BeginExecuteReader()

Initiiert die asynchrone Ausführung der Transact-SQL-Anweisung oder der gespeicherten Prozedur, die von diesem SqlCommand beschrieben wird, und ruft ein oder mehrere Resultsets vom Server ab.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.

public:
 IAsyncResult ^ BeginExecuteReader();
public IAsyncResult BeginExecuteReader ();
member this.BeginExecuteReader : unit -> IAsyncResult
Public Function BeginExecuteReader () As IAsyncResult

Gibt zurück

Ein IAsyncResult zum Abfragen von Ergebnissen und/oder Warten auf Ergebnisse. Dieser Wert wird auch zum Aufrufen von EndExecuteReader(IAsyncResult) benötigt, die eine SqlDataReader-Instanz zurückgibt, mit der die zurückgegebenen Zeilen abgerufen werden können.An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndExecuteReader(IAsyncResult), which returns a SqlDataReader instance that can be used to retrieve the returned rows.

Ausnahmen

Es wurde ein anderer SqlDbType als Binary oder VarBinary verwendet, als Value auf Stream festgelegt wurde.A SqlDbType other than Binary or VarBinary was used when Value was set to Stream. Weitere Informationen zum Streaming finden Sie unter SqlClient Streaming Support (SqlClient-Streamingunterstützung).For more information about streaming, see SqlClient Streaming Support.

- oder --or-

Es wurde ein anderer SqlDbType als Char, NChar, NVarChar, VarChar oder Xml verwendet, als Value auf TextReader festgelegt wurde.A SqlDbType other than Char, NChar, NVarChar, VarChar, or Xml was used when Value was set to TextReader.

- oder --or-

Es wurde ein anderer SqlDbType als Xml verwendet, als Value auf XmlReader festgelegt wurde.A SqlDbType other than Xml was used when Value was set to XmlReader.

Alle Fehler, die beim Ausführen des Befehlstexts aufgetreten sind.Any error that occurred while executing the command text.

- oder --or-

Bei einem Streamingvorgang ist ein Timeout aufgetreten.A timeout occurred during a streaming operation. Weitere Informationen zum Streaming finden Sie unter SqlClient-Streamingunterstützung.For more information about streaming, see SqlClient Streaming Support.

Das Name-Wert-Paar "Asynchronous Processing=true" war nicht in der Verbindungszeichenfolge enthalten, mit der die Verbindung für diesen SqlCommand definiert wird.The name/value pair "Asynchronous Processing=true" was not included within the connection string defining the connection for this SqlCommand.

- oder --or-

Die SqlConnection wurde während eines Streamingvorgangs geschlossen oder getrennt.The SqlConnection closed or dropped during a streaming operation. Weitere Informationen zum Streaming finden Sie unter SqlClient Streaming Support (SqlClient-Streamingunterstützung).For more information about streaming, see SqlClient Streaming Support.

Während eines Streamingvorgangs ist bei einem Stream-, XmlReader- oder TextReader-Objekt ein Fehler aufgetreten.An error occurred in a Stream, XmlReader or TextReader object during a streaming operation. Weitere Informationen zum Streaming finden Sie unter SqlClient Streaming Support (SqlClient-Streamingunterstützung).For more information about streaming, see SqlClient Streaming Support.

Das Stream-, XmlReader - oder TextReader -Objekt wurde während eines Streamingvorgangs geschlossen.The Stream, XmlReader or TextReader object was closed during a streaming operation. Weitere Informationen zum Streaming finden Sie unter SqlClient Streaming Support (SqlClient-Streamingunterstützung).For more information about streaming, see SqlClient Streaming Support.

Beispiele

Die folgende Konsolenanwendung startet das asynchrone Abrufen eines Daten Readers.The following console application starts the process of retrieving a data reader asynchronously. Beim Warten auf die Ergebnisse befindet sich diese einfache Anwendung in einer Schleife, die den IsCompleted Eigenschafts Wert untersucht.While waiting for the results, this simple application sits in a loop, investigating the IsCompleted property value. Sobald der Prozess abgeschlossen ist, ruft der Code den SqlDataReader ab und zeigt seinen Inhalt an.As soon as the process has completed, the code retrieves the SqlDataReader and displays its contents.

using System.Data.SqlClient;

class Class1
{
    static void Main()
    {
        // This is a simple example that demonstrates the usage of the 
        // BeginExecuteReader functionality
        // The WAITFOR statement simply adds enough time to prove the 
        // asynchronous nature of the command.
        string commandText =
            "WAITFOR DELAY '00:00:03';" +
            "SELECT LastName, FirstName FROM Person.Contact " +
            "WHERE LastName LIKE 'M%'";

        RunCommandAsynchronously(commandText, GetConnectionString());

        Console.WriteLine("Press ENTER to continue.");
        Console.ReadLine();
    }

    private static void RunCommandAsynchronously(
        string commandText, string connectionString)
    {
        // Given command text and connection string, asynchronously execute
        // the specified command against the connection. For this example,
        // the code displays an indicator as it is working, verifying the 
        // asynchronous behavior. 
        using (SqlConnection connection = new SqlConnection(connectionString))
        {
            try
            {
                SqlCommand command = new SqlCommand(commandText, connection);

                connection.Open();
                IAsyncResult result = command.BeginExecuteReader();

                // Although it is not necessary, the following code
                // displays a counter in the console window, indicating that 
                // the main thread is not blocked while awaiting the command 
                // results.
                int count = 0;
                while (!result.IsCompleted)
                {
                    count += 1;
                    Console.WriteLine("Waiting ({0})", count);
                    // Wait for 1/10 second, so the counter
                    // does not consume all available resources 
                    // on the main thread.
                    System.Threading.Thread.Sleep(100);
                }

                using (SqlDataReader reader = command.EndExecuteReader(result))
                {
                    DisplayResults(reader);
                }
            }
            catch (SqlException ex)
            {
                Console.WriteLine("Error ({0}): {1}", ex.Number, ex.Message);
            }
            catch (InvalidOperationException ex)
            {
                Console.WriteLine("Error: {0}", ex.Message);
            }
            catch (Exception ex)
            {
                // You might want to pass these errors
                // back out to the caller.
                Console.WriteLine("Error: {0}", ex.Message);
            }
        }
    }

    private static void DisplayResults(SqlDataReader reader)
    {
        // Display the data within the reader.
        while (reader.Read())
        {
            // Display all the columns. 
            for (int i = 0; i < reader.FieldCount; i++)
                Console.Write("{0} ", reader.GetValue(i));
            Console.WriteLine();
        }
    }

    private static string GetConnectionString()
    {
        // To avoid storing the connection string in your code,            
        // you can retrieve it from a configuration file. 

        // If you have not included "Asynchronous Processing=true" in the
        // connection string, the command is not able
        // to execute asynchronously.
        return "Data Source=(local);Integrated Security=true;" +
            "Initial Catalog=AdventureWorks; Asynchronous Processing=true";
    }
}
Imports System.Data.SqlClient

Module Module1
    Sub Main()
        ' This is a simple example that demonstrates the usage of the 
        ' BeginExecuteReader functionality.
        ' The WAITFOR statement simply adds enough time to prove the 
        ' asynchronous nature of the command.
        Dim commandText As String = _
         "WAITFOR DELAY '00:00:03';" & _
         "SELECT LastName, FirstName FROM Person.Contact " & _
         "WHERE LastName LIKE 'M%'"

        RunCommandAsynchronously(commandText, GetConnectionString())

        Console.WriteLine("Press ENTER to continue.")
        Console.ReadLine()
    End Sub

    Private Sub RunCommandAsynchronously( _
     ByVal commandText As String, ByVal connectionString As String)

        ' Given command text and connection string, asynchronously execute
        ' the specified command against the connection. For this example,
        ' the code displays an indicator as it is working, verifying the 
        ' asynchronous behavior. 
        Using connection As New SqlConnection(connectionString)
            Try
                Dim command As New SqlCommand(commandText, connection)

                connection.Open()
                Dim result As IAsyncResult = command.BeginExecuteReader()

                ' Although it is not necessary, the following procedure
                ' displays a counter in the console window, indicating that 
                ' the main thread is not blocked while awaiting the command 
                ' results.
                Dim count As Integer
                While Not result.IsCompleted
                    count += 1
                    Console.WriteLine("Waiting ({0})", count)
                    ' Wait for 1/10 second, so the counter
                    ' does not consume all available resources 
                    ' on the main thread.
                    Threading.Thread.Sleep(100)
                End While

                ' Once the IAsyncResult object signals that it is done
                ' waiting for results, you can retrieve the results.
                Using reader As SqlDataReader = command.EndExecuteReader(result)
                    DisplayResults(reader)
                End Using
            Catch ex As SqlException
                Console.WriteLine("Error ({0}): {1}", ex.Number, ex.Message)
            Catch ex As InvalidOperationException
                Console.WriteLine("Error: {0}", ex.Message)
            Catch ex As Exception
                ' You might want to pass these errors
                ' back out to the caller.
                Console.WriteLine("Error: {0}", ex.Message)
            End Try
        End Using
    End Sub

    Private Sub DisplayResults(ByVal reader As SqlDataReader)
        ' Display the data within the reader.
        While reader.Read()
            ' Display all the columns.
            For i As Integer = 0 To reader.FieldCount - 1
                Console.Write("{0} ", reader.GetValue(i))
            Next
            Console.WriteLine()
        End While
    End Sub

    Private Function GetConnectionString() As String
        ' To avoid storing the connection string in your code, 
        ' you can retrieve it from a configuration file. 

        ' If you have not included "Asynchronous Processing=true" in the
        ' connection string, the command is not able
        ' to execute asynchronously.
        Return "Data Source=(local);Integrated Security=true;" & _
          "Initial Catalog=AdventureWorks; Asynchronous Processing=true"
    End Function
End Module

Hinweise

Die BeginExecuteReader -Methode startet die asynchrone Ausführung einer Transact-SQL-Anweisung oder einer gespeicherten Prozedur, die Zeilen zurückgibt, damit andere Tasks gleichzeitig ausgeführt werden können, während die Anweisung ausgeführt wird.The BeginExecuteReader method starts the process of asynchronously executing a Transact-SQL statement or stored procedure that returns rows, so that other tasks can run concurrently while the statement is executing. Wenn die-Anweisung abgeschlossen ist, müssen Entwickler die EndExecuteReader -Methode aufrufen, um den Vorgang abzuschließen SqlDataReader und das vom Befehl zurückgegebene abzurufen.When the statement has completed, developers must call the EndExecuteReader method to finish the operation and retrieve the SqlDataReader returned by the command. Die BeginExecuteReader Methode wird sofort zurückgegeben, aber bis der Code den EndExecuteReader entsprechenden Methodenaufruf ausführt, dürfen keine anderen Aufrufe ausgeführt werden, die eine synchrone oder asynchrone Ausführung für SqlCommand dasselbe Objekt starten.The BeginExecuteReader method returns immediately, but until the code executes the corresponding EndExecuteReader method call, it must not execute any other calls that start a synchronous or asynchronous execution against the same SqlCommand object. Wenn aufgerufen wird, SqlCommand bevordieAusführungdesBefehlsabgeschlossenist,wirddas-Objektblockiert,bisdieAusführungabgeschlossenist.EndExecuteReaderCalling the EndExecuteReader before the command's execution is completed causes the SqlCommand object to block until the execution is finished.

Beachten Sie, dass der Befehls Text und die Parameter synchron an den Server gesendet werden.Note that the command text and parameters are sent to the server synchronously. Wenn ein großer Befehl oder viele Parameter gesendet werden, kann diese Methode während Schreibvorgängen blockiert werden.If a large command or many parameters are sent, this method may block during writes. Nachdem der Befehl gesendet wurde, wird die Methode sofort zurückgegeben, ohne auf eine Antwort vom Server zu warten, d. h., die Lesevorgänge sind asynchron.After the command is sent, the method returns immediately without waiting for an answer from the server--that is, reads are asynchronous. Obwohl die Befehlsausführung asynchron ist, ist das Abrufen von Werten weiterhin synchron.Although command execution is asynchronous, value fetching is still synchronous. Dies bedeutet, dass Aufrufe Read von möglicherweise blockieren, wenn mehr Daten erforderlich sind und der Lesevorgang des zugrunde liegenden Netzwerks blockiert wird.This means that calls to Read may block if more data is required and the underlying network's read operation blocks.

Da diese Überladung keine Rückruf Prozedur unterstützt, müssen Entwickler entweder Abfragen, um zu bestimmen, ob der Befehl abgeschlossen wurde IsCompleted , indem Sie IAsyncResult die-Eigenschaft BeginExecuteReader von verwenden, die von der-Methode zurückgegeben wurde, oder auf den Abschluss von mindestens ein-Befehl, der AsyncWaitHandle die-Eigenschaft des IAsyncResultzurückgegebenen-Objekts verwendet.Because this overload does not support a callback procedure, developers must either poll to determine whether the command has completed, using the IsCompleted property of the IAsyncResult returned by the BeginExecuteReader method; or wait for the completion of one or more commands using the AsyncWaitHandle property of the returned IAsyncResult.

Wenn Sie oder ExecuteReader BeginExecuteReader verwenden, um auf XML-Daten zuzugreifen, gibt SQL Server alle XML-Ergebnisse zurück, die mehr als 2.033 Zeichen lang sind und in mehreren Zeilen mit jeweils 2.033 Zeichen enthalten sind.If you use ExecuteReader or BeginExecuteReader to access XML data, SQL Server will return any XML results greater than 2,033 characters in length in multiple rows of 2,033 characters each. Um dieses Verhalten zu vermeiden, ExecuteXmlReader verwenden BeginExecuteXmlReader Sie oder zum Lesen von for XML-Abfragen.To avoid this behavior, use ExecuteXmlReader or BeginExecuteXmlReader to read FOR XML queries.

Siehe auch

BeginExecuteReader(CommandBehavior) BeginExecuteReader(CommandBehavior) BeginExecuteReader(CommandBehavior) BeginExecuteReader(CommandBehavior)

Initiiert die asynchrone Ausführung der Transact-SQL-Anweisung oder der gespeicherten Prozedur, die von diesem SqlCommand unter Verwendung eines der CommandBehavior-Werte beschrieben wird.Initiates the asynchronous execution of the Transact-SQL statement or stored procedure that is described by this SqlCommand using one of the CommandBehavior values.

public:
 IAsyncResult ^ BeginExecuteReader(System::Data::CommandBehavior behavior);
public IAsyncResult BeginExecuteReader (System.Data.CommandBehavior behavior);
member this.BeginExecuteReader : System.Data.CommandBehavior -> IAsyncResult
Public Function BeginExecuteReader (behavior As CommandBehavior) As IAsyncResult

Parameter

behavior
CommandBehavior CommandBehavior CommandBehavior CommandBehavior

Einer der CommandBehavior-Werte, der Optionen zur Ausführung von Anweisungen und zum Abrufen von Daten festlegt.One of the CommandBehavior values, indicating options for statement execution and data retrieval.

Gibt zurück

Ein IAsyncResult zum Abfragen von Ergebnissen und/oder als Warteschleife. Dieser Wert wird auch zum Aufrufen von EndExecuteReader(IAsyncResult) benötigt, das eine SqlDataReader-Instanz zurückgibt, mit der die zurückgegebenen Zeilen abgerufen werden können.An IAsyncResult that can be used to poll, wait for results, or both; this value is also needed when invoking EndExecuteReader(IAsyncResult), which returns a SqlDataReader instance that can be used to retrieve the returned rows.

Ausnahmen

Es wurde ein anderer SqlDbType als Binary oder VarBinary verwendet, als Value auf Stream festgelegt wurde.A SqlDbType other than Binary or VarBinary was used when Value was set to Stream. Weitere Informationen zum Streaming finden Sie unter SqlClient Streaming Support (SqlClient-Streamingunterstützung).For more information about streaming, see SqlClient Streaming Support.

- oder --or-

Es wurde ein anderer SqlDbType als Char, NChar, NVarChar, VarChar oder Xml verwendet, als Value auf TextReader festgelegt wurde.A SqlDbType other than Char, NChar, NVarChar, VarChar, or Xml was used when Value was set to TextReader.

- oder --or-

Es wurde ein anderer SqlDbType als Xml verwendet, als Value auf XmlReader festgelegt wurde.A SqlDbType other than Xml was used when Value was set to XmlReader.

Alle Fehler, die beim Ausführen des Befehlstexts aufgetreten sind.Any error that occurred while executing the command text.

- oder --or-

Bei einem Streamingvorgang ist ein Timeout aufgetreten.A timeout occurred during a streaming operation. Weitere Informationen zum Streaming finden Sie unter SqlClient-Streamingunterstützung.For more information about streaming, see SqlClient Streaming Support.

Das Name-Wert-Paar "Asynchronous Processing=true" war nicht in der Verbindungszeichenfolge enthalten, mit der die Verbindung für diesen SqlCommand definiert wird.The name/value pair "Asynchronous Processing=true" was not included within the connection string defining the connection for this SqlCommand.

- oder --or-

Die SqlConnection wurde während eines Streamingvorgangs geschlossen oder getrennt.The SqlConnection closed or dropped during a streaming operation. Weitere Informationen zum Streaming finden Sie unter SqlClient Streaming Support (SqlClient-Streamingunterstützung).For more information about streaming, see SqlClient Streaming Support.

Während eines Streamingvorgangs ist bei einem Stream-, XmlReader- oder TextReader-Objekt ein Fehler aufgetreten.An error occurred in a Stream, XmlReader or TextReader object during a streaming operation. Weitere Informationen zum Streaming finden Sie unter SqlClient Streaming Support (SqlClient-Streamingunterstützung).For more information about streaming, see SqlClient Streaming Support.

Das Stream-, XmlReader - oder TextReader -Objekt wurde während eines Streamingvorgangs geschlossen.The Stream, XmlReader or TextReader object was closed during a streaming operation. Weitere Informationen zum Streaming finden Sie unter SqlClient Streaming Support (SqlClient-Streamingunterstützung).For more information about streaming, see SqlClient Streaming Support.

Beispiele

Die folgende Konsolenanwendung startet das asynchrone Abrufen eines Daten Readers.The following console application starts the process of retrieving a data reader asynchronously. Beim Warten auf die Ergebnisse befindet sich diese einfache Anwendung in einer Schleife, die den IsCompleted Eigenschafts Wert untersucht.While waiting for the results, this simple application sits in a loop, investigating the IsCompleted property value. Nachdem der Prozess abgeschlossen wurde, ruft der Code den SqlDataReader ab und zeigt seinen Inhalt an.Once the process has completed, the code retrieves the SqlDataReader and displays its contents.

In diesem Beispiel werden auch CommandBehavior.CloseConnection der CommandBehavior.SingleRow -Wert und der-Wert im Behavior-Parameter übergeben, wodurch die Verbindung SqlDataReader geschlossen wird, wenn die zurückgegebene geschlossen ist, und um das Ergebnis einer einzelnen Zeile zu optimieren.This example also passes the CommandBehavior.CloseConnection and CommandBehavior.SingleRow values in the behavior parameter, causing the connection to be closed with the returned SqlDataReader is closed, and to optimize for a single row result.

using System.Data.SqlClient;
class Class1
{
    static void Main()
    {
        // This example is not terribly useful, but it proves a point.
        // The WAITFOR statement simply adds enough time to prove the 
        // asynchronous nature of the command.
        string commandText = "WAITFOR DELAY '00:00:03';" +
            "SELECT ProductID, Name FROM Production.Product WHERE ListPrice < 100";

        RunCommandAsynchronously(commandText, GetConnectionString());

        Console.WriteLine("Press ENTER to continue.");
        Console.ReadLine();
    }

    private static void RunCommandAsynchronously(
        string commandText, string connectionString)
    {
        // Given command text and connection string, asynchronously execute
        // the specified command against the connection. For this example,
        // the code displays an indicator as it is working, verifying the 
        // asynchronous behavior. 

        try
        {
            // The code does not need to handle closing the connection explicitly--
            // the use of the CommandBehavior.CloseConnection option takes care
            // of that for you. 
            SqlConnection connection = new SqlConnection(connectionString);
            SqlCommand command = new SqlCommand(commandText, connection);

            connection.Open();
            IAsyncResult result = command.BeginExecuteReader(
                CommandBehavior.CloseConnection);

            // Although it is not necessary, the following code
            // displays a counter in the console window, indicating that 
            // the main thread is not blocked while awaiting the command 
            // results.
            int count = 0;
            while (!result.IsCompleted)
            {
                Console.WriteLine("Waiting ({0})", count++);
                // Wait for 1/10 second, so the counter
                // does not consume all available resources 
                // on the main thread.
                System.Threading.Thread.Sleep(100);
            }

            using (SqlDataReader reader = command.EndExecuteReader(result))
            {
                DisplayResults(reader);
            }
        }
        catch (SqlException ex)
        {
            Console.WriteLine("Error ({0}): {1}", ex.Number, ex.Message);
        }
        catch (InvalidOperationException ex)
        {
            Console.WriteLine("Error: {0}", ex.Message);
        }
        catch (Exception ex)
        {
            // You might want to pass these errors
            // back out to the caller.
            Console.WriteLine("Error: {0}", ex.Message);
        }
    }

    private static void DisplayResults(SqlDataReader reader)
    {
        // Display the data within the reader.
        while (reader.Read())
        {
            // Display all the columns. 
            for (int i = 0; i < reader.FieldCount; i++)
            {
                Console.Write("{0}\t", reader.GetValue(i));
            }
            Console.WriteLine();
        }
    }

    private static string GetConnectionString()
    {
        // To avoid storing the connection string in your code,            
        // you can retrieve it from a configuration file. 

        // If you have not included "Asynchronous Processing=true" in the
        // connection string, the command is not able
        // to execute asynchronously.
        return "Data Source=(local);Integrated Security=true;" +
            "Initial Catalog=AdventureWorks; Asynchronous Processing=true";
    }
}
Imports System.Data.SqlClient

Module Module1
    Sub Main()
        ' This example is not terribly useful, but it proves a point.
        ' The WAITFOR statement simply adds enough time to prove the 
        ' asynchronous nature of the command.
        Dim commandText As String = _
         "WAITFOR DELAY '00:00:03';" & _
         "SELECT ProductID, Name FROM Production.Product WHERE ListPrice < 100"

        RunCommandAsynchronously(commandText, GetConnectionString())

        Console.WriteLine("Press ENTER to continue.")
        Console.ReadLine()
    End Sub

    Private Sub RunCommandAsynchronously( _
     ByVal commandText As String, ByVal connectionString As String)

        ' Given command text and connection string, asynchronously execute
        ' the specified command against the connection. For this example,
        ' the code displays an indicator as it is working, verifying the 
        ' asynchronous behavior. 
        Try
            ' The code does not need to handle closing the connection explicitly--
            ' the use of the CommandBehavior.CloseConnection option takes care
            ' of that for you. 
            Dim connection As New SqlConnection(connectionString)
            Dim command As New SqlCommand(commandText, connection)

            connection.Open()
            Dim result As IAsyncResult = _
              command.BeginExecuteReader(CommandBehavior.CloseConnection)

            ' Although it is not necessary, the following code
            ' displays a counter in the console window, indicating that 
            ' the main thread is not blocked while awaiting the command 
            ' results.
            Dim count As Integer = 0
            While Not result.IsCompleted
                count += 1
                Console.WriteLine("Waiting ({0})", count)
                ' Wait for 1/10 second, so the counter
                ' does not consume all available resources 
                ' on the main thread.
                Threading.Thread.Sleep(100)
            End While

            ' The "using" statement closes the SqlDataReader when it is 
            ' done executing.
            Using reader As SqlDataReader = command.EndExecuteReader(result)
                DisplayResults(reader)
            End Using
        Catch ex As SqlException
            Console.WriteLine("Error ({0}): {1}", ex.Number, ex.Message)
        Catch ex As InvalidOperationException
            Console.WriteLine("Error: {0}", ex.Message)
        Catch ex As Exception
            ' You might want to pass these errors
            ' back out to the caller.
            Console.WriteLine("Error: {0}", ex.Message)
        End Try
    End Sub

    Private Sub DisplayResults(ByVal reader As SqlDataReader)
        ' Display the data within the reader.
        While reader.Read()
            ' Display all the columns. 
            For i As Integer = 0 To reader.FieldCount - 1
                Console.Write("{0} ", reader.GetValue(i))
            Next
            Console.WriteLine()
        End While
    End Sub

    Private Function GetConnectionString() As String
        ' To avoid storing the connection string in your code,            
        ' you can retrieve it from a configuration file. 

        ' If you have not included "Asynchronous Processing=true" in the
        ' connection string, the command is not able
        ' to execute asynchronously.
        Return "Data Source=(local);Integrated Security=true;" & _
          "Initial Catalog=AdventureWorks; Asynchronous Processing=true"
    End Function
End Module

Hinweise

Die BeginExecuteReader -Methode startet die asynchrone Ausführung einer Transact-SQL-Anweisung oder einer gespeicherten Prozedur, die Zeilen zurückgibt, damit andere Tasks gleichzeitig ausgeführt werden können, während die Anweisung ausgeführt wird.The BeginExecuteReader method starts the process of asynchronously executing a Transact-SQL statement or stored procedure that returns rows, so that other tasks can run concurrently while the statement is executing. Wenn die-Anweisung abgeschlossen ist, müssen Entwickler die EndExecuteReader -Methode aufrufen, um den Vorgang abzuschließen SqlDataReader und das vom Befehl zurückgegebene abzurufen.When the statement has completed, developers must call the EndExecuteReader method to finish the operation and retrieve the SqlDataReader returned by the command. Die BeginExecuteReader Methode wird sofort zurückgegeben, aber bis der Code den EndExecuteReader entsprechenden Methodenaufruf ausführt, dürfen keine anderen Aufrufe ausgeführt werden, die eine synchrone oder asynchrone Ausführung für SqlCommand dasselbe Objekt starten.The BeginExecuteReader method returns immediately, but until the code executes the corresponding EndExecuteReader method call, it must not execute any other calls that start a synchronous or asynchronous execution against the same SqlCommand object. Wenn aufgerufen wird, SqlCommand bevordieAusführungdesBefehlsabgeschlossenist,wirddas-Objektblockiert,bisdieAusführungabgeschlossenist.EndExecuteReaderCalling the EndExecuteReader before the command's execution is completed causes the SqlCommand object to block until the execution is finished.

Mit behavior dem-Parameter können Sie Optionen angeben, mit denen das Verhalten des Befehls und dessen Verbindung gesteuert wird.The behavior parameter lets you specify options that control the behavior of the command and its connection. Diese Werte können zusammen kombiniert werden (mit dem-Operator der OR Programmiersprache). im Allgemeinen verwenden Entwickler CommandBehavior.CloseConnection den-Wert, um sicherzustellen, dass die Verbindung SqlDataReader von der Laufzeit geschlossen wird, wenn geschlossen wird.These values can be combined together (using the programming language's OR operator); generally, developers use the CommandBehavior.CloseConnection value to make sure that the connection is closed by the runtime when the SqlDataReader is closed.

Beachten Sie, dass der Befehls Text und die Parameter synchron an den Server gesendet werden.Note that the command text and parameters are sent to the server synchronously. Wenn ein großer Befehl oder viele Parameter gesendet werden, kann diese Methode während Schreibvorgängen blockiert werden.If a large command or many parameters are sent, this method may block during writes. Nachdem der Befehl gesendet wurde, wird die Methode sofort zurückgegeben, ohne auf eine Antwort vom Server zu warten, d. h., die Lesevorgänge sind asynchron.After the command is sent, the method returns immediately without waiting for an answer from the server--that is, reads are asynchronous. Obwohl die Befehlsausführung asynchron ist, ist das Abrufen von Werten weiterhin synchron.Although command execution is asynchronous, value fetching is still synchronous. Dies bedeutet, dass Aufrufe Read von möglicherweise blockieren, wenn mehr Daten erforderlich sind und der Lesevorgang des zugrunde liegenden Netzwerks blockiert wird.This means that calls to Read may block if more data is required and the underlying network's read operation blocks.

Da diese Überladung keine Rückruf Prozedur unterstützt, müssen Entwickler entweder Abfragen, um zu bestimmen, ob der Befehl abgeschlossen wurde IsCompleted , indem Sie IAsyncResult die-Eigenschaft BeginExecuteNonQuery von verwenden, die von der-Methode zurückgegeben wurde, oder auf den Abschluss von mindestens ein-Befehl, der AsyncWaitHandle die-Eigenschaft des IAsyncResultzurückgegebenen-Objekts verwendet.Because this overload does not support a callback procedure, developers must either poll to determine whether the command has completed, using the IsCompleted property of the IAsyncResult returned by the BeginExecuteNonQuery method; or wait for the completion of one or more commands using the AsyncWaitHandle property of the returned IAsyncResult.

Wenn Sie oder ExecuteReader BeginExecuteReader verwenden, um auf XML-Daten zuzugreifen, gibt SQL Server alle XML-Ergebnisse mit einer Länge von mehr als 2.033 Zeichen in mehreren Zeilen mit jeweils 2.033 Zeichen zurück.If you use ExecuteReader or BeginExecuteReader to access XML data, SQL Server returns any XML results greater than 2,033 characters in length in multiple rows of 2,033 characters each. Um dieses Verhalten zu vermeiden, ExecuteXmlReader verwenden BeginExecuteXmlReader Sie oder zum Lesen von for XML-Abfragen.To avoid this behavior, use ExecuteXmlReader or BeginExecuteXmlReader to read FOR XML queries.

Siehe auch

BeginExecuteReader(AsyncCallback, Object) BeginExecuteReader(AsyncCallback, Object) BeginExecuteReader(AsyncCallback, Object) BeginExecuteReader(AsyncCallback, Object)

Initiiert die asynchrone Ausführung der Transact-SQL-Anweisung oder der gespeicherten Prozedur, die von diesem SqlCommand beschrieben wird, und ruft ein oder mehrere Resultsets vom Server ab, wenn eine Rückrufprozedur und Zustandsinformationen verfügbar sind.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.

public:
 IAsyncResult ^ BeginExecuteReader(AsyncCallback ^ callback, System::Object ^ stateObject);
public IAsyncResult BeginExecuteReader (AsyncCallback callback, object stateObject);
member this.BeginExecuteReader : AsyncCallback * obj -> IAsyncResult
Public Function BeginExecuteReader (callback As AsyncCallback, stateObject As Object) As IAsyncResult

Parameter

callback
AsyncCallback AsyncCallback AsyncCallback AsyncCallback

Ein AsyncCallback-Delegat, der aufgerufen wird, wenn die Ausführung des Befehls abgeschlossen wurde.An AsyncCallback delegate that is invoked when the command's execution has completed. Übergeben Sie null (Nothing in Microsoft Visual Basic), um anzugeben, dass kein Rückruf erforderlich ist.Pass null (Nothing in Microsoft Visual Basic) to indicate that no callback is required.

stateObject
Object Object Object Object

Ein benutzerdefiniertes Zustandsobjekt, das an die Rückrufprozedur übergeben wird.A user-defined state object that is passed to the callback procedure. Rufen Sie dieses Objekt innerhalb der Rückrufprozedur mit der AsyncState-Eigenschaft ab.Retrieve this object from within the callback procedure using the AsyncState property.

Gibt zurück

Ein IAsyncResult zum Abfragen von Ergebnissen oder als Warteschleife. Dieser Wert wird auch zum Aufrufen von EndExecuteReader(IAsyncResult) benötigt, das eine SqlDataReader-Instanz zurückgibt, mit der die zurückgegebenen Zeilen abgerufen werden können.An IAsyncResult that can be used to poll, wait for results, or both; this value is also needed when invoking EndExecuteReader(IAsyncResult), which returns a SqlDataReader instance which can be used to retrieve the returned rows.

Ausnahmen

Es wurde ein anderer SqlDbType als Binary oder VarBinary verwendet, als Value auf Stream festgelegt wurde.A SqlDbType other than Binary or VarBinary was used when Value was set to Stream. Weitere Informationen zum Streaming finden Sie unter SqlClient Streaming Support (SqlClient-Streamingunterstützung).For more information about streaming, see SqlClient Streaming Support.

- oder --or-

Es wurde ein anderer SqlDbType als Char, NChar, NVarChar, VarChar oder Xml verwendet, als Value auf TextReader festgelegt wurde.A SqlDbType other than Char, NChar, NVarChar, VarChar, or Xml was used when Value was set to TextReader.

- oder --or-

Es wurde ein anderer SqlDbType als Xml verwendet, als Value auf XmlReader festgelegt wurde.A SqlDbType other than Xml was used when Value was set to XmlReader.

Alle Fehler, die beim Ausführen des Befehlstexts aufgetreten sind.Any error that occurred while executing the command text.

- oder --or-

Bei einem Streamingvorgang ist ein Timeout aufgetreten.A timeout occurred during a streaming operation. Weitere Informationen zum Streaming finden Sie unter SqlClient-Streamingunterstützung.For more information about streaming, see SqlClient Streaming Support.

Das Name-Wert-Paar "Asynchronous Processing=true" war nicht in der Verbindungszeichenfolge enthalten, mit der die Verbindung für diesen SqlCommand definiert wird.The name/value pair "Asynchronous Processing=true" was not included within the connection string defining the connection for this SqlCommand.

- oder --or-

Die SqlConnection wurde während eines Streamingvorgangs geschlossen oder getrennt.The SqlConnection closed or dropped during a streaming operation. Weitere Informationen zum Streaming finden Sie unter SqlClient Streaming Support (SqlClient-Streamingunterstützung).For more information about streaming, see SqlClient Streaming Support.

Während eines Streamingvorgangs ist bei einem Stream-, XmlReader- oder TextReader-Objekt ein Fehler aufgetreten.An error occurred in a Stream, XmlReader or TextReader object during a streaming operation. Weitere Informationen zum Streaming finden Sie unter SqlClient Streaming Support (SqlClient-Streamingunterstützung).For more information about streaming, see SqlClient Streaming Support.

Das Stream-, XmlReader - oder TextReader -Objekt wurde während eines Streamingvorgangs geschlossen.The Stream, XmlReader or TextReader object was closed during a streaming operation. Weitere Informationen zum Streaming finden Sie unter SqlClient Streaming Support (SqlClient-Streamingunterstützung).For more information about streaming, see SqlClient Streaming Support.

Beispiele

In der folgenden Windows-Anwendung wird die Verwendung der BeginExecuteReader-Methode gezeigt, wobei eine Transact-SQL-Anweisung ausgeführt wird, die eine Verzögerung von einigen Sekunden beinhaltet (Emulieren eines zeitintensiven Befehls).The following Windows application demonstrates the use of the BeginExecuteReader method, executing a Transact-SQL statement that includes a delay of a few seconds (emulating a long-running command). Da im Beispiel der Befehl asynchron ausgeführt wird, bleibt das Formular beim Warten auf die Ergebnisse reaktionsfähig.Because the sample executes the command asynchronously, the form remains responsive while awaiting the results. In diesem Beispiel wird das SqlCommand ausführende Objekt als- SqlCommand EndExecuteReader Parameterübergeben.dadurchisteseinfach,dasObjektinnerhalbderRückrufProzedurabzurufen,damitderCodedieMethodeaufrufenstateObject kann, die dem der erste Rückruf BeginExecuteReadervon.This example passes the executing SqlCommand object as the stateObject parameter; doing so makes it simple to retrieve the SqlCommand object from within the callback procedure, so that the code can call the EndExecuteReader method corresponding to the initial call to BeginExecuteReader.

In diesem Beispiel werden viele wichtige Techniken veranschaulicht.This example demonstrates many important techniques. Dies schließt das Aufrufen einer Methode ein, die mit dem Formular von einem separaten Thread interagiert.This includes calling a method that interacts with the form from a separate thread. Außerdem wird in diesem Beispiel veranschaulicht, wie Sie verhindern können, dass Benutzer einen Befehl mehrmals parallel ausführen, und wie Sie sicherstellen müssen, dass das Formular nicht geschlossen wird, bevor die Rückruf Prozedur aufgerufen wird.In addition, this example demonstrates how you must block users from executing a command multiple times concurrently, and how you must make sure that the form does not close before the callback procedure is called.

Erstellen Sie zum Einrichten dieses Beispiels eine neue Windows-Anwendung.To set up this example, create a new Windows application. Platzieren Sie Button ein-Steuer DataGridView Element, ein- Label Steuerelement und ein-Steuerelement im Formular (übernehmen Sie für jedes Steuerelement den Standardnamen).Put a Button control, a DataGridView control, and a Label control on the form (accepting the default name for each control). Fügen Sie der Klasse des Formulars den folgenden Code hinzu, und ändern Sie die Verbindungs Zeichenfolge nach Bedarf für Ihre Umgebung.Add the following code to the form's class, modifying the connection string as needed for your environment.

using System.Data.SqlClient;

namespace Microsoft.AdoDotNet.CodeSamples
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }

        // Hook up the form's Load event handler (you can double-click on 
        // the form's design surface in Visual Studio), and then add 
        // this code to the form's class:

        // You need this delegate in order to fill the grid from
        // a thread other than the form's thread. See the HandleCallback
        // procedure for more information.
        private delegate void FillGridDelegate(SqlDataReader reader);

        // You need this delegate to update the status bar.
        private delegate void DisplayStatusDelegate(string Text);

        // This flag ensures that the user does not attempt
        // to restart the command or close the form while the 
        // asynchronous command is executing.
        private bool isExecuting = false;

        // Because the overloaded version of BeginExecuteReader
        // demonstrated here does not allow you to have the connection
        // closed automatically, this example maintains the 
        // connection object externally, so that it is available for closing.
        private SqlConnection connection = null;

        private void DisplayStatus(string Text)
        {
            this.label1.Text = Text;
        }

        private void FillGrid(SqlDataReader reader)
        {
            try
            {
                DataTable table = new DataTable();
                table.Load(reader);
                this.dataGridView1.DataSource = table;
                DisplayStatus("Ready");
            }
            catch (Exception ex)
            {
                // Because you are guaranteed this procedure
                // is running from within the form's thread,
                // it can directly interact with members of the form.
                DisplayStatus(string.Format("Ready (last attempt failed: {0})",
                    ex.Message));
            }
            finally
            {
                // Do not forget to close the connection, as well.
                if (reader != null)
                {
                    reader.Close();
                }
                if (connection != null)
                {
                    connection.Close();
                }
            }
        }

        private void HandleCallback(IAsyncResult result)
        {
            try
            {
                // Retrieve the original command object, passed
                // to this procedure in the AsyncState property
                // of the IAsyncResult parameter.
                SqlCommand command = (SqlCommand)result.AsyncState;
                SqlDataReader reader = command.EndExecuteReader(result);
                // You may not interact with the form and its contents
                // from a different thread, and this callback procedure
                // is all but guaranteed to be running from a different thread
                // than the form. Therefore you cannot simply call code that 
                // fills the grid, like this:
                // FillGrid(reader);
                // Instead, you must call the procedure from the form's thread.
                // One simple way to accomplish this is to call the Invoke
                // method of the form, which calls the delegate you supply
                // from the form's thread. 
                FillGridDelegate del = new FillGridDelegate(FillGrid);
                this.Invoke(del, reader);
                // Do not close the reader here, because it is being used in 
                // a separate thread. Instead, have the procedure you have
                // called close the reader once it is done with it.
            }
            catch (Exception ex)
            {
                // Because you are now running code in a separate thread, 
                // if you do not handle the exception here, none of your other
                // code catches the exception. Because there is none of 
                // your code on the call stack in this thread, there is nothing
                // higher up the stack to catch the exception if you do not 
                // handle it here. You can either log the exception or 
                // invoke a delegate (as in the non-error case in this 
                // example) to display the error on the form. In no case
                // can you simply display the error without executing a delegate
                // as in the try block here. 
                // You can create the delegate instance as you 
                // invoke it, like this:
                this.Invoke(new DisplayStatusDelegate(DisplayStatus),
                    "Error: " + ex.Message);
            }
            finally
            {
                isExecuting = false;
            }
        }

        private string GetConnectionString()
        {
            // To avoid storing the connection string in your code, 
            // you can retrieve it from a configuration file. 

            // If you do not include the Asynchronous Processing=true name/value pair,
            // you wo not be able to execute the command asynchronously.
            return "Data Source=(local);Integrated Security=true;" +
                "Initial Catalog=AdventureWorks; Asynchronous Processing=true";
        }

        private void button1_Click(object sender, System.EventArgs e)
        {
            if (isExecuting)
            {
                MessageBox.Show(this,
                    "Already executing. Please wait until the current query " +
                    "has completed.");
            }
            else
            {
                SqlCommand command = null;
                try
                {
                    DisplayStatus("Connecting...");
                    connection = new SqlConnection(GetConnectionString());
                    // To emulate a long-running query, wait for 
                    // a few seconds before retrieving the real data.
                    command = new SqlCommand("WAITFOR DELAY '0:0:5';" +
                        "SELECT ProductID, Name, ListPrice, Weight FROM Production.Product",
                        connection);
                    connection.Open();

                    DisplayStatus("Executing...");
                    isExecuting = true;
                    // Although it is not required that you pass the 
                    // SqlCommand object as the second parameter in the 
                    // BeginExecuteReader call, doing so makes it easier
                    // to call EndExecuteReader in the callback procedure.
                    AsyncCallback callback = new AsyncCallback(HandleCallback);
                    command.BeginExecuteReader(callback, command);
                }
                catch (Exception ex)
                {
                    DisplayStatus("Error: " + ex.Message);
                    if (connection != null)
                    {
                        connection.Close();
                    }
                }
            }
        }

        private void Form1_Load(object sender, System.EventArgs e)
        {
            this.button1.Click += new System.EventHandler(this.button1_Click);
            this.FormClosing += new FormClosingEventHandler(Form1_FormClosing);
        }

        void Form1_FormClosing(object sender, FormClosingEventArgs e)
        {
            if (isExecuting)
            {
                MessageBox.Show(this, "Cannot close the form until " +
                    "the pending asynchronous command has completed. Please wait...");
                e.Cancel = true;
            }
        }
    }
}
Imports System.Data.SqlClient

Public Class Form1
    ' Add this code to the form's class:
    ' You need this delegate in order to fill the grid from
    ' a thread other than the form's thread. See the HandleCallback
    ' procedure for more information.
    Private Delegate Sub FillGridDelegate(ByVal reader As SqlDataReader)

    ' You need this delegate to update the status bar.
    Private Delegate Sub DisplayStatusDelegate(ByVal Text As String)

    ' This flag ensures that the user does not attempt
    ' to restart the command or close the form while the 
    ' asynchronous command is executing.
    Private isExecuting As Boolean

    ' Because the overloaded version of BeginExecuteReader
    ' demonstrated here does not allow you to have the connection
    ' closed automatically, this example maintains the 
    ' connection object externally, so that it is available for closing.
    Private connection As SqlConnection

    Private Sub DisplayStatus(ByVal Text As String)
        Me.Label1.Text = Text
    End Sub

    Private Sub FillGrid(ByVal reader As SqlDataReader)
        Try
            Dim table As New DataTable
            table.Load(reader)
            Me.DataGridView1.DataSource = table
            DisplayStatus("Ready")

        Catch ex As Exception
            ' Because you are guaranteed this procedure
            ' is running from within the form's thread,
            ' it can directly interact with members of the form.
            DisplayStatus(String.Format("Ready (last attempt failed: {0})", ex.Message))
        Finally
            ' Do not forget to close the connection, as well.
            If Not reader Is Nothing Then
                reader.Close()
            End If
            If Not connection Is Nothing Then
                connection.Close()
            End If
        End Try
    End Sub

    Private Sub HandleCallback(ByVal result As IAsyncResult)
        Try
            ' Retrieve the original command object, passed
            ' to this procedure in the AsyncState property
            ' of the IAsyncResult parameter.
            Dim command As SqlCommand = CType(result.AsyncState, SqlCommand)
            Dim reader As SqlDataReader = command.EndExecuteReader(result)

            ' You may not interact with the form and its contents
            ' from a different thread, and this callback procedure
            ' is all but guaranteed to be running from a different thread
            ' than the form. Therefore you cannot simply call code that 
            ' fills the grid, like this:
            ' FillGrid(reader)

            ' Instead, you must call the procedure from the form's thread.
            ' One simple way to accomplish this is to call the Invoke
            ' method of the form, which calls the delegate you supply
            ' from the form's thread. 
            Dim del As New FillGridDelegate(AddressOf FillGrid)
            Me.Invoke(del, reader)
            ' Do not close the reader here, because it is being used in 
            ' a separate thread. Instead, have the procedure you have
            ' called close the reader once it is done with it.

        Catch ex As Exception
            ' Because you are now running code in a separate thread, 
            ' if you do not handle the exception here, none of your other
            ' code catches the exception. Because there is none of 
            ' your code on the call stack in this thread, there is nothing
            ' higher up the stack to catch the exception if you do not 
            ' handle it here. You can either log the exception or 
            ' invoke a delegate (as in the non-error case in this 
            ' example) to display the error on the form. In no case
            ' can you simply display the error without executing a delegate
            ' as in the Try block here. 

            ' You can create the delegate instance as you 
            ' invoke it, like this:
            Me.Invoke(New DisplayStatusDelegate(AddressOf DisplayStatus), _
             "Error: " & ex.Message)
        Finally
            isExecuting = False
        End Try
    End Sub

    Private Function GetConnectionString() As String
        ' To avoid storing the connection string in your code,
        ' you can retrieve it from a configuration file. 

        ' If you do not include the Asynchronous Processing=true name/value pair,
        ' you wo not be able to execute the command asynchronously.

        Return "Data Source=(local);Integrated Security=true;" & _
        "Initial Catalog=AdventureWorks; Asynchronous Processing=true"
    End Function

    Private Sub Button1_Click(ByVal sender As System.Object, _
        ByVal e As System.EventArgs) Handles Button1.Click
        If isExecuting Then
            MessageBox.Show(Me, _
                "Already executing. Please wait until the current query " & _
                "has completed.")
        Else
            Dim command As SqlCommand
            Try
                DisplayStatus("Connecting...")
                connection = New SqlConnection(GetConnectionString())
                ' To emulate a long-running query, wait for 
                ' a few seconds before retrieving the real data.
                command = New SqlCommand( _
                 "WAITFOR DELAY '0:0:5';" & _
                 "SELECT ProductID, Name, ListPrice, Weight FROM Production.Product", _
                 connection)
                connection.Open()

                DisplayStatus("Executing...")
                isExecuting = True
                ' Although it is not required that you pass the 
                ' SqlCommand object as the second parameter in the 
                ' BeginExecuteReader call, doing so makes it easier
                ' to call EndExecuteReader in the callback procedure.
                Dim callback As New AsyncCallback(AddressOf HandleCallback)
                command.BeginExecuteReader(callback, command)

            Catch ex As Exception
                DisplayStatus("Error: " & ex.Message)
                If connection IsNot Nothing Then
                    connection.Close()
                End If
            End Try
        End If
    End Sub

    Private Sub Form1_FormClosing(ByVal sender As Object, _
        ByVal e As System.Windows.Forms.FormClosingEventArgs) _
        Handles Me.FormClosing
        If isExecuting Then
            MessageBox.Show(Me, "Cannot close the form until " & _
              "the pending asynchronous command has completed. Please wait...")
            e.Cancel = True
        End If
    End Sub
End Class

Hinweise

Die BeginExecuteReader -Methode startet die asynchrone Ausführung einer Transact-SQL-Anweisung oder einer gespeicherten Prozedur, die Zeilen zurückgibt, damit andere Tasks gleichzeitig ausgeführt werden können, während die Anweisung ausgeführt wird.The BeginExecuteReader method starts the process of asynchronously executing a Transact-SQL statement or stored procedure that returns rows, so that other tasks can run concurrently while the statement is executing. Wenn die-Anweisung abgeschlossen ist, müssen Entwickler die EndExecuteReader -Methode aufrufen, um den Vorgang abzuschließen SqlDataReader und das vom Befehl zurückgegebene abzurufen.When the statement has completed, developers must call the EndExecuteReader method to finish the operation and retrieve the SqlDataReader returned by the command. Die BeginExecuteReader Methode wird sofort zurückgegeben, aber bis der Code den EndExecuteReader entsprechenden Methodenaufruf ausführt, dürfen keine anderen Aufrufe ausgeführt werden, die eine synchrone oder asynchrone Ausführung für SqlCommand dasselbe Objekt starten.The BeginExecuteReader method returns immediately, but until the code executes the corresponding EndExecuteReader method call, it must not execute any other calls that start a synchronous or asynchronous execution against the same SqlCommand object. Wenn aufgerufen wird, SqlCommand bevordieAusführungdesBefehlsabgeschlossenist,bewirktdies,dassdasObjektblockiertwird,bisdieAusführungabgeschlossenist.EndExecuteReaderCalling the EndExecuteReader before the command's execution is completed cause the SqlCommand object to block until the execution is finished.

Mit callback dem-Parameter können Sie AsyncCallback einen-Delegaten angeben, der aufgerufen wird, wenn die-Anweisung abgeschlossen wurde.The callback parameter lets you specify an AsyncCallback delegate that is called when the statement has completed. Sie können die EndExecuteReader -Methode in dieser Delegatprozedur oder an einem beliebigen anderen Speicherort innerhalb der Anwendung abrufen.You can call the EndExecuteReader method from within this delegate procedure, or from any other location within your application. Darüber hinaus können Sie ein beliebiges-Objekt im stateObject -Parameter übergeben, und Ihre Rückruf Prozedur kann diese Informationen mithilfe AsyncState der-Eigenschaft abrufen.In addition, you can pass any object in the stateObject parameter, and your callback procedure can retrieve this information using the AsyncState property.

Beachten Sie, dass der Befehls Text und die Parameter synchron an den Server gesendet werden.Note that the command text and parameters are sent to the server synchronously. Wenn ein großer Befehl oder viele Parameter gesendet werden, kann diese Methode während Schreibvorgängen blockiert werden.If a large command or many parameters are sent, this method may block during writes. Nachdem der Befehl gesendet wurde, wird die Methode sofort zurückgegeben, ohne auf eine Antwort vom Server zu warten, d. h., die Lesevorgänge sind asynchron.After the command is sent, the method returns immediately without waiting for an answer from the server--that is, reads are asynchronous. Obwohl die Befehlsausführung asynchron ist, ist das Abrufen von Werten weiterhin synchron.Although command execution is asynchronous, value fetching is still synchronous. Dies bedeutet, dass Aufrufe Read von möglicherweise blockieren, wenn mehr Daten erforderlich sind und der Lesevorgang des zugrunde liegenden Netzwerks blockiert wird.This means that calls to Read may block if more data is required and the underlying network's read operation blocks.

Da die Rückruf Prozedur innerhalb eines Hintergrundthreads ausgeführt wird, der von der Microsoft .NET Runtime bereitgestellt wird, ist es sehr wichtig, dass Sie einen strengen Ansatz für die Verarbeitung Thread übergreifender Interaktionen in Ihren Anwendungen verwenden.Because the callback procedure executes from within a background thread supplied by the Microsoft .NET runtime, it is very important that you take a rigorous approach to handling cross-thread interactions from within your applications. Beispielsweise dürfen Sie nicht mit dem Inhalt eines Formulars innerhalb der Rückruf Prozedur interagieren. Wenn Sie das Formular aktualisieren müssen, müssen Sie wieder zum Thread des Formulars wechseln, um Ihre Arbeit zu erledigen.For example, you must not interact with a form's contents from within your callback procedure; should you have to update the form, you must switch back to the form's thread in order to do your work. Dieses Verhalten wird im Beispiel in diesem Thema veranschaulicht.The example in this topic demonstrates this behavior.

Alle Fehler, die während der Ausführung des Vorgangs auftreten, werden als Ausnahmen in der Rückruf Prozedur ausgelöst.All errors that occur during the execution of the operation are thrown as exceptions in the callback procedure. Sie müssen die Ausnahme in der Rückruf Prozedur und nicht in der Hauptanwendung behandeln.You must handle the exception in the callback procedure, not in the main application. Weitere Informationen zur Behandlung von Ausnahmen in der Rückruf Prozedur finden Sie im Beispiel in diesem Thema.See the example in this topic for additional information on handling exceptions in the callback procedure.

Wenn Sie oder ExecuteReader BeginExecuteReader verwenden, um auf XML-Daten zuzugreifen, gibt SQL Server alle XML-Ergebnisse mit einer Länge von mehr als 2.033 Zeichen in mehreren Zeilen mit jeweils 2.033 Zeichen zurück.If you use ExecuteReader or BeginExecuteReader to access XML data, SQL Server returns any XML results greater than 2,033 characters in length in multiple rows of 2,033 characters each. Um dieses Verhalten zu vermeiden, ExecuteXmlReader verwenden BeginExecuteXmlReader Sie oder zum Lesen von for XML-Abfragen.To avoid this behavior, use ExecuteXmlReader or BeginExecuteXmlReader to read FOR XML queries.

Siehe auch

BeginExecuteReader(AsyncCallback, Object, CommandBehavior) BeginExecuteReader(AsyncCallback, Object, CommandBehavior) BeginExecuteReader(AsyncCallback, Object, CommandBehavior) BeginExecuteReader(AsyncCallback, Object, CommandBehavior)

Initiiert die asynchrone Ausführung der Transact-SQL-Anweisung oder der gespeicherten Prozedur, die von diesem SqlCommand beschrieben wird, wobei einer der CommandBehavior-Werte verwendet wird und ein oder mehrere Resultsets vom Server abgerufen werden, wenn eine Rückrufprozedur und Zustandsinformationen verfügbar sind.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.

public:
 IAsyncResult ^ BeginExecuteReader(AsyncCallback ^ callback, System::Object ^ stateObject, System::Data::CommandBehavior behavior);
public IAsyncResult BeginExecuteReader (AsyncCallback callback, object stateObject, System.Data.CommandBehavior behavior);
member this.BeginExecuteReader : AsyncCallback * obj * System.Data.CommandBehavior -> IAsyncResult
Public Function BeginExecuteReader (callback As AsyncCallback, stateObject As Object, behavior As CommandBehavior) As IAsyncResult

Parameter

callback
AsyncCallback AsyncCallback AsyncCallback AsyncCallback

Ein AsyncCallback-Delegat, der aufgerufen wird, wenn die Ausführung des Befehls abgeschlossen wurde.An AsyncCallback delegate that is invoked when the command's execution has completed. Übergeben Sie null (Nothing in Microsoft Visual Basic), um anzugeben, dass kein Rückruf erforderlich ist.Pass null (Nothing in Microsoft Visual Basic) to indicate that no callback is required.

stateObject
Object Object Object Object

Ein benutzerdefiniertes Zustandsobjekt, das an die Rückrufprozedur übergeben wird.A user-defined state object that is passed to the callback procedure. Rufen Sie dieses Objekt innerhalb der Rückrufprozedur mit der AsyncState -Eigenschaft ab.Retrieve this object from within the callback procedure using the AsyncState property.

behavior
CommandBehavior CommandBehavior CommandBehavior CommandBehavior

Einer der CommandBehavior-Werte, der Optionen zur Ausführung von Anweisungen und zum Abrufen von Daten festlegt.One of the CommandBehavior values, indicating options for statement execution and data retrieval.

Gibt zurück

Ein IAsyncResult, das zum Abfragen von Ergebnissen und/oder als Warteschleife verwendet werden kann. Dieser Wert wird auch beim Aufrufen von EndExecuteReader(IAsyncResult) benötigt, das eine SqlDataReader-Instanz zurückgibt, mit der die zurückgegebenen Zeilen abgerufen werden können.An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndExecuteReader(IAsyncResult), which returns a SqlDataReader instance which can be used to retrieve the returned rows.

Ausnahmen

Es wurde ein anderer SqlDbType als Binary oder VarBinary verwendet, als Value auf Stream festgelegt wurde.A SqlDbType other than Binary or VarBinary was used when Value was set to Stream. Weitere Informationen zum Streaming finden Sie unter SqlClient Streaming Support (SqlClient-Streamingunterstützung).For more information about streaming, see SqlClient Streaming Support.

- oder --or-

Es wurde ein anderer SqlDbType als Char, NChar, NVarChar, VarChar oder Xml verwendet, als Value auf TextReader festgelegt wurde.A SqlDbType other than Char, NChar, NVarChar, VarChar, or Xml was used when Value was set to TextReader.

- oder --or-

Es wurde ein anderer SqlDbType als Xml verwendet, als Value auf XmlReader festgelegt wurde.A SqlDbType other than Xml was used when Value was set to XmlReader.

Alle Fehler, die beim Ausführen des Befehlstexts aufgetreten sind.Any error that occurred while executing the command text.

- oder --or-

Bei einem Streamingvorgang ist ein Timeout aufgetreten.A timeout occurred during a streaming operation. Weitere Informationen zum Streaming finden Sie unter SqlClient-Streamingunterstützung.For more information about streaming, see SqlClient Streaming Support.

Das Name-Wert-Paar "Asynchronous Processing=true" war nicht in der Verbindungszeichenfolge enthalten, mit der die Verbindung für diesen SqlCommand definiert wird.The name/value pair "Asynchronous Processing=true" was not included within the connection string defining the connection for this SqlCommand.

- oder --or-

Die SqlConnection wurde während eines Streamingvorgangs geschlossen oder getrennt.The SqlConnection closed or dropped during a streaming operation. Weitere Informationen zum Streaming finden Sie unter SqlClient Streaming Support (SqlClient-Streamingunterstützung).For more information about streaming, see SqlClient Streaming Support.

Während eines Streamingvorgangs ist bei einem Stream-, XmlReader- oder TextReader-Objekt ein Fehler aufgetreten.An error occurred in a Stream, XmlReader or TextReader object during a streaming operation. Weitere Informationen zum Streaming finden Sie unter SqlClient Streaming Support (SqlClient-Streamingunterstützung).For more information about streaming, see SqlClient Streaming Support.

Das Stream-, XmlReader - oder TextReader -Objekt wurde während eines Streamingvorgangs geschlossen.The Stream, XmlReader or TextReader object was closed during a streaming operation. Weitere Informationen zum Streaming finden Sie unter SqlClient Streaming Support (SqlClient-Streamingunterstützung).For more information about streaming, see SqlClient Streaming Support.

Beispiele

In der folgenden Windows-Anwendung wird die Verwendung der BeginExecuteReader-Methode gezeigt, wobei eine Transact-SQL-Anweisung ausgeführt wird, die eine Verzögerung von einigen Sekunden beinhaltet (Emulieren eines zeitintensiven Befehls).The following Windows application demonstrates the use of the BeginExecuteReader method, executing a Transact-SQL statement that includes a delay of a few seconds (emulating a long-running command). Da im Beispiel der Befehl asynchron ausgeführt wird, bleibt das Formular beim Warten auf die Ergebnisse reaktionsfähig.Because the sample executes the command asynchronously, the form remains responsive while awaiting the results. In diesem Beispiel wird das SqlCommand ausführende Objekt als- SqlCommand EndExecuteReader Parameterübergeben.dadurchisteseinfach,dasObjektinnerhalbderRückrufProzedurabzurufen,damitderCodedieMethodeaufrufenstateObject kann, die dem der erste Rückruf BeginExecuteReadervon.This example passes the executing SqlCommand object as the stateObject parameter; doing so makes it simple to retrieve the SqlCommand object from within the callback procedure, so that the code can call the EndExecuteReader method corresponding to the initial call to BeginExecuteReader.

In diesem Beispiel werden viele wichtige Techniken veranschaulicht.This example demonstrates many important techniques. Dies schließt das Aufrufen einer Methode ein, die mit dem Formular von einem separaten Thread interagiert.This includes calling a method that interacts with the form from a separate thread. Außerdem wird in diesem Beispiel veranschaulicht, wie Sie verhindern können, dass Benutzer einen Befehl mehrmals parallel ausführen, und wie Sie sicherstellen müssen, dass das Formular nicht geschlossen wird, bevor die Rückruf Prozedur aufgerufen wird.In addition, this example demonstrates how you must block users from executing a command multiple times concurrently, and how you must make sure that the form does not close before the callback procedure is called.

Erstellen Sie zum Einrichten dieses Beispiels eine neue Windows-Anwendung.To set up this example, create a new Windows application. Platzieren Sie Button ein-Steuer DataGridView Element, ein- Label Steuerelement und ein-Steuerelement im Formular (übernehmen Sie für jedes Steuerelement den Standardnamen).Put a Button control, a DataGridView control, and a Label control on the form (accepting the default name for each control). Fügen Sie der Klasse des Formulars den folgenden Code hinzu, und ändern Sie die Verbindungs Zeichenfolge nach Bedarf für Ihre Umgebung.Add the following code to the form's class, modifying the connection string as needed for your environment.

In diesem Beispiel wird CommandBehavior.CloseConnection der-Wert im- SqlDataReader Parameterübergeben,sodassdiezurückgegebenedieVerbindungautomatischschließt,wennbehavior Sie geschlossen wird.This example passes the CommandBehavior.CloseConnection value in the behavior parameter, causing the returned SqlDataReader to automatically close its connection when it is closed.

using System.Data.SqlClient;

namespace Microsoft.AdoDotNet.CodeSamples
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }
        // Hook up the form's Load event handler (you can double-click on 
        // the form's design surface in Visual Studio), and then add 
        // this code to the form's class:
        // You need this delegate in order to fill the grid from
        // a thread other than the form's thread. See the HandleCallback
        // procedure for more information.
        private delegate void FillGridDelegate(SqlDataReader reader);

        // You need this delegate to update the status bar.
        private delegate void DisplayStatusDelegate(string Text);

        // This flag ensures that the user does not attempt
        // to restart the command or close the form while the 
        // asynchronous command is executing.
        private bool isExecuting;

        private void DisplayStatus(string Text)
        {
            this.label1.Text = Text;
        }

        private void FillGrid(SqlDataReader reader)
        {
            try
            {
                DataTable table = new DataTable();
                table.Load(reader);
                this.dataGridView1.DataSource = table;
                DisplayStatus("Ready");
            }
            catch (Exception ex)
            {
                // Because you are guaranteed this procedure
                // is running from within the form's thread,
                // it can directly interact with members of the form.
                DisplayStatus(string.Format("Ready (last attempt failed: {0})",
                    ex.Message));
            }
            finally
            {
                // Closing the reader also closes the connection,
                // because this reader was created using the 
                // CommandBehavior.CloseConnection value.
                if (reader != null)
                {
                    reader.Close();
                }
            }
        }

        private void HandleCallback(IAsyncResult result)
        {
            try
            {
                // Retrieve the original command object, passed
                // to this procedure in the AsyncState property
                // of the IAsyncResult parameter.
                SqlCommand command = (SqlCommand)result.AsyncState;
                SqlDataReader reader = command.EndExecuteReader(result);
                // You may not interact with the form and its contents
                // from a different thread, and this callback procedure
                // is all but guaranteed to be running from a different thread
                // than the form. Therefore you cannot simply call code that 
                // fills the grid, like this:
                // FillGrid(reader);
                // Instead, you must call the procedure from the form's thread.
                // One simple way to accomplish this is to call the Invoke
                // method of the form, which calls the delegate you supply
                // from the form's thread. 
                FillGridDelegate del = new FillGridDelegate(FillGrid);
                this.Invoke(del, reader);
                // Do not close the reader here, because it is being used in 
                // a separate thread. Instead, have the procedure you have
                // called close the reader once it is done with it.
            }
            catch (Exception ex)
            {
                // Because you are now running code in a separate thread, 
                // if you do not handle the exception here, none of your other
                // code catches the exception. Because there is none of 
                // your code on the call stack in this thread, there is nothing
                // higher up the stack to catch the exception if you do not 
                // handle it here. You can either log the exception or 
                // invoke a delegate (as in the non-error case in this 
                // example) to display the error on the form. In no case
                // can you simply display the error without executing a delegate
                // as in the try block here. 
                // You can create the delegate instance as you 
                // invoke it, like this:
                this.Invoke(new DisplayStatusDelegate(DisplayStatus), "Error: " +
                    ex.Message);
            }
            finally
            {
                isExecuting = false;
            }
        }

        private string GetConnectionString()
        {
            // To avoid storing the connection string in your code, 
            // you can retrieve it from a configuration file. 

            // If you do not include the Asynchronous Processing=true name/value pair,
            // you wo not be able to execute the command asynchronously.
            return "Data Source=(local);Integrated Security=true;" +
                "Initial Catalog=AdventureWorks; Asynchronous Processing=true";
        }

        private void button1_Click(object sender, System.EventArgs e)
        {
            if (isExecuting)
            {
                MessageBox.Show(this,
                    "Already executing. Please wait until the current query " +
                    "has completed.");
            }
            else
            {
                SqlCommand command = null;
                SqlConnection connection = null;
                try
                {
                    DisplayStatus("Connecting...");
                    connection = new SqlConnection(GetConnectionString());
                    // To emulate a long-running query, wait for 
                    // a few seconds before retrieving the real data.
                    command = new SqlCommand("WAITFOR DELAY '0:0:5';" +
                        "SELECT ProductID, Name, ListPrice, Weight FROM Production.Product",
                        connection);
                    connection.Open();

                    DisplayStatus("Executing...");
                    isExecuting = true;
                    // Although it is not required that you pass the 
                    // SqlCommand object as the second parameter in the 
                    // BeginExecuteReader call, doing so makes it easier
                    // to call EndExecuteReader in the callback procedure.
                    AsyncCallback callback = new AsyncCallback(HandleCallback);
                    command.BeginExecuteReader(callback, command,
                        CommandBehavior.CloseConnection);
                }
                catch (Exception ex)
                {
                    DisplayStatus("Error: " + ex.Message);
                    if (connection != null)
                    {
                        connection.Close();
                    }
                }
            }
        }

        private void Form1_Load(object sender, System.EventArgs e)
        {
            this.button1.Click += new System.EventHandler(this.button1_Click);
            this.FormClosing += new FormClosingEventHandler(Form1_FormClosing);
        }

        void Form1_FormClosing(object sender, FormClosingEventArgs e)
        {
            if (isExecuting)
            {
                MessageBox.Show(this, "Cannot close the form until " +
                    "the pending asynchronous command has completed. Please wait...");
                e.Cancel = true;
            }
        }
    }
}
Imports System.Data.SqlClient

Public Class Form1
    ' Add this code to the form's class:
    ' You this delegate in order to fill the grid from
    ' a thread other than the form's thread. See the HandleCallback
    ' procedure for more information.
    Private Delegate Sub FillGridDelegate(ByVal reader As SqlDataReader)

    ' You need this delegate to update the status bar.
    Private Delegate Sub DisplayStatusDelegate(ByVal Text As String)

    ' This flag ensures that the user does not attempt
    ' to restart the command or close the form while the 
    ' asynchronous command is executing.
    Private isExecuting As Boolean

    Private Sub DisplayStatus(ByVal Text As String)
        Me.Label1.Text = Text
    End Sub

    Private Sub FillGrid(ByVal reader As SqlDataReader)
        Try
            Dim table As New DataTable
            table.Load(reader)
            Me.DataGridView1.DataSource = table
            DisplayStatus("Ready")

        Catch ex As Exception
            ' Because you are guaranteed this procedure
            ' is running from within the form's thread,
            ' it can directly interact with members of the form.
            DisplayStatus(String.Format("Ready (last attempt failed: {0})", ex.Message))
        Finally
            ' Closing the reader also closes the connection,
            ' because this reader was created using the 
            ' CommandBehavior.CloseConnection value.
            If reader IsNot Nothing Then
                reader.Close()
            End If
        End Try
    End Sub

    Private Sub HandleCallback(ByVal result As IAsyncResult)
        Try
            ' Retrieve the original command object, passed
            ' to this procedure in the AsyncState property
            ' of the IAsyncResult parameter.
            Dim command As SqlCommand = CType(result.AsyncState, SqlCommand)
            Dim reader As SqlDataReader = command.EndExecuteReader(result)

            ' You may not interact with the form and its contents
            ' from a different thread, and this callback procedure
            ' is all but guaranteed to be running from a different thread
            ' than the form. Therefore you cannot simply call code that 
            ' fills the grid, like this:
            ' FillGrid(reader)

            ' Instead, you must call the procedure from the form's thread.
            ' One simple way to accomplish this is to call the Invoke
            ' method of the form, which calls the delegate you supply
            ' from the form's thread. 
            Dim del As New FillGridDelegate(AddressOf FillGrid)
            Me.Invoke(del, reader)

            ' Do not close the reader here, because it is being used in 
            ' a separate thread. Instead, have the procedure you have
            ' called close the reader once it is done with it.

        Catch ex As Exception
            ' Because you are now running code in a separate thread, 
            ' if you do not handle the exception here, none of your other
            ' code catches the exception. Because there is none of 
            ' your code on the call stack in this thread, there is nothing
            ' higher up the stack to catch the exception if you do not 
            ' handle it here. You can either log the exception or 
            ' invoke a delegate (as in the non-error case in this 
            ' example) to display the error on the form. In no case
            ' can you simply display the error without executing a delegate
            ' as in the Try block here. 

            ' You can create the delegate instance as you 
            ' invoke it, like this:
            Me.Invoke(New DisplayStatusDelegate(AddressOf DisplayStatus), _
             "Error: " & ex.Message)
        Finally
            isExecuting = False
        End Try
    End Sub

    Private Function GetConnectionString() As String
        ' To avoid storing the connection string in your code,
        ' you can retrieve it from a configuration file. 

        ' If you do not include the Asynchronous Processing=true name/value pair,
        ' you wo not be able to execute the command asynchronously.

        Return "Data Source=(local);Integrated Security=true;" & _
        "Initial Catalog=AdventureWorks; Asynchronous Processing=true"
    End Function

    Private Sub Button1_Click(ByVal sender As System.Object, _
        ByVal e As System.EventArgs) Handles Button1.Click
        If isExecuting Then
            MessageBox.Show(Me, "Already executing. Please wait until the current query " & _
             "has completed.")
        Else
            Dim connection As SqlConnection
            Dim command As SqlCommand
            Try
                DisplayStatus("Connecting...")
                connection = New SqlConnection(GetConnectionString())
                ' To emulate a long-running query, wait for 
                ' a few seconds before retrieving the real data.
                command = New SqlCommand( _
                 "WAITFOR DELAY '0:0:5';" & _
                 "SELECT ProductID, Name, ListPrice, Weight FROM Production.Product", _
                 connection)
                connection.Open()

                DisplayStatus("Executing...")
                isExecuting = True
                ' Although it is not required that you pass the 
                ' SqlCommand object as the second parameter in the 
                ' BeginExecuteReader call, doing so makes it easier
                ' to call EndExecuteReader in the callback procedure.
                Dim callback As New AsyncCallback(AddressOf HandleCallback)
                command.BeginExecuteReader(callback, command, _
                  CommandBehavior.CloseConnection)

            Catch ex As Exception
                DisplayStatus("Error: " & ex.Message)
                If connection IsNot Nothing Then
                    connection.Close()
                End If
            End Try
        End If
    End Sub

    Private Sub Form1_FormClosing(ByVal sender As Object, _
        ByVal e As System.Windows.Forms.FormClosingEventArgs) Handles Me.FormClosing
        If isExecuting Then
            MessageBox.Show(Me, "Cannot close the form until " & _
             "the pending asynchronous command has completed. Please wait...")
            e.Cancel = True
        End If
    End Sub
End Class

Hinweise

Die BeginExecuteReader -Methode startet die asynchrone Ausführung einer Transact-SQL-Anweisung oder einer gespeicherten Prozedur, die Zeilen zurückgibt, damit andere Tasks gleichzeitig ausgeführt werden können, während die Anweisung ausgeführt wird.The BeginExecuteReader method starts the process of asynchronously executing a Transact-SQL statement or stored procedure that returns rows, so that other tasks can run concurrently while the statement is executing. Wenn die-Anweisung abgeschlossen ist, müssen Entwickler die EndExecuteReader -Methode aufrufen, um den Vorgang abzuschließen SqlDataReader und das vom Befehl zurückgegebene abzurufen.When the statement has completed, developers must call the EndExecuteReader method to finish the operation and retrieve the SqlDataReader returned by the command. Die BeginExecuteReader Methode wird sofort zurückgegeben, aber bis der Code den EndExecuteReader entsprechenden Methodenaufruf ausführt, dürfen keine anderen Aufrufe ausgeführt werden, die eine synchrone oder asynchrone Ausführung für SqlCommand dasselbe Objekt starten.The BeginExecuteReader method returns immediately, but until the code executes the corresponding EndExecuteReader method call, it must not execute any other calls that start a synchronous or asynchronous execution against the same SqlCommand object. Wenn aufgerufen wird, SqlCommand bevordieAusführungdesBefehlsabgeschlossenist,wirddas-Objektblockiert,bisdieAusführungabgeschlossenist.EndExecuteReaderCalling the EndExecuteReader before the command's execution is completed causes the SqlCommand object to block until the execution is finished.

Mit callback dem-Parameter können Sie AsyncCallback einen-Delegaten angeben, der aufgerufen wird, wenn die-Anweisung abgeschlossen wurde.The callback parameter lets you specify an AsyncCallback delegate that is called when the statement has completed. Sie können die EndExecuteReader -Methode in dieser Delegatprozedur oder an einem beliebigen anderen Speicherort innerhalb der Anwendung abrufen.You can call the EndExecuteReader method from within this delegate procedure, or from any other location within your application. Darüber hinaus können Sie ein beliebiges-Objekt im stateObject -Parameter übergeben, und Ihre Rückruf Prozedur kann diese Informationen mithilfe AsyncState der-Eigenschaft abrufen.In addition, you can pass any object in the stateObject parameter, and your callback procedure can retrieve this information using the AsyncState property.

Mit behavior dem-Parameter können Sie Optionen angeben, mit denen das Verhalten des Befehls und dessen Verbindung gesteuert wird.The behavior parameter lets you specify options that control the behavior of the command and its connection. Diese Werte können zusammen kombiniert werden (mit dem-Operator der Or Programmiersprache). im Allgemeinen verwenden Entwickler CloseConnection den-Wert, um sicherzustellen, dass die Verbindung SqlDataReader von der Laufzeit geschlossen wird, wenn geschlossen wird.These values can be combined together (using the programming language's Or operator); generally, developers use the CloseConnection value to make sure that the connection is closed by the runtime when the SqlDataReader is closed. Entwickler können auch das Verhalten von SqlDataReader optimieren, indem Sie den SingleRow Wert angeben, wenn der Wert im Voraus bekannt ist, dass die Transact-SQL-Anweisung oder die gespeicherte Prozedur nur eine einzelne Zeile zurückgibt.Developers can also optimize the behavior of the SqlDataReader by specifying the SingleRow value when it is known in advance that the Transact-SQL statement or stored procedure only returns a single row.

Beachten Sie, dass der Befehls Text und die Parameter synchron an den Server gesendet werden.Note that the command text and parameters are sent to the server synchronously. Wenn ein großer Befehl oder viele Parameter gesendet werden, kann diese Methode während Schreibvorgängen blockiert werden.If a large command or many parameters are sent, this method may block during writes. Nachdem der Befehl gesendet wurde, wird die Methode sofort zurückgegeben, ohne auf eine Antwort vom Server zu warten, d. h., die Lesevorgänge sind asynchron.After the command is sent, the method returns immediately without waiting for an answer from the server--that is, reads are asynchronous. Obwohl die Befehlsausführung asynchron ist, ist das Abrufen von Werten weiterhin synchron.Although command execution is asynchronous, value fetching is still synchronous. Dies bedeutet, dass Aufrufe Read von möglicherweise blockieren, wenn mehr Daten erforderlich sind und der Lesevorgang des zugrunde liegenden Netzwerks blockiert wird.This means that calls to Read may block if more data is required and the underlying network's read operation blocks.

Da die Rückruf Prozedur in einem Hintergrund Thread ausgeführt wird, der von der Microsoft .NET Common Language Runtime bereitgestellt wird, ist es sehr wichtig, dass Sie einen strengen Ansatz für die Verarbeitung Thread übergreifender Interaktionen in Ihren Anwendungen verwenden.Because the callback procedure executes from within a background thread supplied by the Microsoft .NET common language runtime, it is very important that you take a rigorous approach to handling cross-thread interactions from within your applications. Beispielsweise dürfen Sie nicht innerhalb der Rückruf Prozedur mit dem Inhalt eines Formulars interagieren. Wenn Sie das Formular aktualisieren müssen, müssen Sie wieder zum Thread des Formulars wechseln, um Ihre Arbeit zu erledigen.For example, you must not interact with a form's contents from within your callback procedure--should you have to update the form, you must switch back to the form's thread in order to do your work. Dieses Verhalten wird im Beispiel in diesem Thema veranschaulicht.The example in this topic demonstrates this behavior.

Alle Fehler, die während der Ausführung des Vorgangs auftreten, werden als Ausnahmen in der Rückruf Prozedur ausgelöst.All errors that occur during the execution of the operation are thrown as exceptions in the callback procedure. Sie müssen die Ausnahme in der Rückruf Prozedur und nicht in der Hauptanwendung behandeln.You must handle the exception in the callback procedure, not in the main application. Weitere Informationen zur Behandlung von Ausnahmen in der Rückruf Prozedur finden Sie im Beispiel in diesem Thema.See the example in this topic for additional information on handling exceptions in the callback procedure.

Wenn Sie oder ExecuteReader BeginExecuteReader verwenden, um auf XML-Daten zuzugreifen, gibt SQL Server alle XML-Ergebnisse zurück, die mehr als 2.033 Zeichen lang sind und in mehreren Zeilen mit jeweils 2.033 Zeichen enthalten sind.If you use ExecuteReader or BeginExecuteReader to access XML data, SQL Server will return any XML results greater than 2,033 characters in length in multiple rows of 2,033 characters each. Um dieses Verhalten zu vermeiden, ExecuteXmlReader verwenden BeginExecuteXmlReader Sie oder zum Lesen von for XML-Abfragen.To avoid this behavior, use ExecuteXmlReader or BeginExecuteXmlReader to read FOR XML queries.

Siehe auch

Gilt für: