关于.net中连接linux系统下的oracle数据库

时间：2021-11-11 13:12:34

1 首先可以自己写一个关于操作oracle数据库的类，可以这样写：

public abstract class DbHelperOra
 {
        //数据库连接字符串(web.config来配置)，可以动态更改connectionString支持多数据库.  
        public static string connectionString = ConfigurationManager.ConnectionStrings["oracleCont"].ConnectionString;   
  public DbHelperOra()
  {   
  }
  
  #region  执行简单SQL语句

  /// <summary>
  /// 执行SQL语句，返回影响的记录数
  /// </summary>
  /// <param name="SQLString">SQL语句</param>
  /// <returns>影响的记录数</returns>
  public static int ExecuteSql(string SQLString)
  {
   using (OracleConnection connection = new OracleConnection(connectionString))
   {    
    using (OracleCommand cmd = new OracleCommand(SQLString,connection))
    {
     try
     {  
      connection.Open();
      int rows=cmd.ExecuteNonQuery();
      return rows;
     }
     catch(System.Data.OracleClient.OracleException E)
     {     
      connection.Close();
      throw new Exception(E.Message);
     }
    }    
   }
  }
  
  /// <summary>
  /// 执行多条SQL语句，实现数据库事务。
  /// </summary>
  /// <param name="SQLStringList">多条SQL语句</param>  
  public static void ExecuteSqlTran(ArrayList SQLStringList)
  {
   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<SQLStringList.Count;n++)
     {
      string strsql=SQLStringList[n].ToString();
      if (strsql.Trim().Length>1)
      {
       cmd.CommandText=strsql;
       cmd.ExecuteNonQuery();
      }
     }          
     tx.Commit();     
    }
    catch(System.Data.OracleClient.OracleException E)
    {  
     tx.Rollback();
     throw new Exception(E.Message);
    }
   }
  }
  /// <summary>
  /// 执行带一个存储过程参数的的SQL语句。
  /// </summary>
  /// <param name="SQLString">SQL语句</param>
  /// <param name="content">参数内容,比如一个字段是格式复杂的文章，有特殊符号，可以通过这个方式添加</param>
  /// <returns>影响的记录数</returns>
  public static int ExecuteSql(string SQLString,string content)
  {    
   using (OracleConnection connection = new OracleConnection(connectionString))
   {
    OracleCommand cmd = new OracleCommand(SQLString,connection);
                System.Data.OracleClient.OracleParameter myParameter = new System.Data.OracleClient.OracleParameter("@content", OracleType.NVarChar);
    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="strSQL">SQL语句</param>
  /// <param name="fs">图像字节,数据库的字段类型为image的情况</param>
  /// <returns>影响的记录数</returns>
  public static int ExecuteSqlInsertImg(string strSQL,byte[] fs)
  {  
   using (OracleConnection connection = new OracleConnection(connectionString))
   {
    OracleCommand cmd = new OracleCommand(strSQL,connection);
                System.Data.OracleClient.OracleParameter myParameter = new System.Data.OracleClient.OracleParameter("@fs", OracleType.LongRaw);
    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="SQLString">计算查询结果语句</param>
  /// <returns>查询结果（object）</returns>
  public static object GetSingle(string SQLString)
  {
   using (OracleConnection connection = new OracleConnection(connectionString))
   {
    using(OracleCommand cmd = new OracleCommand(SQLString,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>
        /// 执行查询语句，返回OracleDataReader ( 注意：调用该方法后，一定要对SqlDataReader进行Close )
  /// </summary>
  /// <param name="strSQL">查询语句</param>
  /// <returns>OracleDataReader</returns>
  public static OracleDataReader ExecuteReader(string strSQL)
  {
   OracleConnection connection = new OracleConnection(connectionString);   
   OracleCommand cmd = new OracleCommand(strSQL,connection);    
   try
   {
    connection.Open();
                OracleDataReader myReader = cmd.ExecuteReader(CommandBehavior.CloseConnection);
    return myReader;
   }
   catch(System.Data.OracleClient.OracleException e)
   {        
    throw new Exception(e.Message);
   }   
   
  }  
  /// <summary>
  /// 执行查询语句，返回DataSet
  /// </summary>
  /// <param name="SQLString">查询语句</param>
  /// <returns>DataSet</returns>
  public static DataSet Query(string SQLString)
  {
   using (OracleConnection connection = new OracleConnection(connectionString))
   {
    DataSet ds = new DataSet();
    try
    {
     connection.Open();
     OracleDataAdapter command = new OracleDataAdapter(SQLString,connection);
     command.Fill(ds,"ds");
    }
    catch(System.Data.OracleClient.OracleException ex)
    {    
     throw new Exception(ex.Message);
    }   
    return ds;
   }   
  }

 


  #endregion

  #region 执行带参数的SQL语句

  /// <summary>
  /// 执行SQL语句，返回影响的记录数
  /// </summary>
  /// <param name="SQLString">SQL语句</param>
  /// <returns>影响的记录数</returns>
  public static int ExecuteSql(string SQLString,params OracleParameter[] cmdParms)
  {
   using (OracleConnection connection = new OracleConnection(connectionString))
   {    
    using (OracleCommand cmd = new OracleCommand())
    {
     try
     {  
      PrepareCommand(cmd, connection, null,SQLString, cmdParms);
      int rows=cmd.ExecuteNonQuery();
      cmd.Parameters.Clear();
      return rows;
     }
     catch(System.Data.OracleClient.OracleException E)
     {    
      throw new Exception(E.Message);
     }
    }    
   }
  }
  
   
  /// <summary>
  /// 执行多条SQL语句，实现数据库事务。
  /// </summary>
  /// <param name="SQLStringList">SQL语句的哈希表（key为sql语句，value是该语句的OracleParameter[]）</param>
  public static void ExecuteSqlTran(Hashtable SQLStringList)
  {   
   using (OracleConnection conn = new OracleConnection(connectionString))
   {
    conn.Open();
    using (OracleTransaction trans = conn.BeginTransaction())
    {
     OracleCommand cmd = new OracleCommand();
     try
     {
      //循环
      foreach (DictionaryEntry myDE in SQLStringList)
      { 
       string  cmdText=myDE.Key.ToString();
       OracleParameter[] cmdParms=(OracleParameter[])myDE.Value;
       PrepareCommand(cmd,conn,trans,cmdText, cmdParms);
       int val = cmd.ExecuteNonQuery();
       cmd.Parameters.Clear();

       trans.Commit();
      }     
     }
     catch
     {
      trans.Rollback();
      throw;
     }
    }    
   }
  }
 
    
  /// <summary>
  /// 执行一条计算查询结果语句，返回查询结果（object）。
  /// </summary>
  /// <param name="SQLString">计算查询结果语句</param>
  /// <returns>查询结果（object）</returns>
  public static object GetSingle(string SQLString,params OracleParameter[] cmdParms)
  {
   using (OracleConnection connection = new OracleConnection(connectionString))
   {
    using (OracleCommand cmd = new OracleCommand())
    {
     try
     {
      PrepareCommand(cmd, connection, null,SQLString, cmdParms);
      object obj = cmd.ExecuteScalar();
      cmd.Parameters.Clear();
      if((Object.Equals(obj,null))||(Object.Equals(obj,System.DBNull.Value)))
      {     
       return null;
      }
      else
      {
       return obj;
      }    
     }
     catch(System.Data.OracleClient.OracleException e)
     {    
      throw new Exception(e.Message);
     }     
    }
   }
  }
  
  /// <summary>
        /// 执行查询语句，返回OracleDataReader ( 注意：调用该方法后，一定要对SqlDataReader进行Close )
  /// </summary>
  /// <param name="strSQL">查询语句</param>
  /// <returns>OracleDataReader</returns>
  public static OracleDataReader ExecuteReader(string SQLString,params OracleParameter[] cmdParms)
  {  
   OracleConnection connection = new OracleConnection(connectionString);
   OracleCommand cmd = new OracleCommand();    
   try
   {
    PrepareCommand(cmd, connection, null,SQLString, cmdParms);
                OracleDataReader myReader = cmd.ExecuteReader(CommandBehavior.CloseConnection);
    cmd.Parameters.Clear();
    return myReader;
   }
   catch(System.Data.OracleClient.OracleException e)
   {        
    throw new Exception(e.Message);
   }     
   
  }  
  
  /// <summary>
  /// 执行查询语句，返回DataSet
  /// </summary>
  /// <param name="SQLString">查询语句</param>
  /// <returns>DataSet</returns>
  public static DataSet Query(string SQLString,params OracleParameter[] cmdParms)
  {
   using (OracleConnection connection = new OracleConnection(connectionString))
   {
    OracleCommand cmd = new OracleCommand();
    PrepareCommand(cmd, connection, null,SQLString, cmdParms);
    using( OracleDataAdapter da = new OracleDataAdapter(cmd) )
    {
     DataSet ds = new DataSet(); 
     try
     {            
      da.Fill(ds,"ds");
      cmd.Parameters.Clear();
     }
     catch(System.Data.OracleClient.OracleException ex)
     {    
      throw new Exception(ex.Message);
     }   
     return ds;
    }    
   }   
  }

        public static DataSet GetStrSql(string strSql)
        {
            using (OracleConnection connection = new OracleConnection(connectionString))
            {
                OracleCommand cmd = new OracleCommand();
                using (OracleDataAdapter da = new OracleDataAdapter(cmd))
                {
                    DataSet dsInfo = new DataSet();
                    try
                    {
                       
                        da.Fill(dsInfo, "dsInfo");
                        cmd.Parameters.Clear();
                    }
                    catch (System.Data.OracleClient.OracleException ex)
                    {
                        throw new Exception(ex.Message);
                    }
                    return dsInfo;
                }
            }
       
        }


  private static void PrepareCommand(OracleCommand cmd,OracleConnection conn,OracleTransaction trans, string cmdText, OracleParameter[] cmdParms)
  {
   if (conn.State != ConnectionState.Open)
    conn.Open();
   cmd.Connection = conn;
   cmd.CommandText = cmdText;
   if (trans != null)
    cmd.Transaction = trans;
   cmd.CommandType = CommandType.Text;//cmdType;
   if (cmdParms != null)
   {
    foreach (OracleParameter parm in cmdParms)
     cmd.Parameters.Add(parm);
   }
  }

  #endregion

  #region 存储过程操作

  /// <summary>
        /// 执行存储过程 返回SqlDataReader ( 注意：调用该方法后，一定要对SqlDataReader进行Close )
  /// </summary>
  /// <param name="storedProcName">存储过程名</param>
  /// <param name="parameters">存储过程参数</param>
  /// <returns>OracleDataReader</returns>
  public static OracleDataReader RunProcedure(string storedProcName, IDataParameter[] parameters )
  {
   OracleConnection connection = new OracleConnection(connectionString);
   OracleDataReader returnReader;
   connection.Open();
   OracleCommand command = BuildQueryCommand( connection,storedProcName, parameters );
   command.CommandType = CommandType.StoredProcedure;
            returnReader = command.ExecuteReader(CommandBehavior.CloseConnection);    
   return returnReader;   
  }
  
  
  /// <summary>
  /// 执行存储过程
  /// </summary>
  /// <param name="storedProcName">存储过程名</param>
  /// <param name="parameters">存储过程参数</param>
  /// <param name="tableName">DataSet结果中的表名</param>
  /// <returns>DataSet</returns>
  public static DataSet RunProcedure(string storedProcName, IDataParameter[] parameters, string tableName )
  {
   using (OracleConnection connection = new OracleConnection(connectionString))
   {
    DataSet dataSet = new DataSet();
    connection.Open();
    OracleDataAdapter sqlDA = new OracleDataAdapter();
    sqlDA.SelectCommand = BuildQueryCommand(connection, storedProcName, parameters );
    sqlDA.Fill( dataSet, tableName );
    connection.Close();
    return dataSet;
   }
  }

  
  /// <summary>
  /// 构建 OracleCommand 对象(用来返回一个结果集，而不是一个整数值)
  /// </summary>
  /// <param name="connection">数据库连接</param>
  /// <param name="storedProcName">存储过程名</param>
  /// <param name="parameters">存储过程参数</param>
  /// <returns>OracleCommand</returns>
  private static OracleCommand BuildQueryCommand(OracleConnection connection,string storedProcName, IDataParameter[] parameters)
  {   
   OracleCommand command = new OracleCommand( storedProcName, connection );
   command.CommandType = CommandType.StoredProcedure;
   foreach (OracleParameter parameter in parameters)
   {
    command.Parameters.Add( parameter );
   }
   return command;
  }
  
  /// <summary>
  /// 执行存储过程，返回影响的行数  
  /// </summary>
  /// <param name="storedProcName">存储过程名</param>
  /// <param name="parameters">存储过程参数</param>
  /// <param name="rowsAffected">影响的行数</param>
  /// <returns></returns>
  public static int RunProcedure(string storedProcName, IDataParameter[] parameters, out int rowsAffected )
  {
   using (OracleConnection connection = new OracleConnection(connectionString))
   {
    int result;
    connection.Open();
    OracleCommand command = BuildIntCommand(connection, storedProcName, parameters);
    rowsAffected = command.ExecuteNonQuery();
    result = (int)command.Parameters["ReturnValue"].Value;
              
    //Connection.Close();
    return result;
   }
  }
  
  /// <summary>
  /// 创建 OracleCommand 对象实例(用来返回一个整数值)
  /// </summary>
  /// <param name="storedProcName">存储过程名</param>
  /// <param name="parameters">存储过程参数</param>
  /// <returns>OracleCommand 对象实例</returns>
  private static OracleCommand BuildIntCommand(OracleConnection connection,string storedProcName, IDataParameter[] parameters)
  {
   OracleCommand command = BuildQueryCommand(connection,storedProcName, parameters );
            command.Parameters.Add(new OracleParameter("ReturnValue", OracleType.Int32,4,ParameterDirection.ReturnValue,
    false,0,0,string.Empty,DataRowVersion.Default,null));
   return command;
  }
  #endregion 

 }

2 在web.config 中写连接字符串：

<add name="oracleCont"  connectionString="Data Source=(DESCRIPTION=(ADDRESS=(PROTOCOL=TCP)(HOST=*.*.*.*)(PORT=1521))(CONNECT_DATA=(SERVICE_NAME=*)));User Id=*;Password=*" providerName="System.Data.OracleClient"/>

HOST是远程服务器ip,SERVICE_NAME是oracle数据库名称，

Oracle tns配置的6种常见错误解决问题
经过长时间学习Oracle，你可能会遇到Oracle tns配置问题，这里将介绍Oracle tns配置问题的解决方法。最近忙着安装Oracle数据库，本来挺简单的，可老是出现问题，最后自己在网上整理了一些tns错误解决方法，希望对初学者有益。

常见问题:

1、ORA-12541:tns:没有监听器：
显而易见，服务器端的监听器没有启动，另外检查客户端IP地址或端口填写是否正确。启动监听器：
$lsnrctlstart或C:\lsnrctlstart。

2、ORA-12500:tns:监听程序无法启动专用服务器进程：
对于Windows而言，没有启动Oracle实例服务。启动实例服务：C:\oradim–startup-sidmyOracle。

3、ORA-12535:tns:操作超时：
出现这个问题的原因很多，但主要跟网络有关。解决这个问题，首先检查客户端与服务端的网络是否畅通，如果网络连通，则检查客户端与服务器的的防火墙(包括系统自带的和杀毒软件的防火墙)是否阻挡了连接。

4、ORA-12154:tns:无法处理服务名：或者:无法解析指定的连接标识符检查输入的服务名与配置的服务名是否一致。另外注意生成的本地服务名文件(Windows下如D:\Oracle\ora92\network\admin\tnsnames.ora，
Linux/Unix下$Oracle_HOME/network/admin/tnsnames.ora)里每项服务的首服务名称前不能有空格。

5、ORA-12514:tns:监听进程不能解析在连接描述符中给出的SERVICE_NAME打开NetManager，选中服务名称，检查服务标识栏里的服务名输入是否正确。该服务名必须与服务器端监听器配置的全局数据库名一致。

6、Windows下启动监听服务提示找不到路径：
用命令或在服务窗口中启动监听提示找不到路径，或监听服务启动异常。打开注册表，进入HKEY_LOCAL_MACHINE/SYSTEM/Current
ControlSet/Services/OracleOraHome92tnsListener项，查看ImagePath字符串项是否存在，如果没有，设定值为d:\Oracle\product\10.2.0
\db_1\BIN\tnsLSNR.不同的安装路径设定值做相应的更改。这种方法同样适用于Oracle实例服务，同上，找到如同
HKEY_LOCAL_MACHINE/SYSTEM/CurrentControlSet/Services/OracleServiceMYOracle项，查看ImagePath字符串项是否存在，如果没有，则新建，设定值为d:\Oracle\product\10.2.0\db_1\bin\Oracle.EXECOGNOS，以上介绍Oracle tns配置的6种常见错误解决问题 。

 

 

标签：

相关文章