如何联接oracle数据库

Question

刚刚接触.net，连接sql2005可以用系统提供的数据库控件，再将gridview绑定数据库控件，请问连接oracle应该怎么办！~！

Answer 1

首先配置连接字符串，在Web.config里面。。
 <connectionStrings>
    <add name="connString" connectionString="Data Source=(DESCRIPTION=(ADDRESS=(PROTOCOL=TCP)(HOST=192.168.0.162)(PORT=1521))(CONNECT_DATA=(SERVICE_NAME=ORCL)));User Id=scott;Password=lester;" providerName="System.Data.OracleClient"/>
  </connectionStrings>
接下来给你一个通用的类，连接Oracle的。。
using System;
using System.Collections;
using System.Collections.Specialized;
using System.Data;
using System.Configuration;
using System.Data.OracleClient;
namespace Com2000888.Utility
{
   
    
    /// <summary>
    /// Copyright (C) 2004-2008 LiTianPing 
    /// 数据访问基础类(基于OracleServer)
    /// 用户可以修改满足自己项目的需要。
    /// </summary>
    /// 
    public abstract class DbHelperOracle
    {
        //数据库连接字符串(web.config来配置)
        //<add key="ConnectionString" value="server=127.0.0.1;database=DATABASE;uid=sa;pwd=" />
        public static string connectionString = ConfigurationManager.ConnectionStrings["connString"].ConnectionString;
        public DbHelperOracle()
        {
        }        #region  执行简单Oracle语句        /// <summary>
        /// 执行Oracle语句，返回影响的记录数
        /// </summary>
        /// <param name="OracleString">Oracle语句</param>
        /// <returns>影响的记录数</returns>
        public static int ExecuteOracle(string OracleString)
        {
            using (OracleConnection connection = new OracleConnection(connectionString))
            {
                using (OracleCommand cmd = new OracleCommand(OracleString, connection))
                {
                    try
                    {
                        connection.Open();
                        int rows = cmd.ExecuteNonQuery();
                        return rows;
                    }
                    catch (System.Data.OracleClient.OracleException E)
                    {
                        connection.Close();
                        throw new Exception(E.Message);
                    }
                }
            }
        }        /// <summary>
        /// 执行多条Oracle语句，实现数据库事务。
        /// </summary>
        /// <param name="OracleStringList">多条Oracle语句</param>
        public static void ExecuteOracleTran(ArrayList OracleStringList)
        {
            using (OracleConnection conn = new OracleConnection(connectionString))
            {
                conn.Open();
                OracleCommand cmd = new OracleCommand();
                cmd.Connection = conn;
                OracleTransaction tx = conn.BeginTransaction();
                cmd.Transaction = tx;
                try
                {
                    for (int n = 0; n < OracleStringList.Count; n++)
                    {
                        string strOracle = OracleStringList[n].ToString();
                        if (strOracle.Trim().Length > 1)
                        {
                            cmd.CommandText = strOracle;
                            cmd.ExecuteNonQuery();
                        }
                    }
                    tx.Commit();
                }
                catch (System.Data.OracleClient.OracleException E)
                {
                    tx.Rollback();
                    throw new Exception(E.Message);
                }
            }
        }
        /// <summary>
        /// 执行带一个存储过程参数的的Oracle语句。
        /// </summary>
        /// <param name="OracleString">Oracle语句</param>
        /// <param name="content">参数内容,比如一个字段是格式复杂的文章，有特殊符号，可以通过这个方式添加</param>
        /// <returns>影响的记录数</returns>
        public static int ExecuteOracle(string OracleString, string content)
        {
            using (OracleConnection connection = new OracleConnection(connectionString))
            {
                OracleCommand cmd = new OracleCommand(OracleString, connection);
                System.Data.OracleClient.OracleParameter myParameter = new System.Data.OracleClient.OracleParameter("@content", OracleType.NClob);
                myParameter.Value = content;
                cmd.Parameters.Add(myParameter);
                try
                {
                    connection.Open();
                    int rows = cmd.ExecuteNonQuery();
                    return rows;
                }
                catch (System.Data.OracleClient.OracleException E)
                {
                    throw new Exception(E.Message);
                }
                finally
                {
                    cmd.Dispose();
                    connection.Close();
                }
            }
        }
        /// <summary>
        /// 向数据库里插入图像格式的字段(和上面情况类似的另一种实例)
        /// </summary>
        /// <param name="strOracle">Oracle语句</param>
        /// <param name="fs">图像字节,数据库的字段类型为image的情况</param>
        /// <returns>影响的记录数</returns>
        public static int ExecuteOracleInsertImg(string strOracle, byte[] fs)
        {
            using (OracleConnection connection = new OracleConnection(connectionString))
            {
                OracleCommand cmd = new OracleCommand(strOracle, connection);
                System.Data.OracleClient.OracleParameter myParameter = new System.Data.OracleClient.OracleParameter("@fs", OracleType.Blob);
                myParameter.Value = fs;
                cmd.Parameters.Add(myParameter);
                try
                {
                    connection.Open();
                    int rows = cmd.ExecuteNonQuery();
                    return rows;
                }
                catch (System.Data.OracleClient.OracleException E)
                {
                    throw new Exception(E.Message);
                }
                finally
                {
                    cmd.Dispose();
                    connection.Close();
                }
            }
        }        /// <summary>
        /// 执行一条计算查询结果语句，返回查询结果（object）。
        /// </summary>
        /// <param name="OracleString">计算查询结果语句</param>
        /// <returns>查询结果（object）</returns>
        public static object GetSingle(string OracleString)
        {
            using (OracleConnection connection = new OracleConnection(connectionString))
            {
                using (OracleCommand cmd = new OracleCommand(OracleString, connection))
                {
                    try
                    {
                        connection.Open();
                        object obj = cmd.ExecuteScalar();
                        if ((Object.Equals(obj, null)) || (Object.Equals(obj, System.DBNull.Value)))
                        {
                            return null;
                        }
                        else
                        {
                            return obj;
                        }
                    }
                    catch (System.Data.OracleClient.OracleException e)
                    {
                        connection.Close();
                        throw new Exception(e.Message);
                    }
                }
            }
        }        /// <summary>
        /// 执行一条计算查询结果语句，返回查询结果（object）。
        /// </summary>
        /// <param name="OracleString">计算查询结果语句</param>
        /// <returns>查询结果（object）</returns>
        public static int GetSingleInt(string OracleString)
        {
            object obj = GetSingle(OracleString);
            if ((Object.Equals(obj, null)) || (Object.Equals(obj, System.DBNull.Value)))
            {
                return 0;
            }
            else
            {
                return int.Parse(obj.ToString());
            }        }
        /// <summary>
        /// 执行查询语句，返回OracleDataReader
        /// </summary>
        /// <param name="strOracle">查询语句</param>
        /// <returns>OracleDataReader</returns>
        public static OracleDataReader ExecuteReader(string strOracle)
        {
            OracleConnection connection = new OracleConnection(connectionString);
            OracleCommand cmd = new OracleCommand(strOracle, connection);
            try
            {
                connection.Open();
                OracleDataReader myReader = cmd.ExecuteReader();
                return myReader;
            }
            catch (System.Data.OracleClient.OracleException e)
            {
                throw new Exception(e.Message);
            }        }

Answer 2

