Realizar operaciones por lotes mediante (ADO.NET)

"Napoleon" wrote in message
news:

La cuestion es que deseo grabar registros en bloque es decir,,, que se
digita una factura y por ende su detalle,, al grabar la cabeza no hay
problema,, pues se dispara la intrucion de insercion y ya tengo generado
la
cabeza de la factura, el problema surge al grabar el detalle, pues tengo
que
barrer fila por fila y eso inplica que a todo momento se va a la bbdd
(conecta y desconecta) y si me surge un error en la insercion en una fila
intermedia tendria que hacer una rutina para borrar los registros
anteriores
a la fila y a la cabeza,,,

yo trabajo esclusivamente con procedimientos almacenados es decir tengo un
sp, par insertar cabeza y un para detalle, lo que deseo es cargar la
rutina
de insercion en una especie de bloque o algo parecido y hacer un solo
conectado y desconectado a la base de datos
Porfavor podrian darme una guia de como poder hacer esto, y si me pueden
ayudar con un ejemplo o documentacion para poder realizar este proceso

Para llamar a dos procedimientos almacenados con una sola apertura de
conexión, no tienes más que abrir la conexión, llamar a uno detrás de otro,
y luego cerrarla, por ejemplo, usando para ello un bloque "using":

using (SqlConnectin cn = new SqlConnection(cadena))
{
cn.Open();
SqlCommand cmd = new SqlCommand("Proc1", cn);
cmd.CommandType = CommandType.StoredProcedure;
cmd.Parameters.Add.
cmd.ExecuteNonQuery();
cmd = new SqlCommand("Proc2", cn);
cmd.CommandType = CommandType.StoredProcedure;
cmd.Parameters.Add.
cmd.ExecuteNonQuery();
}

Si lo que quieres es que, si falla una de las llamadas, se deshaga la
operación completa, lo que te interesa es usar una transacción:

using (SqlConnectin cn = new SqlConnection(cadena))
{
cn.Open();
SqlTransaction trans = cn.BeginTransaction();
try
{
SqlCommand cmd = new SqlCommand("Proc1", cn);
cmd.Transaction = trans;
cmd.CommandType = CommandType.StoredProcedure;
cmd.Parameters.Add.
cmd.ExecuteNonQuery();
cmd = new SqlCommand("Proc2", cn);
cmd.Transaction = trans;
cmd.CommandType = CommandType.StoredProcedure;
cmd.Parameters.Add.
cmd.ExecuteNonQuery();
trans.Commit();
}
catch
{
trans.RollBack();
throw;
}
}

OK, gracias por responder, y tu tiempo..
pero sabes que tengo un problema por cuanto el aplicativo lo tengo en n
capas, y el metodo que me suguieres me ocasiona.. tener la conexion abierta
hasta que termine de barrer los detalles, por lo que con el trajin me
acasionaria un cuello de botella cuando se incremenete la iteracion de
usuarios,
no sabes algun metodo o pasos pasos para abrir la

conexion - instanciar el comando - cerrar
/// cargar comando con sp´s ///
luego abrir conexion- disparar comando - cerra conexion

Lo que te comento es algo que aplicaba en vb 6.0 en un com que utilizo ,
dando propiedades al la conexion y al recorset, pero en .net no se como
aplicar.., con todo te incluyo el codigo de vb.60
Function funObtenerDatos(pCadenaConexion As String, pOpcion As Integer,
pstrCadenaSQL As String, pRS As ADODB.Recordset, pMsj As String) As Boolean
On Error GoTo errManejador
Call funArmaCadenaConexion(pCadenaConexion)
Call funConectar
Select Case pOpcion
Case 2: 'Abrir Conexion
Set pRS = New ADODB.Recordset
pRS.CursorLocation = adUseClient
pRS.CursorType = adOpenKeyset
pRS.LockType = adLockBatchOptimistic
Set pRS.ActiveConnection = cn
pRS.Open pstrCadenaSQL
' pRS.Open pstrCadenaSQL, cn, adOpenDynamic, adLockOptimistic
' pRS.MarshalOptions = adMarshalModifiedOnly
pRS.ActiveConnection = Nothing
Case 3: 'Cerrar
Set pRS.ActiveConnection = cn
pRS.UpdateBatch
Set pRS.ActiveConnection = Nothing
End Select
Call funDesconectar
funObtenerDatos = True
errManejador:
If Err Then
Call funDesconectar
pMsj = Err.Number & " " & Err.Description
Err.Clear
funObtenerDatos = False
End If
End Function
Gracias de antemano por tu tiempo
"Alberto Poblacion"
escribió en el mensaje news:

