web-dev-qa-db-fra.com

Vous appelez la procédure stockée Oracle à partir de C #?

Comment appeler une procédure stockée dans Oracle à partir de C #?

c#.netoraclestored-proceduresado.net
25
Rohan

Veuillez visiter ce site ODP mis en place par Oracle pour les développeurs Microsoft OracleClient: http://www.Oracle.com/technetwork/topics/dotnet/index-085703.html

Vous trouverez également ci-dessous un exemple de code qui vous permet de commencer à appeler une procédure stockée de C # vers Oracle. PKG_COLLECTION.CSP_COLLECTION_HDR_SELECT est la procédure stockée construite sur Oracle acceptant les paramètres PUNIT, POFFICE, PRECEIPT_NBR et renvoyant le résultat dans T_CURSOR.

using Oracle.DataAccess;
using Oracle.DataAccess.Client;

public DataTable GetHeader_BySproc(string unit, string office, string receiptno)
{
    using (OracleConnection cn = new OracleConnection(DatabaseHelper.GetConnectionString()))
    {
        OracleDataAdapter da = new OracleDataAdapter();
        OracleCommand cmd = new OracleCommand();
        cmd.Connection = cn;
        cmd.InitialLONGFetchSize = 1000;
        cmd.CommandText = DatabaseHelper.GetDBOwner() + "PKG_COLLECTION.CSP_COLLECTION_HDR_SELECT";
        cmd.CommandType = CommandType.StoredProcedure;
        cmd.Parameters.Add("PUNIT", OracleDbType.Char).Value = unit;
        cmd.Parameters.Add("POFFICE", OracleDbType.Char).Value = office;
        cmd.Parameters.Add("PRECEIPT_NBR", OracleDbType.Int32).Value = receiptno;
        cmd.Parameters.Add("T_CURSOR", OracleDbType.RefCursor).Direction = ParameterDirection.Output;

        da.SelectCommand = cmd;
        DataTable dt = new DataTable();
        da.Fill(dt);
        return dt;
    }
}
32
hyperkittie

J'ai maintenant les étapes nécessaires pour appeler la procédure depuis C #

   //GIVE PROCEDURE NAME
   cmd = new OracleCommand("PROCEDURE_NAME", con);
   cmd.CommandType = CommandType.StoredProcedure;

   //ASSIGN PARAMETERS TO BE PASSED
   cmd.Parameters.Add("PARAM1",OracleDbType.Varchar2).Value = VAL1;
   cmd.Parameters.Add("PARAM2",OracleDbType.Varchar2).Value = VAL2;

   //THIS PARAMETER MAY BE USED TO RETURN RESULT OF PROCEDURE CALL
   cmd.Parameters.Add("vSUCCESS", OracleDbType.Varchar2, 1);
   cmd.Parameters["vSUCCESS"].Direction = ParameterDirection.Output;

   //USE THIS PARAMETER CASE CURSOR IS RETURNED FROM PROCEDURE
   cmd.Parameters.Add("vCHASSIS_RESULT",OracleDbType.RefCursor,ParameterDirection.InputOutput); 

   //CALL PROCEDURE
   con.Open();
   OracleDataAdapter da = new OracleDataAdapter(cmd);
   cmd.ExecuteNonQuery();

   //RETURN VALUE
   if (cmd.Parameters["vSUCCESS"].Value.ToString().Equals("T"))
   {
      //YOUR CODE
   }
   //OR
   //IN CASE CURSOR IS TO BE USED, STORE IT IN DATATABLE
   con.Open();
   OracleDataAdapter da = new OracleDataAdapter(cmd);
   da.Fill(dt);

J'espère que cela t'aides

17
Rohan

C'est fondamentalement le même mécanisme que pour une commande sans requête avec:

  • command.CommandText = le nom de la procédure stockée
  • command.CommandType = CommandType.StoredProcedure
  • Autant d'appels à command.Parameters.Add que le nombre de paramètres requis par le sp
  • command.ExecuteNonQuery

Il existe de nombreux exemples, le premier retourné par Google est celui-ci

Il y a aussi un petit piège dans lequel vous pourriez tomber, si votre SP est une fonction, votre paramètre de valeur de retour doit être le premier dans la collection de paramètres

5
vc 74