  /// <summary>
        /// 执行查询语句，返回DataSet
        /// </summary>
        /// <param name="OracleString">查询语句</param>
        /// <returns>DataSet</returns>
        public static DataSet Query(string OracleString)
        {
            using (OracleConnection connection = new OracleConnection(connectionString))
            {
                DataSet ds = new DataSet();
                try
                {
                    connection.Open();
                    OracleDataAdapter command = new OracleDataAdapter(OracleString, connection);
                    command.Fill(ds, "ds");
                }
                catch (System.Data.OracleClient.OracleException ex)
                {
                    throw new Exception(ex.Message);
                }
                return ds;
            }
        }        /// <summary>
        /// 执行查询语句，返回DataTable
        /// </summary>
        /// <param name="OracleString"></param>
        /// <param name="TableName"></param>
        /// <param name="ct"></param>
        /// <returns></returns>
        public static DataTable GetDataTable(string OracleString, string TableName, CommandType ct)
        {
            using (OracleConnection connection = new OracleConnection(connectionString))
            {
                DataTable dt = new DataTable();
                dt.TableName = TableName;
                try
                {
                    connection.Open();
                    OracleDataAdapter command = new OracleDataAdapter(OracleString, connection);
                    command.SelectCommand.CommandType = ct;
                    command.Fill(dt);
                }
                catch (System.Data.OracleClient.OracleException ex)
                {
                    throw new Exception(ex.Message);
                }
                return dt;
            }
        }        /// <summary>
        /// 执行查询语句，返回DataTable
        /// </summary>
        /// <param name="OracleString"></param>
        /// <param name="TableName"></param>
        /// <param name="ct"></param>
        /// <returns></returns>
        public static DataTable GetDataTable(string OracleString)
        {
            using (OracleConnection connection = new OracleConnection(connectionString))
            {
                DataTable dt = new DataTable();
                try
                {
                    connection.Open();
                    OracleDataAdapter command = new OracleDataAdapter(OracleString, connection);
                    command.Fill(dt);
                }
                catch (System.Data.OracleClient.OracleException ex)
                {
                    throw new Exception(ex.Message);
                }
                return dt;
            }
        }        /// <summary>
        /// 执行查询语句，返回DataTable
        /// </summary>
        /// <param name="OracleString"></param>
        /// <param name="TableName"></param>
        /// <param name="ct"></param>
        /// <returns></returns>
        //public static DataTable GetDataTable(string OracleString, ObjectContext ObjContext)
        //{        //    Jeez.Common.Base.EncryptTripleDes encry = new Jeez.Common.Base.EncryptTripleDes();
        //    DbHelperOracle.connectionString = (((string)encry.Decrypt(ObjContext.ConnectionString)).Split(Jeez.Common.Constants.JeezSplitChar1))[0];
        //    using (OracleConnection connection = new OracleConnection(connectionString))
        //    {
        //        DataTable dt = new DataTable();
        //        try
        //        {
        //            connection.Open();
        //            OracleDataAdapter command = new OracleDataAdapter(OracleString, connection);
        //            command.Fill(dt);
        //        }
        //        catch (System.Data.OracleClient.OracleException ex)
        //        {
        //            throw new Exception(ex.Message);
        //        }
        //        return dt;
        //    }
        //}        #endregion        #region 执行带参数的Oracle语句        /// <summary>
        /// 执行Oracle语句，返回影响的记录数
        /// </summary>
        /// <param name="OracleString">Oracle语句</param>
        /// <returns>影响的记录数</returns>
        public static int ExecuteOracle(string OracleString, CommandType ct, params OracleParameter[] cmdParms)
        {
            using (OracleConnection connection = new OracleConnection(connectionString))
            {
                using (OracleCommand cmd = new OracleCommand())
                {
                    cmd.CommandTimeout = 60;
                    try
                    {
                        PrepareCommand(cmd, connection, ct, null, OracleString, cmdParms);
                        int rows = cmd.ExecuteNonQuery();
                        cmd.Parameters.Clear();
                        return rows;
                    }
                    catch (System.Data.OracleClient.OracleException E)
                    {
                        throw new Exception(E.Message);
                    }
                }
            }
        }        /// <summary>
        ///  完成where子语句功能，该子语句是1＝1开头的东西。。
        /// </summary>
        /// <param name="OracleString">Oracle语句</param>
        /// <param name="Condition">Oracle条件,如name='罗军',不需要and修饰</param>
        /// <returns>返回不包括where的where子句</returns>
        public static string EntireOracleWhere(string OracleString, string Condition)
        {
            if (Condition == "")
            {
                return OracleString;
            }            if (OracleString.Contains("1=1"))
            {
                return OracleString + " and " + Condition;
            }
            if (OracleString.Trim().StartsWith("and"))
            {
                return " 1=1 " + OracleString + " and " + Condition;
            }
            if (OracleString == "")
            {
                return " 1=1 and " + Condition;
            }
            else return "";
        }        /// <summary>
        /// 执行多条Oracle语句，实现数据库事务。
        /// </summary>
        /// <param name="OracleStringList">Oracle语句的哈希表（key为Oracle语句，value是该语句的OracleParameter[]）</param>
        public static void ExecuteOracleTran(Hashtable OracleStringList)
        {
            using (OracleConnection conn = new OracleConnection(connectionString))
            {
                conn.Open();
                using (OracleTransaction trans = conn.BeginTransaction())
                {
                    OracleCommand cmd = new OracleCommand();
                    try
                    {
                        //循环
                        foreach (DictionaryEntry myDE in OracleStringList)
                        {
                            string cmdText = myDE.Key.ToString();
                            OracleParameter[] cmdParms = (OracleParameter[])myDE.Value;
                            PrepareCommand(cmd, conn, CommandType.Text, trans, cmdText, cmdParms);
                            int val = cmd.ExecuteNonQuery();
                            cmd.Parameters.Clear();                            trans.Commit();
                        }
                    }
                    catch
                    {
                        trans.Rollback();
                        throw;
                    }
                }
            }
        }

Answer 3

顶LS！其实百度下很多的！http://topic.csdn.net/u/20090815/23/9169d6d6-51a0-4341-9a38-fbb67a4e8d74.html

Answer 4

恩， 很多的！ 用动软代码生成器 也会跟你生成Oracel的dbhlper类！

Answer 5

什么时候能够回到我的。net世界。唉

Answer 6

using System.Data.OracleClient;
using(OracleConnection conn = new OracleConnection("data source=<服务名>;user id=<用户名>;password=<密码>"))
{
 conn.Open();
}
看petshop有oracle操作