"Napoleon" wrote in message
news:

La cuestion es que deseo grabar registros en bloque es decir,,, que se
digita una factura y por ende su detalle,, al grabar la cabeza no hay
problema,, pues se dispara la intrucion de insercion y ya tengo generado
la
cabeza de la factura, el problema surge al grabar el detalle, pues tengo
que
barrer fila por fila y eso inplica que a todo momento se va a la bbdd
(conecta y desconecta) y si me surge un error en la insercion en una fila
intermedia tendria que hacer una rutina para borrar los registros
anteriores
a la fila y a la cabeza,,,

yo trabajo esclusivamente con procedimientos almacenados es decir tengo
un
sp, par insertar cabeza y un para detalle, lo que deseo es cargar la
rutina
de insercion en una especie de bloque o algo parecido y hacer un solo
conectado y desconectado a la base de datos
Porfavor podrian darme una guia de como poder hacer esto, y si me pueden
ayudar con un ejemplo o documentacion para poder realizar este proceso

Para llamar a dos procedimientos almacenados con una sola apertura de
conexión, no tienes más que abrir la conexión, llamar a uno detrás de
otro, y luego cerrarla, por ejemplo, usando para ello un bloque "using":

using (SqlConnectin cn = new SqlConnection(cadena))
{
cn.Open();
SqlCommand cmd = new SqlCommand("Proc1", cn);
cmd.CommandType = CommandType.StoredProcedure;
cmd.Parameters.Add.
cmd.ExecuteNonQuery();
cmd = new SqlCommand("Proc2", cn);
cmd.CommandType = CommandType.StoredProcedure;
cmd.Parameters.Add.
cmd.ExecuteNonQuery();
}

Si lo que quieres es que, si falla una de las llamadas, se deshaga la
operación completa, lo que te interesa es usar una transacción:

using (SqlConnectin cn = new SqlConnection(cadena))
{
cn.Open();
SqlTransaction trans = cn.BeginTransaction();
try
{
SqlCommand cmd = new SqlCommand("Proc1", cn);
cmd.Transaction = trans;
cmd.CommandType = CommandType.StoredProcedure;
cmd.Parameters.Add.
cmd.ExecuteNonQuery();
cmd = new SqlCommand("Proc2", cn);
cmd.Transaction = trans;
cmd.CommandType = CommandType.StoredProcedure;
cmd.Parameters.Add.
cmd.ExecuteNonQuery();
trans.Commit();
}
catch
{
trans.RollBack();
throw;
}
}

Creo que lo que buscas lo podrás encontrar aqui :

http://msmvps.com/blogs/cwalzer/arc...-2008.aspx

(Parámetros del tipo Tabla)

OJO, solo para SQL Server 2008.


Cordial saludo,


Mauricio Atanache G.


"Napoleon" escribió en el mensaje de
noticias:

OK, gracias por responder, y tu tiempo..
pero sabes que tengo un problema por cuanto el aplicativo lo tengo en n
capas, y el metodo que me suguieres me ocasiona.. tener la conexion
abierta hasta que termine de barrer los detalles, por lo que con el trajin
me acasionaria un cuello de botella cuando se incremenete la iteracion de
usuarios,
no sabes algun metodo o pasos pasos para abrir la

conexion - instanciar el comando - cerrar
/// cargar comando con spŽs ///
luego abrir conexion- disparar comando - cerra conexion

