1: Führen Sie eine gespeicherte Prozedur ohne Rückgabeparameter aus (Eingabe)
1: Schreiben Sie zunächst eine gespeicherte Prozedur in die Datenbank, z. B. Erstellen einer gespeicherten Prozedur „addUser“.
Proc addUser erstellen
@ID int,
@Name varchar(20),
@Sex varchar(20)
As
In Benutzerwerte einfügen( @ID, @Name, @Sex )
2: Erstellen Sie ein SqlCommand-Objekt und initialisieren Sie das SqlCommand-Objekt wie:
SqlCommand cmd = new SqlCommand( );
cmd.CommandText = "addUser"; // Rufen Sie Which Stored Procedure auf
cmd.CommandType = CommandType.StoredProcedure; // Legen Sie den SQL-Befehlstyp auf eine gespeicherte Prozedur fest, und der Standardwert ist SQL-Anweisung.
cmd.Connection = con; // Verbindung festlegen
3: Gespeicherte Prozedurparameter zum SqlCommand-Objekt hinzufügen
SqlParameter param = new SqlParameter( ); // Definieren Sie ein Parameterobjekt
param .ParameterName = "@ID"; //Parametername der gespeicherten Prozedur
param.Value = txtID.Text.Trim(); //Der Wert dieses Parameters
cmd.Parameters.Add( param ); / SqlCommand Object fügt dieses Parameterobjekt hinzu
param = new SqlParameter( "@Name", txtName.Text.Trim() ); // Abkürzung
cmd.Parameters.Add( param );
4: Das SqlCommand-Objekt ruft die Funktion auf, die Sql ausführt. Zum Beispiel:
cmd.ExecuteNonQuery();
2: Führen Sie eine gespeicherte Prozedur mit Rückgabeparametern aus (Ausgabe)
1: Schreiben Sie zunächst eine gespeicherte Prozedur in die Datenbank, z. B. das Erstellen eines gespeicherten queryUser Verfahren.
alter Proc queryUser
@ID int,
@Suc varchar(10) Output
As
select @Suc= 'false'
falls vorhanden( Wählen Sie * Von Benutzern aus, bei denen u_id = @ID )
select @Suc = 'success'
2: Erstellen Sie ein SqlCommand-Objekt und initialisieren Sie das SqlCommand-Objekt wie:
SqlCommand cmd = new SqlCommand( );
cmd.CommandText = " queryUser"; //Geben Sie an, welche gespeicherte Prozedur aufgerufen werden soll
cmd.CommandType = CommandType.StoredProcedure; //Geben Sie an, dass der SQL-Befehlstyp eine gespeicherte Prozedur ist und der Standardwert eine SQL-Anweisung ist.
cmd.Connection = con; // Verbindung festlegen
3: Gespeicherte Prozedurparameter zum SqlCommand-Objekt hinzufügen
SqlParameter param1 = new SqlParameter( "@ID", txtID.Text ); / Eingabeparameter hinzufügen
cmd.Parameters.Add( param1 );
SqlParameter param2 = new SqlParameter(); // Ausgabeparameter hinzufügen
param2.ParameterName = "@Suc";
param2.SqlDbType = SqlDbType.VarChar; //SQL-Typ des Ausgabeparameters
param2.Size = 10;//SQL-Typgröße des Ausgabeparameters
param2.Direction = ParameterDirection.Output; //Geben Sie dies an Parameter Das Objekt ist der Ausgabeparametertyp
cmd.Parameters.Add( param2 ); Zum Beispiel:
cmd.ExecuteNonQuery();
MessageBox.Show( param2.Value.ToString() ); // Den Wert des Ausgabeparameters ausgeben
Beispiel einer gespeicherten Prozedur für Eingabeparameter :
try
{
SqlCommand cmd = new SqlCommand();
cmd.Connection = con;
cmd.CommandType = CommandType.StoredProcedure;
cmd.CommandText = "addUser" ;
SqlParameter param = new SqlParameter( );
param.ParameterName = "@ID";
param.Value = txtID.Text.Trim();
cmd.Parameters.Add ( param ) ;
param = new SqlParameter( "@Name", txtName.Text.Trim() );
cmd.Parameters.Add( param );
param = new SqlParameter() ;
param.ParameterName = "@Sex";
param.Value = txtSex.Text.Trim();
cmd.Parameters.Add( param );
/ /da. InsertCommand = cmd;
if ( cmd.ExecuteNonQuery() == 1 )
{
MessageBox.Show( "Erfolgreich hinzugefügt" );
}
else
{
MessageBox.Show("Failed");
}
}
catch( SqlException ex )
{
MessageBox.Show( ex.Message );
}
Beispiel einer gespeicherten Prozedur, die Parameter ausgibt:
try
{
SqlCommand cmd = new SqlCommand( );
cmd.CommandText = "queryUser";
cmd. CommandType = CommandType .StoredProcedure;
cmd.Connection = con;
SqlParameter param1 = new SqlParameter( "@ID", txtID.Text );
cmd.Parameters.Add( param1 );
SqlParameter param2 = new SqlParameter();
param2.ParameterName = "@Suc";
param2.SqlDbType = SqlDbType.VarChar;
param2.Size = 10;
param2. Direction = ParameterDirection .Output;
cmd.Parameters.Add( param2 );
cmd.ExecuteNonQuery();
MessageBox.Show( param1.Value.ToString() );
MessageBox .Show( param2.Value.ToString() );
}
catch( SqlException ex )
{
MessageBox.Show( ex.Message );
}
Die Methode zum Abrufen des Rückgabewerts in ado.net ist (c#):
---------------------------------------- ---- ----------------------------------
SqlConnection dbconn = new SqlConnection(connStr);
SqlCommand cmd = new SqlCommand("sp_uptmp",dbconn);
cmd.CommandType = CommandType.StoredProcedure;
SqlParameter tmpName = cmd.Parameters.Add("@tmpName",SqlDbType.VarChar );
SqlParameter srcPos = _cmd.Parameters.Add("@srcPos",SqlDbType.VarChar);
SqlParameter rtnval = cmd.Parameters.Add("rval",SqlDbType.Int);
tmpName.Direction = ParameterDirection. Input;
srcPos.Direction = ParameterDirection.Input;
rtnval.Direction = ParameterDirection.ReturnValue;
tmpName.Value = "";
srcPos.Value = "";
dbconn.Open();
cmd.ExecuteNonQuery();
dbconn.Close();
tmpid = (int)rtnval.Value; //Dies ist der Rückgabewert
Angenommen, es gibt eine gespeicherte Prozedur wie folgt:
------------- ------------------------------------
CREATE proc sp_uptmp @tmpName varchar(50 ),@srcPos varchar( 255)
as
Begin TRAN
in t_template-Werte einfügen(@tmpName,@srcPos)
COMMIT
return isnull(@@identity ,0)
LOS
---------------------------------- ------ --------------------
Die Methode zum Abrufen des Rückgabewerts in ado.net ist (c#):
-- ------- ------------------------------------------- ------- -
SqlConnection dbconn = new SqlConnection(connStr);
SqlCommand cmd = new SqlCommand("sp_uptmp",dbconn);
cmd.CommandType = CommandType.StoredProcedure;
SqlParameter tmpName = cmd .Parameters.Add("@tmpName",SqlDbType.VarChar);
SqlParameter srcPos = _cmd.Parameters.Add("@srcPos",SqlDbType.VarChar);
SqlParameter rtnval = cmd.Parameters.Add(" rval",SqlDbType.Int);
tmpName.Direction = ParameterDirection.Input;
srcPos.Direction = ParameterDirection.Input;
rtnval.Direction = ParameterDirection.ReturnValue ;
tmpName.Value = "";
srcPos.Value = "";
dbconn.Open();
cmd.ExecuteNonQuery();
dbconn.Close() ;
tmpid = (int)rtnval.Value; //Dies ist der Rückgabewert
In der ADO-Umgebung ist die übliche Praxis beim Aufrufen einer gespeicherten Prozedur zum Abfragen von Daten:
1 Erstellen Sie ein Verbindungsbefehlsobjekt
2 Öffnen Sie die Verbindung, weisen Sie dem Befehl den Namen, den Datentyp und den Wert des Parameters zu
3 Führen Sie das Befehlsobjekt aus
4 Geben Sie das Recordset-Objekt an den Client zurück
Auf diese Weise müssen Sie bei jedem Aufruf der gespeicherten Prozedur den Anweisungen in der gespeicherten Prozedur folgen. Der Datentyp des Parameters erstellt ein Parameterobjekt
. Wenn eine gespeicherte Prozedur beispielsweise zwei Parameter @ID int erfordert und @Name varchar(10), es muss
'Parameter erstellen
cmd.Parameters.Append cmd.CreateParameter("@ID ",adInteger,adParamInput,4)
cmd.Parameters.Append cmd. CreateParameter("@Name",adVarChar,adParamInput,10)
'Weisen Sie dem Parameter einen Wert zu
cmd("@State") = 1
cmd("@WhereT")=“2“
Jedes Mal, wenn Sie eine gespeicherte Prozedur aufrufen, müssen Sie alle Parameter der gespeicherten Prozedur manuell hinzufügen und Ihre eigene Gehirnleistung einsetzen, um den Datentyp der Parameter und die Informationen der Parameter in der gespeicherten Prozedur sicherzustellen.
Das Command.Parameters-Objekt verfügt über eine Refresh-Methode. Die Funktion dieser Methode besteht darin, die Namen und Datentypen aller vom aktuellen Command-Objekt benötigten Parameter zu lesen Hier ist die Funktion eine allgemeine Funktion einer gespeicherten Prozedur, die eine Ergebnismenge zurückgibt. Es ist einfach und kann nach Bedarf verfeinert werden.
‘Debugging in Visual Basic 6.0 bestanden.
Function GetRsByPro(strConnString As String, strProName As String, arjParameter() As String)
' Gibt den abgefragten Datensatz zurück
' strConnString Datenverbindungszeichenfolge
' strProName Name der gespeicherten Prozedur
' arjParameter () Von der gespeicherten Prozedur benötigtes Array
On Error GoTo errMsg
'ADO-Objekt erstellen
Dim Cmd As New Command
' ASP Con = Server.CreateObject("ADODB.Connection")
Con als neue Verbindung dimmen
' ASP Set Cmd = Server.CreateObject("ADODB.Command")
Rs als neues Recordset dimmen
' ASP Set rs = Server.CreateObject("ADODB.Recordset")
'Datenbank öffnen
Con.Open strConnString
Set Cmd.ActiveConnection = Con
Cmd.Commandtype = adCmdStoredProc
Cmd.Parameters.Refresh
If UBound(arjParameter) < > For i = 0 To Cmd .Parameters.Count - 1
Cmd.Parameters(i).Value = arjParameter(i)
Next
'Set Recordset object
Rs.CursorType = 3
Rs.LockType = 3
Rs.CursorLocation = 3
Set Rs.Source = Cmd
Rs.Open
'Return result set
Set GetRsByPro = Rs
'Datenquelle schließen
Con.Close
Set Con = Nothing
errMsg:
Debug.Print Err.Description
End Function
'Call Demo
Rs als neues Recordset dimmen
StrConnString=““
StrProName=“pro_GetAllUser“
ArjParameter(1) dimmen
arjParameter(0)=“1“
arjParameter(1)=“ Shandong“
Set Rs= GetRsByPro(strConnString, strProName, arjParameter())
Mit derselben Methode in der .NET-Entwicklungsumgebung können Sie auch eine allgemeine Methode zum Aufrufen der gespeicherten Prozedur erstellen.
In ADO.NET verfügt weder das OleDbCommand.Parameters-Objekt noch das SqlCommand.Parameters-Objekt über eine Refresh-Methode zum Lesen der Parameterinformationen der gespeicherten Prozedur. .NET stellt eine statische DeriveParameters-Methode in der OleDbCommandBuilder-Klasse bereit, um dieselbe Funktion zu erreichen .
Beschreibung von DeriveParameters im .NET SDK
„Verwenden Sie die Parameterinformationen der in SqlCommand angegebenen gespeicherten Prozedur, um die Parametersammlung des angegebenen SqlCommand-Objekts zu füllen.“
SqlConnection Conn=new SqlConnection(cnString);
Conn.Open();
SqlCommand Comm=new SqlCommand();
Comm.Connection =conn;
Comm.CommandType =CommandType. StoredProcedure ;
Comm.CommandText =proName;
SqlCommandBuilder.DeriveParameters(comm);
//Nach dieser Methode hat das SqlParameters-Objekt des SqlCommand-Objekts dabei geholfen, die Informationen in der gespeicherten Prozedur zu ermitteln
Implementieren Ausführung Jede gespeicherte Prozedur gibt den spezifischen Funktionscode eines DataSet-Objekts zurück
Dateiname: TestSqlAccess.cs
// Debuggen in vs.net über
using System;
using System.Data;
using System.Xml;
using System.Data.SqlClient;
using System.Data.OleDb;
using System.Collections;
namespace Erp
{
public versiegelt class TestSqlAccess
{
#region Ruft die Parametersammlung der gespeicherten Prozedur ab
public static SqlParameter [] getParameters(string cnString,string proName)
{
SqlConnection conn=new SqlConnection(cnString);
conn.Open();
SqlCommand comm=new SqlCommand();
comm.Connection =conn;
comm.CommandType =CommandType.StoredProcedure;
comm.CommandText =proName;
SqlCommandBuilder.DeriveParameters(comm);
SqlParameter [] arPrm=new SqlParameter[comm.Parameters.Count];
for (int i=0;i {
arPrm[i]=new SqlParameter();
arPrm[i].SqlDbType =comm.Parameters[i].SqlDbType;
arPrm[i].ParameterName=comm.Parameters[i ]. ParameterName;
arPrm[i].Size =comm.Parameters[i].Size;
}
return arPrm;
}
#endregion
# Region führt das Command-Objekt aus und gibt DataSet zurück
/////Sie können die von Microsoft bereitgestellte SqlHelper-Klasse aufrufen...
#endregion Das Ausführen des Command-Objekts gibt ein DataSet zurück
Verwenden eines DataReader zum Zurückgeben von Zeilen und Parametern
Sie können ein DataReader-Objekt verwenden, um einen schreibgeschützten Forward-Only-Datenstrom zurückzugeben . Die im DataReader enthaltenen Informationen können aus einer gespeicherten Prozedur stammen. In diesem Beispiel wird ein DataReader-Objekt verwendet, um eine gespeicherte Prozedur mit Eingabe- und Ausgabeparametern auszuführen, und anschließend werden die zurückgegebenen Datensätze durchlaufen, um die Rückgabeparameter anzuzeigen.
1. Erstellen Sie die folgende gespeicherte Prozedur auf dem Server, auf dem Microsoft SQL Server ausgeführt wird: Create Procedure TestProcedure
(
@au_idIN varchar (11),
@numTitlesOUT Integer OUTPUT
)
AS
Wählen Sie A.au_fname, A.au_lname, T.title
aus den Autoren als A und verbinden Sie den Titelautor als TA on
A.au_id=TA.au_id
Titel als T zusammenführen
on T.title_id=TA.title_id
wobei A.au_id= @ au_idIN
set @numTitlesOUT = @@Rowcount
return (5)
2. Erstellen Sie ein neues Visual C# .NET Windows-Anwendungsprojekt.
3. Verwenden Sie Using-Anweisungen für die Namespaces System und System.Data, sodass im nachfolgenden Code keine Deklarationen in diesen Namespaces qualifiziert werden müssen. Fügen Sie diesen Code oben im Codemodul „Formulare“ hinzu. Achten Sie darauf, nur den Code zu kopieren, der dem von Ihnen ausgewählten Anbieter entspricht. SQL-Client mit System.Data.SqlClient;
OLE DB-Datenanbieter mit System.Data.OleDb;
4. Ersetzen Sie den Code im privaten Form_Load-Ereignis durch den folgenden Code: SQL Client SqlConnection PubsConn = new SqlConnection
("Data Source=server;integrated " +
"Security=sspi;initial Catalog=pubs;");
SqlCommand testCMD = new SqlCommand
("TestProcedure", PubsConn);
testCMD.CommandType = CommandType.StoredProcedure;
SqlParameter RetVal = testCMD.Parameters.Add
"RetVal ", SqlDbType.Int);
RetVal.Direction = ParameterDirection.ReturnValue;
SqlParameter IdIn = testCMD.Parameters.Add
("@au_idIN", SqlDbType .VarChar , 11);
IdIn.Direction = ParameterDirection.Input;
SqlParameter NumTitles = testCMD.Parameters.Add
("@numtitlesout", SqlDbType.VarChar, 11) ;
NumTitles.Direction = ParameterDirection.Output;
IdIn.Value = "213-46-8915";
PubsConn.Open();
SqlDataReader myReader = testCMD.ExecuteReader();
Console.WriteLine ("Buchtitel für diesen Autor:");
while (myReader.Read())
{
Console.WriteLine ("{0}", myReader.GetString (2));
};
myReader.Close();
Console.WriteLine("Anzahl der Zeilen:" + NumTitles.Value);
Console.WriteLine("Return Value:" + RetValue.Value);
OLE DB-Daten bereitgestelltes Programm OleDbConnection PubsConn = new OleDbConnection
("Provider=SQLOLEDB;Data Source=server;" +
"integrated Security=sspi;initial Catalog=pubs;");
OleDbCommand testCMD = new OleDbCommand
("TestProcedure", PubsConn);
testCMD.CommandType = CommandType.StoredProcedure; 🎜 >
("RetVal", OleDbType.Integer);RetVal.Direction = ParameterDirection.ReturnValue;
OleDbParameter IdIn = testCMD.Parameters.Add
("@au_idIN", OleDbType.VarChar , 11);
IdIn.Direction = ParameterDirection.Input;
OleDbParameter NumTitles = testCMD.Parameters.Add
("@numtitlesout", OleDbType.VarChar, 11) ;
NumTitles.Direction = ParameterDirection.Output;
IdIn.Value = "213-46-8915";
PubsConn.Open();
OleDbDataReader myReader = testCMD.ExecuteReader();
Console.WriteLine ("Buchtitel für diesen Autor:");
while (myReader.Read())
{
Console.WriteLine ("{0}", myReader.GetString (2));
};
myReader.Close();
Console.WriteLine("Anzahl der Zeilen:" + NumTitles.Value);
Console.WriteLine("Return Value:" + RetValue.Value);
5. 修改 Connection 对象的连接字符串，以便指向运行 SQL Server 的计算机。
6. 运行此代码。注意，DataReader数值.您可以使用 DataReader 对象的 Read 方法遍历返回的记录.
输出窗口显示两本书的标题、返回值 5 和输出参数,其中包含记录的数目 (2)。注意,您必须关闭代码中的 DataReader ist eine vertrauenswürdige Lösung DataReader,则不必为了查看返回参数而遍历所有记录.
