SqlCommand.BeginExecuteNonQuery Método
Definición
Importante
Parte de la información hace referencia a la versión preliminar del producto, que puede haberse modificado sustancialmente antes de lanzar la versión definitiva. Microsoft no otorga ninguna garantía, explícita o implícita, con respecto a la información proporcionada aquí.
Sobrecargas
| BeginExecuteNonQuery() |
Inicia la ejecución asincrónica de la instrucción Transact-SQL o el procedimiento almacenado descrito por este SqlCommand . |
| BeginExecuteNonQuery(AsyncCallback, Object) |
Inicia la ejecución asincrónica de la instrucción Transact-SQL o el procedimiento almacenado descrito por este SqlCommand , dado un procedimiento de devolución de llamada e información de estado. |
BeginExecuteNonQuery()
Inicia la ejecución asincrónica de la instrucción Transact-SQL o el procedimiento almacenado descrito por este SqlCommand .
public:
IAsyncResult ^ BeginExecuteNonQuery();public IAsyncResult BeginExecuteNonQuery ();member this.BeginExecuteNonQuery : unit -> IAsyncResultPublic Function BeginExecuteNonQuery () As IAsyncResultDevoluciones
que IAsyncResult se puede usar para sondear o esperar resultados, o ambos; este valor también es necesario al invocar EndExecuteNonQuery(IAsyncResult) , que devuelve el número de filas afectadas.
Excepciones
Se usó un SqlDbType valor distinto de Binary o VarBinary cuando Value se estableció Stream en . Para obtener más información sobre el streaming, vea Compatibilidad de transmisión de datos de SqlClient.
o bien
Un SqlDbType valor distinto de Char, NChar, NVarChar, VarChar o Xml se usó cuando Value se estableció TextReader en .
O bien
Se usó un SqlDbType valor distinto de Xml cuando Value se estableció en XmlReader .
Cualquier error que se produjo al ejecutar el texto del comando.
o bien
Se agotó el tiempo de espera durante una operación de streaming. Para obtener más información sobre el streaming, vea Compatibilidad de transmisión de datos de SqlClient.
La SqlConnection se cerró o se interrumpió durante una operación de streaming. Para obtener más información sobre el streaming, vea Compatibilidad de transmisión de datos de SqlClient.
- or -
<xref data-throw-if-not-resolved="true" uid="Microssoft.Data.SqlClient.SqlCommand.EnableOptimizedParameterBinding"></xref>
is set to true and a parameter with direction Output or InputOutput has been added to the <xref data-throw-if-not-resolved="true" uid="Microsoft.Data.SqlClient.SqlCommand.Parameters"></xref> collection.
Error en un Stream objeto o XmlReaderTextReader durante una operación de streaming. Para obtener más información sobre el streaming, vea Compatibilidad de transmisión de datos de SqlClient.
El Stream objeto , XmlReader o TextReader se cerró durante una operación de streaming. Para obtener más información sobre el streaming, vea Compatibilidad de transmisión de datos de SqlClient.
Ejemplos
La siguiente aplicación de consola crea datos de actualizaciones en la base de datos de ejemplo AdventureWorks , realizando su trabajo de forma asincrónica. Para emular un proceso de ejecución prolongada, en este ejemplo se inserta una instrucción WAITFOR en el texto del comando. Normalmente, no realizaría esfuerzos para que los comandos se ejecuten más lentamente, pero hacerlo en este caso facilita la demostración del comportamiento asincrónico.
// <Snippet1>
using System;
using System.Data;
using Microsoft.Data.SqlClient;
class Class1
{
static void Main()
{
// This is a simple example that demonstrates the usage of the
// BeginExecuteNonQuery functionality.
// The WAITFOR statement simply adds enough time to prove the
// asynchronous nature of the command.
string commandText =
"UPDATE Production.Product SET ReorderPoint = ReorderPoint + 1 " +
"WHERE ReorderPoint Is Not Null;" +
"WAITFOR DELAY '0:0:3';" +
"UPDATE Production.Product SET ReorderPoint = ReorderPoint - 1 " +
"WHERE ReorderPoint Is Not Null";
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
{
int count = 0;
SqlCommand command = new SqlCommand(commandText, connection);
connection.Open();
IAsyncResult result = command.BeginExecuteNonQuery();
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);
}
Console.WriteLine("Command complete. Affected {0} rows.",
command.EndExecuteNonQuery(result));
}
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 string GetConnectionString()
{
// To avoid storing the connection string in your code,
// you can retrieve it from a configuration file.
return "Data Source=(local);Integrated Security=SSPI;" +
"Initial Catalog=AdventureWorks";
}
}
// </Snippet1>
Comentarios
El BeginExecuteNonQuery método inicia el proceso de ejecutar de forma asincrónica una instrucción Transact-SQL o un procedimiento almacenado que no devuelve filas, de modo que otras tareas se puedan ejecutar simultáneamente mientras se ejecuta la instrucción. Una vez completada la instrucción , los desarrolladores deben llamar al EndExecuteNonQuery método para finalizar la operación. El BeginExecuteNonQuery método devuelve inmediatamente, pero hasta que el código ejecuta la llamada al método correspondiente EndExecuteNonQuery , no debe ejecutar ninguna otra llamada que inicie una ejecución sincrónica o asincrónica en el mismo SqlCommand objeto. EndExecuteNonQuery Al llamar a antes de que se complete la ejecución del comando, el SqlCommand objeto se bloqueará hasta que finalice la ejecución.
Tenga en cuenta que el texto del comando y los parámetros se envían al servidor de forma sincrónica. Si se envía un comando grande o muchos parámetros, este método puede bloquearse durante las escrituras. Una vez enviado el comando, el método devuelve inmediatamente sin esperar una respuesta del servidor, es decir, las lecturas son asincrónicas.
Dado que esta sobrecarga no admite un procedimiento de devolución de llamada, los desarrolladores deben sondear para determinar si el comando se ha completado, mediante la IsCompleted propiedad del IAsyncResult devuelto por el BeginExecuteNonQuery método; o esperar a que se complete uno o varios comandos mediante la AsyncWaitHandle propiedad del devuelto IAsyncResult.
Este método omite la CommandTimeout propiedad .
Se aplica a
BeginExecuteNonQuery(AsyncCallback, Object)
Inicia la ejecución asincrónica de la instrucción Transact-SQL o el procedimiento almacenado descrito por este SqlCommand , dado un procedimiento de devolución de llamada e información de estado.
public:
IAsyncResult ^ BeginExecuteNonQuery(AsyncCallback ^ callback, System::Object ^ stateObject);public IAsyncResult BeginExecuteNonQuery (AsyncCallback callback, object stateObject);member this.BeginExecuteNonQuery : AsyncCallback * obj -> IAsyncResultPublic Function BeginExecuteNonQuery (callback As AsyncCallback, stateObject As Object) As IAsyncResultParámetros
- callback
- AsyncCallback
Delegado AsyncCallback que se invoca cuando finaliza la ejecución del comando. Aprobadonull ( Nothing en Microsoft Visual Basic) para indicar que no se requiere ninguna devolución de llamada.
- stateObject
- Object
Objeto de estado definido por el usuario que se pasa al procedimiento de devolución de llamada. Recupere este objeto desde el procedimiento de devolución de llamada mediante la propiedad AsyncState.
Devoluciones
que IAsyncResult se puede usar para sondear o esperar resultados, o ambos; este valor también es necesario al invocar EndExecuteNonQuery(IAsyncResult) , que devuelve el número de filas afectadas.
Excepciones
Se usó un SqlDbType valor distinto de Binary o VarBinary cuando Value se estableció Stream en . Para obtener más información sobre el streaming, vea Compatibilidad de transmisión de datos de SqlClient.
o bien
Un SqlDbType valor distinto de Char, NChar, NVarChar, VarChar o Xml se usó cuando Value se estableció TextReader en .
O bien
Se usó un SqlDbType valor distinto de Xml cuando Value se estableció en XmlReader .
Cualquier error que se produjo al ejecutar el texto del comando.
o bien
Se agotó el tiempo de espera durante una operación de streaming. Para obtener más información sobre el streaming, vea Compatibilidad de transmisión de datos de SqlClient.
La SqlConnection se cerró o se interrumpió durante una operación de streaming. Para obtener más información sobre el streaming, vea Compatibilidad de transmisión de datos de SqlClient.
- or -
<xref data-throw-if-not-resolved="true" uid="Microssoft.Data.SqlClient.SqlCommand.EnableOptimizedParameterBinding"></xref>
is set to true and a parameter with direction Output or InputOutput has been added to the <xref data-throw-if-not-resolved="true" uid="Microsoft.Data.SqlClient.SqlCommand.Parameters"></xref> collection.
Ejemplos
La siguiente aplicación de Windows muestra el uso del BeginExecuteNonQuery método , ejecutando una instrucción Transact-SQL que incluye un retraso de varios segundos (emulando un comando de ejecución prolongada).
En este ejemplo se muestran muchas técnicas importantes. Esto incluye llamar a un método que interactúa con el formulario desde un subproceso independiente. Además, en este ejemplo se muestra cómo se debe impedir que los usuarios ejecuten un comando varias veces simultáneamente y cómo debe asegurarse de que el formulario no se cierra antes de llamar al procedimiento de devolución de llamada.
Para configurar este ejemplo, cree una aplicación Windows. Coloque un Button control y un Label control en el formulario (aceptando el nombre predeterminado para cada control). Agregue el código siguiente a la clase del formulario, modificando la cadena de conexión según sea necesario para su entorno.
// <Snippet1>
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Text;
using System.Windows.Forms;
using Microsoft.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:
private void Form1_Load(object sender, EventArgs e)
{
this.button1.Click += new System.EventHandler(this.button1_Click);
this.FormClosing += new System.Windows.Forms.
FormClosingEventHandler(this.Form1_FormClosing);
}
// You need this delegate in order to display text from a thread
// other than the form's thread. See the HandleCallback
// procedure for more information.
// This same delegate matches both the DisplayStatus
// and DisplayResults methods.
private delegate void DisplayInfoDelegate(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;
// This example maintains the connection object
// externally, so that it is available for closing.
private SqlConnection connection;
private static string GetConnectionString()
{
// To avoid storing the connection string in your code,
// you can retrieve it from a configuration file.
return "Data Source=(local);Integrated Security=true;" +
"Initial Catalog=AdventureWorks";
}
private void DisplayStatus(string Text)
{
this.label1.Text = Text;
}
private void DisplayResults(string Text)
{
this.label1.Text = Text;
DisplayStatus("Ready");
}
private void Form1_FormClosing(object sender,
System.Windows.Forms.FormClosingEventArgs e)
{
if (isExecuting)
{
MessageBox.Show(this, "Cannot close the form until " +
"the pending asynchronous command has completed. Please wait...");
e.Cancel = 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
{
DisplayResults("");
DisplayStatus("Connecting...");
connection = new SqlConnection(GetConnectionString());
// To emulate a long-running query, wait for
// a few seconds before working with the data.
// This command does not do much, but that's the point--
// it does not change your data, in the long run.
string commandText =
"WAITFOR DELAY '0:0:05';" +
"UPDATE Production.Product SET ReorderPoint = ReorderPoint + 1 " +
"WHERE ReorderPoint Is Not Null;" +
"UPDATE Production.Product SET ReorderPoint = ReorderPoint - 1 " +
"WHERE ReorderPoint Is Not Null";
command = new SqlCommand(commandText, connection);
connection.Open();
DisplayStatus("Executing...");
isExecuting = true;
// Although it is not required that you pass the
// SqlCommand object as the second parameter in the
// BeginExecuteNonQuery call, doing so makes it easier
// to call EndExecuteNonQuery in the callback procedure.
AsyncCallback callback = new AsyncCallback(HandleCallback);
command.BeginExecuteNonQuery(callback, command);
}
catch (Exception ex)
{
isExecuting = false;
DisplayStatus(string.Format("Ready (last error: {0})", ex.Message));
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;
int rowCount = command.EndExecuteNonQuery(result);
string rowText = " rows affected.";
if (rowCount == 1)
{
rowText = " row affected.";
}
rowText = rowCount + rowText;
// 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
// displays the results, like this:
// DisplayResults(rowText)
// 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.
DisplayInfoDelegate del = new DisplayInfoDelegate(DisplayResults);
this.Invoke(del, rowText);
}
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 none of
// your code is 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 DisplayInfoDelegate(DisplayStatus),
String.Format("Ready(last error: {0}", ex.Message));
}
finally
{
isExecuting = false;
if (connection != null)
{
connection.Close();
}
}
}
}
}
// </Snippet1>
Comentarios
El BeginExecuteNonQuery método inicia el proceso de ejecutar de forma asincrónica una instrucción Transact-SQL o un procedimiento almacenado que no devuelve filas, de modo que otras tareas se puedan ejecutar simultáneamente mientras se ejecuta la instrucción. Una vez completada la instrucción , los desarrolladores deben llamar al EndExecuteNonQuery método para finalizar la operación. El BeginExecuteNonQuery método devuelve inmediatamente, pero hasta que el código ejecuta la llamada al método correspondiente EndExecuteNonQuery , no debe ejecutar ninguna otra llamada que inicie una ejecución sincrónica o asincrónica en el mismo SqlCommand objeto. EndExecuteNonQuery Al llamar a antes de que se complete la ejecución del comando, el SqlCommand objeto se bloqueará hasta que finalice la ejecución.
El callback parámetro permite especificar un AsyncCallback delegado al que se llama cuando la instrucción se ha completado. Puede llamar al EndExecuteNonQuery método desde dentro de este procedimiento delegado o desde cualquier otra ubicación dentro de la aplicación. Además, puede pasar cualquier objeto en el asyncStateObject parámetro y el procedimiento de devolución de llamada puede recuperar esta información mediante la AsyncState propiedad .
Tenga en cuenta que el texto del comando y los parámetros se envían al servidor de forma sincrónica. Si se envía un comando grande o muchos parámetros, este método puede bloquearse durante las escrituras. Una vez enviado el comando, el método devuelve inmediatamente sin esperar una respuesta del servidor, es decir, las lecturas son asincrónicas.
Dado que el procedimiento de devolución de llamada se ejecuta desde dentro de un subproceso en segundo plano proporcionado por Common Language Runtime de Microsoft .NET, es muy importante adoptar un enfoque riguroso para controlar las interacciones entre subprocesos desde dentro de las aplicaciones. Por ejemplo, no debe interactuar con el contenido de un formulario desde el procedimiento de devolución de llamada; si tiene que actualizar el formulario, debe volver al subproceso del formulario para realizar el trabajo. En el ejemplo de este tema se muestra este comportamiento.
Todos los errores que se producen durante la ejecución de la operación se producen como excepciones en el procedimiento de devolución de llamada. Debe controlar la excepción en el procedimiento de devolución de llamada, no en la aplicación principal. Consulte el ejemplo de este tema para obtener información adicional sobre el control de excepciones en el procedimiento de devolución de llamada.
Este método omite la CommandTimeout propiedad .