Lo que te comento es algo que aplicaba en vb 6.0 en un com que utilizo ,
dando propiedades al la conexion y al recorset, pero en .net no se como
aplicar.., con todo te incluyo el codigo de vb.60
Function funObtenerDatos(pCadenaConexion As String, pOpcion As Integer,
pstrCadenaSQL As String, pRS As ADODB.Recordset, pMsj As String) As
Boolean
On Error GoTo errManejador
Call funArmaCadenaConexion(pCadenaConexion)
Call funConectar
Select Case pOpcion
Case 2: 'Abrir Conexion
Set pRS = New ADODB.Recordset
pRS.CursorLocation = adUseClient
pRS.CursorType = adOpenKeyset
pRS.LockType = adLockBatchOptimistic
Set pRS.ActiveConnection = cn
pRS.Open pstrCadenaSQL
' pRS.Open pstrCadenaSQL, cn, adOpenDynamic,
adLockOptimistic
' pRS.MarshalOptions = adMarshalModifiedOnly
pRS.ActiveConnection = Nothing
Case 3: 'Cerrar
Set pRS.ActiveConnection = cn
pRS.UpdateBatch
Set pRS.ActiveConnection = Nothing
End Select
Call funDesconectar
funObtenerDatos = True
errManejador:
If Err Then
Call funDesconectar
pMsj = Err.Number & " " & Err.Description
Err.Clear
funObtenerDatos = False
End If
End Function
Gracias de antemano por tu tiempo
"Alberto Poblacion"
escribió en el mensaje news:

"Napoleon" wrote in message
news:

La cuestion es que deseo grabar registros en bloque es decir,,, que se
digita una factura y por ende su detalle,, al grabar la cabeza no hay
problema,, pues se dispara la intrucion de insercion y ya tengo generado
la
cabeza de la factura, el problema surge al grabar el detalle, pues tengo
que
barrer fila por fila y eso inplica que a todo momento se va a la bbdd
(conecta y desconecta) y si me surge un error en la insercion en una
fila
intermedia tendria que hacer una rutina para borrar los registros
anteriores
a la fila y a la cabeza,,,

yo trabajo esclusivamente con procedimientos almacenados es decir tengo
un
sp, par insertar cabeza y un para detalle, lo que deseo es cargar la
rutina
de insercion en una especie de bloque o algo parecido y hacer un solo
conectado y desconectado a la base de datos
Porfavor podrian darme una guia de como poder hacer esto, y si me pueden
ayudar con un ejemplo o documentacion para poder realizar este proceso

Para llamar a dos procedimientos almacenados con una sola apertura de
conexión, no tienes más que abrir la conexión, llamar a uno detrás de
otro, y luego cerrarla, por ejemplo, usando para ello un bloque "using":

using (SqlConnectin cn = new SqlConnection(cadena))
{
cn.Open();
SqlCommand cmd = new SqlCommand("Proc1", cn);
cmd.CommandType = CommandType.StoredProcedure;
cmd.Parameters.Add.
cmd.ExecuteNonQuery();
cmd = new SqlCommand("Proc2", cn);
cmd.CommandType = CommandType.StoredProcedure;
cmd.Parameters.Add.
cmd.ExecuteNonQuery();
}

Si lo que quieres es que, si falla una de las llamadas, se deshaga la
operación completa, lo que te interesa es usar una transacción:

using (SqlConnectin cn = new SqlConnection(cadena))
{
cn.Open();
SqlTransaction trans = cn.BeginTransaction();
try
{
SqlCommand cmd = new SqlCommand("Proc1", cn);
cmd.Transaction = trans;
cmd.CommandType = CommandType.StoredProcedure;
cmd.Parameters.Add.
cmd.ExecuteNonQuery();
cmd = new SqlCommand("Proc2", cn);
cmd.Transaction = trans;
cmd.CommandType = CommandType.StoredProcedure;
cmd.Parameters.Add.
cmd.ExecuteNonQuery();
trans.Commit();
}
catch
{
trans.RollBack();
throw;
}
}