Ce code fonctionne bien pour moi en appelant la procédure stockée Oracle

Ajoutez des références en cliquant avec le bouton droit sur le nom de votre projet dans l'Explorateur de solutions> Ajouter une référence> .Net puis Ajouter des espaces de noms.

using System.Data.OracleClient;
using System.Data;

puis collez ce code dans le gestionnaire d'événements

        string str = "User ID=username;Password=password;Data Source=Test";
        OracleConnection conn = new OracleConnection(str);
        OracleCommand cmd = new OracleCommand("stored_procedure_name", conn);
        cmd.CommandType = CommandType.StoredProcedure;
        --Ad parameter list--
        cmd.Parameters.Add("parameter_name", "varchar2").Value = value;
        ....
        conn.Open();
        cmd.ExecuteNonQuery();

Et c'est fait ... Joyeux codage avec C #

4
Abdul

La connexion à Oracle est moche. Voici un code plus propre avec une instruction using. De nombreux autres exemples n'appellent pas les méthodes IDisposable sur les objets qu'ils créent.

using (OracleConnection connection = new OracleConnection("ConnectionString"))
    using (OracleCommand command = new OracleCommand("ProcName", connection))             
    {
          command.CommandType = CommandType.StoredProcedure;
          command.Parameters.Add("ParameterName", OracleDbType.Varchar2).Value = "Your Data Here";
          command.Parameters.Add("SomeOutVar", OracleDbType.Varchar2, 120);
          command.Parameters["return_out"].Direction = ParameterDirection.Output;
          command.Parameters.Add("SomeOutVar1", OracleDbType.Varchar2, 120);
          command.Parameters["return_out2"].Direction = ParameterDirection.Output;
          connection.Open();
          command.ExecuteNonQuery();
          string SomeOutVar = command.Parameters["SomeOutVar"].Value.ToString();
          string SomeOutVar1 = command.Parameters["SomeOutVar1"].Value.ToString();
    }
3
Robert Stokes

Dans .Net à travers la version 4, cela peut être fait de la même manière que pour les processus stockés SQL Server, mais notez que vous avez besoin:

using System.Data.OracleClient;

Il y a certaines exigences système ici que vous devez vérifier sont OK dans votre scénario.

Microsoft est déconseille cet espace de noms à partir de .Net 4 donc des fournisseurs tiers seront nécessaires à l'avenir. Dans cet esprit, il vaut mieux utiliser Oracle Data Provider for .Net (ODP.NET) à partir de Word go - cela a des optimisations qui ne sont pas dans les classes Microsoft. Il existe d'autres options tierces, mais Oracle a tout intérêt à garder les développeurs .Net à bord, donc les leurs devraient être bons.

2
Steve Townsend

Au lieu de

cmd = new OracleCommand("ProcName", con);
cmd.CommandType = CommandType.StoredProcedure;
cmd.Parameters.Add("ParName", OracleDbType.Varchar2, ParameterDirection.Input).Value = "foo";

Vous pouvez également utiliser cette syntaxe:

cmd = new OracleCommand("BEGIN ProcName(:p0); END;", con);
cmd.CommandType = CommandType.Text;
cmd.Parameters.Add("ParName", OracleDbType.Varchar2, ParameterDirection.Input).Value = "foo";

Notez que si vous définissez cmd.BindByName = False (qui est la valeur par défaut) alors vous devez ajouter les paramètres dans le même ordre qu'ils sont écrits dans votre chaîne de commande, les noms réels ne sont pas pertinents. Pour cmd.BindByName = True les noms des paramètres doivent correspondre, l'ordre n'a pas d'importance.

Dans le cas d'un appel de fonction, la chaîne de commande serait la suivante:

cmd = new OracleCommand("BEGIN :ret := ProcName(:ParName); END;", con);
cmd.CommandType = CommandType.Text;
cmd.Parameters.Add("ret", OracleDbType.RefCursor, ParameterDirection.ReturnValue);    
cmd.Parameters.Add("ParName", OracleDbType.Varchar2, ParameterDirection.Input).Value = "foo";
// cmd.ExecuteNonQuery(); is not needed, otherwise the function is executed twice!
var da = new OracleDataAdapter(cmd);
da.Fill(dt);
1
Wernfried Domscheit