Arbeiten Sie mit der Oracle-Datenbank in C#
View more Tutorials:
Im Unterlagen leite ich Sie bei der Manipulation mit der Oracle Database aus C# an. Das Ziel fasst um
- Query
- Insert
- Update
- Delete
- Call function, procedure in C#,...
Der Unterlagen benutzt SIMPLEHR, ein Beispiel Database Schema wird in vielen Anleitungen auf o7planning.org benutzt. Sie können das Schema auf Oracle, MySQL oder SQL Server erstellen. Sie können die Anleitung bei... schauen:
Das Projekt CsOracleTutorial erstellen:
Das Projekt wird erstellt
Sie sollen die DLL Bibliothek erklären und brauchen eine UtilityKlasse (DBUtils.cs) zur Verbindung in die Database. Mit der Oracle Database können Sie die Anleitung bei ... sehen:
DBOracleUtils.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Oracle.DataAccess.Client;
namespace Tutorial.SqlConn
{
class DBOracleUtils
{
public static OracleConnection
GetDBConnection(string host, int port, String sid, String user, String password)
{
Console.WriteLine("Getting Connection ...");
// Connection String zur Verbindung mit Oracle.
string connString = "Data Source=(DESCRIPTION =(ADDRESS = (PROTOCOL = TCP)(HOST = "
+ host + ")(PORT = " + port + "))(CONNECT_DATA = (SERVER = DEDICATED)(SERVICE_NAME = "
+ sid + ")));Password=" + password + ";User ID=" + user;
OracleConnection conn = new OracleConnection();
conn.ConnectionString = connString;
return conn;
}
}
}
DBUtils.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Oracle.DataAccess.Client;
namespace Tutorial.SqlConn
{
class DBUtils
{
public static OracleConnection GetDBConnection()
{
string host = "192.168.0.102";
int port = 1521;
string sid = "db12c";
string user = "simplehr";
string password = "12345";
return DBOracleUtils.GetDBConnection(host, port, sid, user, password);
}
}
}
Um im C# mit der Database Oracle,z.B query, insert, update, delete zu manipulieren, benutzen Sie ein Objekt OracleCommand. OracleCommand ist eine Klasse, die aus DbCommand verlängert wird. Falls Sie query, insert,update oder delete in MySQL brauchen, sollen Sie MySqlCommand benutzen oder mit SQL Server brauchen Sie SqlCommand. Leider ist es Ihnen sehr schwierig, eine Source Code für die unterschiedlichen Database zu benutzen
Sie können das Objekt OracleCommand zur Manipulation mit Oracle Database erstellen:
OracleConnection conn = DBUtils.GetDBConnection(); // Way 1: // Create a Command from Connection. OracleCommand cmd = conn.CreateCommand(); // Set Command Text cmd.CommandText = sql; // Way 2: // Create new Command OracleCommand cmd = new OracleCommand(sql); // Set connection for Command. cmd.Connection = conn; // Way 3: // Create new Command with parameters: Command text & connection OracleCommand cmd = new OracleCommand(sql, conn);
Zum Beispiel: die Daten durch C# abfragen
QueryDataExample.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Tutorial.SqlConn;
using System.Data.Common;
using Oracle.DataAccess.Client;
namespace CsOracleTutorial
{
class QueryDataExample
{
static void Main(string[] args)
{
// Ein Objekt Connection entnehmen um in DB zu verbinden.
OracleConnection conn = DBUtils.GetDBConnection();
conn.Open();
try
{
QueryEmployee(conn);
}
catch (Exception e)
{
Console.WriteLine("Error: " + e);
Console.WriteLine(e.StackTrace);
}
finally
{
conn.Close();
conn.Dispose();
}
Console.Read();
}
private static void QueryEmployee(OracleConnection conn)
{
string sql = "Select Emp_Id, Emp_No, Emp_Name, Mng_Id from Employee";
// Die Erstellung eines Objekt Command.
OracleCommand cmd = new OracleCommand();
// Die Verbindung von Command mit Connection.
cmd.Connection = conn;
cmd.CommandText = sql;
using (DbDataReader reader = cmd.ExecuteReader())
{
if (reader.HasRows)
{
while (reader.Read())
{
// Index der Spalte Emp_ID im Befehl SQL.
int empIdIndex = reader.GetOrdinal("Emp_Id"); // 0
long empId = Convert.ToInt64(reader.GetValue(0));
// Index der Spalte Emp_No ist 1.
string empNo = reader.GetString(1);
int empNameIndex = reader.GetOrdinal("Emp_Name");// 2
string empName = reader.GetString(empNameIndex);
int mngIdIndex = reader.GetOrdinal("Mng_Id");
long? mngId = null;
if (!reader.IsDBNull(mngIdIndex))
{
mngId = Convert.ToInt64(reader.GetValue(mngIdIndex));
}
Console.WriteLine("--------------------");
Console.WriteLine("empIdIndex:" + empIdIndex);
Console.WriteLine("EmpId:" + empId);
Console.WriteLine("EmpNo:" + empNo);
Console.WriteLine("EmpName:" + empName);
Console.WriteLine("MngId:" + mngId);
}
}
}
}
}
}
Das Beispiel durchführen
Achtung: der Befehl using ist um sicherzustellen, dass das Objekt zerstört wird (dispose) nachdem es aus der Region ausgestritten hat// Den Schlüsselwort 'using' für das Objekt mit dem Typ IDispose benutzen. // (ist das Objekt von Interface IDispose). using (DbDataReader reader = cmd.ExecuteReader()) { // Code ... } // Äquivalent mit dem illustrierten Aufschreiben: DbDataReader reader = cmd.ExecuteReader(); try { // Code ... } finally { // Die Methode aufrufen um das Objekt zu zerstören // Die Ressourcen freien reader.Dispose(); }
Zum Beispiel: einen Rekord in die Tabelle Salary_Grade insert.
InsertDataExample.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Tutorial.SqlConn;
using System.Data.Common;
using System.Data;
using Oracle.DataAccess.Client;
namespace CsOracleTutorial
{
class InsertDataExample
{
static void Main(string[] args)
{
OracleConnection connection = DBUtils.GetDBConnection();
connection.Open();
try
{
// Der Befehl Insert.
string sql = "Insert into Salary_Grade (Grade, High_Salary, Low_Salary) "
+ " values (@grade, @highSalary, @lowSalary) ";
OracleCommand cmd = connection.CreateCommand();
cmd.CommandText = sql;
// Ein Objekt Parameter erstellen.
OracleParameter gradeParam = new OracleParameter("@grade",SqlDbType.Int);
gradeParam.Value = 3;
cmd.Parameters.Add(gradeParam);
// Den Parameter @highSalary (kürzer schreiben) einfügen.
OracleParameter highSalaryParam = cmd.Parameters.Add("@highSalary", SqlDbType.Float);
highSalaryParam.Value = 20000;
// Den Parameter @lowSalary (mehr kürzer).
cmd.Parameters.Add("@lowSalary", SqlDbType.Float ).Value = 10000;
// Die Durchführung vom Command (für delete, insert, update).
int rowCount = cmd.ExecuteNonQuery();
Console.WriteLine("Row Count affected = " + rowCount);
}
catch (Exception e)
{
Console.WriteLine("Error: " + e);
Console.WriteLine(e.StackTrace);
}
finally
{
connection.Close();
connection.Dispose();
connection = null;
}
Console.Read();
}
}
}
Das Beispiel durchführen
Zum Beispiel: Das Update im C#.
UpdateExample.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Oracle.DataAccess.Client;
using Tutorial.SqlConn;
using System.Data;
namespace CsOracleTutorial
{
class UpdateExample
{
static void Main(string[] args)
{
OracleConnection conn = DBUtils.GetDBConnection();
conn.Open();
try
{
string sql = "Update Employee set Salary = @salary where Emp_Id = @empId";
OracleCommand cmd = new OracleCommand();
cmd.Connection = conn;
cmd.CommandText = sql;
cmd.Parameters.Add("@salary", SqlDbType.Float).Value = 850;
cmd.Parameters.Add("@empId", SqlDbType.Decimal).Value = 7369;
// Die Durchführung vom Command (für delete, insert, update).
int rowCount = cmd.ExecuteNonQuery();
Console.WriteLine("Row Count affected = " + rowCount);
}
catch (Exception e)
{
Console.WriteLine("Error: " + e);
Console.WriteLine(e.StackTrace);
}
finally
{
conn.Close();
conn.Dispose();
conn = null;
}
Console.Read();
}
}
}
Das Beispiel durchführen
Zum Beispiel: C# benutzen um die Daten in Database zu löschen
DeleteExample.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Oracle.DataAccess.Client;
using Tutorial.SqlConn;
using System.Data;
namespace CsOracleTutorial
{
class DeleteExample
{
static void Main(string[] args)
{
// Die Verbindung entnehmen um die DB zu verbinden.
OracleConnection conn = DBUtils.GetDBConnection();
conn.Open();
try
{
string sql = "Delete from Salary_Grade where Grade = @grade ";
// Das Objekt Command erstellen
OracleCommand cmd = new OracleCommand();
// Mit Connection coordinieren
cmd.Connection = conn;
// Command Text.
cmd.CommandText = sql;
cmd.Parameters.Add("@grade", SqlDbType.Int).Value = 3;
// Die Durchführung von Command (für delete,insert, update).
int rowCount = cmd.ExecuteNonQuery();
Console.WriteLine("Row Count affected = " + rowCount);
}
catch (Exception e)
{
Console.WriteLine("Error: " + e);
Console.WriteLine(e.StackTrace);
}
finally
{
conn.Close();
conn.Dispose();
conn = null;
}
Console.Read();
}
}
}
Sie brauchen einen einfachen Verfahren in Oracle zu erstellen und ihn im C# aufzurufen:
Get_Employee_Info
-- This procedure retrieves information of an employee,
-- Input parameter: p_Emp_ID (Integer)
-- There are four output parameters v_Emp_No, v_First_Name, v_Last_Name, v_Hire_Date
Create Or Replace Procedure Get_Employee_Info(p_Emp_Id Integer
,v_Emp_No Out Varchar2
,v_First_Name Out Varchar2
,v_Last_Name Out Varchar2
,v_Hire_Date Out Date) Is
Begin
v_Emp_No := 'E' || p_Emp_Id;
--
v_First_Name := 'Michael';
v_Last_Name := 'Smith';
v_Hire_Date := Sysdate;
End Get_Employee_Info;
/
CallProcedureExample.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Tutorial.SqlConn;
using System.Data;
using Oracle.DataAccess.Client;
using Oracle.DataAccess.Types;
namespace CsOracleTutorial
{
class CallProcedureExample
{
// Get_Employee_Info
// @p_Emp_Id Integer ,
// @v_Emp_No Varchar(50) OUTPUT
// @v_First_Name Varchar(50) OUTPUT
// @v_Last_Name Varchar(50) OUTPUT
// @v_Hire_Date Date OUTPUT
static void Main(string[] args)
{
OracleConnection conn = DBUtils.GetDBConnection();
conn.Open();
try
{
// Die Erstellung eines Objekt Command
// zur Aufruf nach dem Verfahren Get_Employee_Info.
OracleCommand cmd = new OracleCommand("Get_Employee_Info", conn);
// Das Typ vom Command ist StoredProcedure
cmd.CommandType = CommandType.StoredProcedure;
// Den Parameter @p_Emp_Id einfügen und die Wert = 100 für ihn einstellen.
cmd.Parameters.Add("@p_Emp_Id", OracleDbType.Int32).Value =100;
// Den Parameter @v_Emp_No mit dem Typ vom Varchar(20) einfügen.
cmd.Parameters.Add(new OracleParameter("@v_Emp_No", OracleDbType.Varchar2, 20));
cmd.Parameters.Add(new OracleParameter("@v_First_Name", OracleDbType.Varchar2, 50));
cmd.Parameters.Add(new OracleParameter("@v_Last_Name", OracleDbType.Varchar2, 50));
cmd.Parameters.Add(new OracleParameter("@v_Hire_Date", OracleDbType.Date));
// Den Parameter @v_Emp_No als OUTPUT registrieren.
cmd.Parameters["@v_Emp_No"].Direction = ParameterDirection.Output;
cmd.Parameters["@v_First_Name"].Direction = ParameterDirection.Output;
cmd.Parameters["@v_Last_Name"].Direction = ParameterDirection.Output;
cmd.Parameters["@v_Hire_Date"].Direction = ParameterDirection.Output;
// Die Durchführung des Verfahren.
cmd.ExecuteNonQuery();
// Die Output-Wert entnehmen
string empNo = cmd.Parameters["@v_Emp_No"].Value.ToString();
string firstName = cmd.Parameters["@v_First_Name"].Value.ToString();
string lastName = cmd.Parameters["@v_Last_Name"].Value.ToString();
object hireDateObj = cmd.Parameters["@v_Hire_Date"].Value;
Console.WriteLine("hireDateObj type: "+ hireDateObj.GetType().ToString());
OracleDate hireDate = (OracleDate)hireDateObj;
Console.WriteLine("Emp No: " + empNo);
Console.WriteLine("First Name: " + firstName);
Console.WriteLine("Last Name: " + lastName);
Console.WriteLine("Hire Date: " + hireDate);
}
catch (Exception e)
{
Console.WriteLine("Error: " + e);
Console.WriteLine(e.StackTrace);
}
finally
{
conn.Close();
conn.Dispose();
}
Console.Read();
}
}
}
Das Beispiel durchführen
Sie brauchen eine einfache Funktion zu erstellen und sie in C# aufzurufen
Get_Emp_No
CREATE or Replace Function Get_Emp_No (p_Emp_Id Integer) Return Varchar2 As Begin return 'E' || p_Emp_Id; END; /
CallFunctionExample.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Tutorial.SqlConn;
using System.Data;
using Oracle.DataAccess.Client;
using Oracle.DataAccess.Types;
namespace CsOracleTutorial
{
class CallFunctionExample
{
// Function: Get_Emp_No
// Parameter: @p_Emp_Id Integer
static void Main(string[] args)
{
OracleConnection conn = DBUtils.GetDBConnection();
conn.Open();
try
{
// Ein Objekt Command erstellen um die Funktion Get_Emp_No aufzurufen.
OracleCommand cmd = new OracleCommand("Get_Emp_No", conn);
// Das Typ vom Command ist StoredProcedure
cmd.CommandType = CommandType.StoredProcedure;
// ** Achtung: Mit Oracle wird der zurückgegebene Parameter zuerst eingefügt.
// Die Erstellung eines Parameter Varchar2(50)).
OracleParameter resultParam = new OracleParameter("@Result", OracleDbType.Varchar2, 50);
// ReturnValue
resultParam.Direction = ParameterDirection.ReturnValue;
// In die Liste einen Parameter einfügen.
cmd.Parameters.Add(resultParam);
// Den Parameter @p_Emp_Id einfügen und die Wert = 100 einstellen.
cmd.Parameters.Add("@p_Emp_Id", OracleDbType.Int32).Value = 100;
// Die Aufruf auf die Funktion
cmd.ExecuteNonQuery();
string empNo = null;
if (resultParam.Value != DBNull.Value)
{
Console.WriteLine("resultParam.Value: "+ resultParam.Value.GetType().ToString());
OracleString ret = (OracleString) resultParam.Value;
empNo = ret.ToString();
}
Console.WriteLine("Emp No: " + empNo);
}
catch (Exception e)
{
Console.WriteLine("Error: " + e);
Console.WriteLine(e.StackTrace);
}
finally
{
conn.Close();
conn.Dispose();
}
Console.Read();
}
}
}
Das Beispiel durchführen
OracleCommand.ExecuteScalar() ist eine Methode zur Implementierung des SQL Befehl, der die Wert von der ersten Spalte in der ersten Zeile rückgibt
-- The following statement returns only one value. Select count(*) from Employee; -- Or Select Max(e.Salary) From Employee e;
Zum Beispiel
ExecuteScalarExample.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Oracle.DataAccess.Client;
using System.Data;
using Tutorial.SqlConn;
namespace CsOracleTutorial
{
class ExecuteScalarExample
{
static void Main(string[] args)
{
OracleConnection conn = DBUtils.GetDBConnection();
conn.Open();
try
{
OracleCommand cmd = new OracleCommand("Select count(*) From Employee", conn);
cmd.CommandType = CommandType.Text;
// Die Methode ExecuteScalar
// gibt die erste Wert der ersten Spalte in der ersten Zeile zurück
object countObj = cmd.ExecuteScalar();
int count = 0;
if (countObj != null)
{
count = Convert.ToInt32(countObj);
}
Console.WriteLine("Emp Count: " + count);
}
catch (Exception e)
{
Console.WriteLine("Error: " + e);
Console.WriteLine(e.StackTrace);
}
finally
{
conn.Close();
conn.Dispose();
}
Console.Read();
}
}
}
Das Beispiel durchführen
