我自己用的ORACLEHELPER.cs文件，比较全，好用

最新推荐文章于 2023-05-04 11:20:52 发布
最新推荐文章于 2023-05-04 11:20:52 发布
阅读量1.1w 收藏 5
点赞数
分类专栏： Oracle相关 文章标签： parameters dataset exception string cmd object
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xjzdr/article/details/6454357
版权

using System;
using System.Collections;
using System.Collections.Specialized;
using System.Data;
using System.Data.OracleClient;
using System.Configuration;

namespace GJSH.DBUtility
{
 /// <summary>
 /// Copyright (C) 2004-2008 LiTianPing
 /// 数据访问基础类(基于Oracle)
 /// 可以用户可以修改满足自己项目的需要。
 /// </summary>
 public abstract class DbHelperOra
 {
        //数据库连接字符串(web.config来配置)，可以动态更改connectionString支持多数据库.  
        public static string connectionString = PubConstant.ConnectionString;    
  public DbHelperOra()
  {   
  }
        #region 公用方法
       
        public static int GetMaxID(string FieldName, string TableName)
        {
            string strsql = "select max(" + FieldName + ")+1 from " + TableName;
            object obj = DbHelperOra.GetSingle(strsql);
            if (obj == null)
            {
                return 1;
            }
            else
            {
                return int.Parse(obj.ToString());
            }
        }

      

        public static bool Exists(string strSql, params OracleParameter[] cmdParms)
        {
            object obj = DbHelperOra.GetSingle(strSql, cmdParms);
            int cmdresult;
            if ((Object.Equals(obj, null)) || (Object.Equals(obj, System.DBNull.Value)))
            {
                cmdresult = 0;
            }
            else
            {
                cmdresult = int.Parse(obj.ToString());
            }
            if (cmdresult == 0)
            {
                return false;
            }
            else
            {
                return true;
            }
        }
        #endregion

  #region  执行简单SQL语句

        public static bool Exists(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 false;
      }
      else
      {
       return true;
      }    
     }
     catch(System.Data.OracleClient.OracleException e)
     {      
      connection.Close();
      throw new Exception(e.Message);
     }
                    finally
                    {
                        cmd.Dispose();
                        connection.Close();
                    }
    }
   }
        }
  /// <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);
     }
                    finally
                    {
                        cmd.Dispose();
                        connection.Close();
                    }
    }    
   }
  }
  
  /// <summary>
  /// 执行多条SQL语句，实现数据库事务。
  /// </summary>
  /// <param name="SQLStringList">多条SQL语句</param>  
  public static bool ExecuteSqlTran(ArrayList SQLStringList)
  {
            bool re = false;
            using (OracleConnection connection = new OracleConnection(connectionString))
   {
                connection.Open();
    OracleCommand cmd = new OracleCommand();
                cmd.Connection = connection;
                OracleTransaction tx = connection.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();
                    re = true;
    }
    catch(System.Data.OracleClient.OracleException E)
    {
                    re = false;
     tx.Rollback();
     throw new Exception(E.Message);
    }
                finally
                {
                    cmd.Dispose();
                    connection.Close();
                }
   }
            return re;

  }
  /// <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);
     }
                    finally
                    {
                        cmd.Dispose();
                        connection.Close();
                    }
    }
   }
  }
  /// <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);
    }
                finally
                {                  
                    connection.Close();
                }
    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);
     }
                    finally
                    {
                        cmd.Dispose();
                        connection.Close();
                    }
    }    
   }
  }
  
   
  /// <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);
     }
                    finally
                    {
                        cmd.Dispose();
                        connection.Close();
                    }
    }
   }
  }
  
  /// <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);
     }
                    finally
                    {
                        cmd.Dispose();
                        connection.Close();
                    }
     return ds;
    }    
   }   
  }


  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 RunProcedureReader(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="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>
        /// 执行存储过程，什么值也不返回
        /// </summary>
        /// <param name="storedProcName"></param>
        /// <param name="parameters"></param>
        public static void RunProcedure(string storedProcName, OracleParameter[] parameters)
        {
           
            using (OracleConnection connection = new OracleConnection(connectionString))
            {

 

                System.Data.OracleClient.OracleCommand cmd = BuildQueryCommand(connection, storedProcName, parameters);
                   
                //    new OracleCommand(storedProcName, connection);
                //cmd.CommandType = CommandType.StoredProcedure;
                //foreach (OracleParameter parameter in parameters)
                //{
                //    cmd.Parameters.Add(parameter);
                //}

                //cmd.Parameters.Add(new OracleParameter("p_userid", OracleType.Int32, 9)).Value = p_userid;
                //cmd.Parameters.Add(new OracleParameter("p_yyyy", OracleType.Int32, 7)).Value = p_yyyy;
                //cmd.Parameters.Add(new OracleParameter("p_mm", OracleType.Int32, 9)).Value = p_mm;

 

 

                try
                {
                    if (connection.State != ConnectionState.Open)
                    {

                        connection.Open();
                    }

                    cmd.ExecuteNonQuery();

                }
                catch (Exception ex)
                {
                    ex.Message.ToString();
                    throw new Exception(ex.Message);
                   // Console.WriteLine(ex.Message.ToString());
                }
                finally
                {
                    connection.Close();

                }
                
            }


        }

      


 
/// <summary>
  /// 执行存储过程,返回数据集
  /// </summary>
  /// <param name="storedProcName">存储过程名</param>
  /// <param name="parameters">存储过程参数</param>
  /// <param name="tableName">DataSet结果中的表名</param>
  /// <returns>DataSet</returns>
        public static DataSet RunProcedureGetDataSet(string storedProcName, OracleParameter[] parameters)
  {
   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, "dt");
    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_rowsAffected(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;
  }
        //private static Hashtable parmCache = Hashtable.Synchronized(new Hashtable());

        //public static OracleParameter[] GetCachedParameters(string cacheKey)
        //{
        //    OracleParameter[] cachedParms = (OracleParameter[])parmCache[cacheKey];
        //    // OracleParameter[] cachedParms = (OracleParameter[])parmCache[cacheKey];

        //    if (cachedParms == null)
        //        return null;


        //    OracleParameter[] clonedParms = new OracleParameter[cachedParms.Length];


        //    for (int i = 0, j = cachedParms.Length; i < j; i++)
        //        clonedParms[i] = (OracleParameter)((ICloneable)cachedParms[i]).Clone();

        //    return clonedParms;
        //}

  #endregion 

 }
}

xjzdr
关注
  • 0
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
C#三层架构的MVC项目源码
11-11
本程序一个基于三层架构的MVC模式应用的完整示例项目源码，基于Asp.net 3.5开发， 结构更简洁，提供更多有效的示例源码参考。 方便用户更好的理解和使用该架构进行开发，配合动软.Net代码生成器，可以使开发效率事半功倍，倍感轻松。 该项目涉及如下几项要点应用： 1) 基于标准的三层结构。 2) 表示层采用MVC模式。 3) 数据的增、删、改、查操作。 4) 列表数据显示及分页处理。 5) Linq的应用等。
OracleHelper.cs源码
Shuttle的技术博客
07-03 3437
 话不多说，直接贴过来，自己收藏，大家要得下！using System;using System.Configuration;using System.Data;using System.Data.OracleClient;using System.Collections;namespace PetShop.DBUtility ...{    /**////     /// A hel
Helper.cs 模板生成帮助类
weixin_30436101的博客
07-05 101
1usingSystem;2usingSystem.Data;3usingSystem.ComponentModel;4usingCodeSmith.Engine;5usingSchemaExplorer;6usingMicrosoft.CSharp;78publicclassHelper:CodeTemplate9{10...
ImageClass
weixin_33753845的博客
10-22 352
using System;using System.Collections;using System.IO;using System.Drawing;using System.Drawing.Imaging;using System.Drawing.Drawing2D; public class ImageClass{ public ImageClass() { } #re...
C# WebSocket(Fleck) 客户端:html Winfrom
熊思雨的博客
10-08 9866
WebSocket 通信协议于2011年被定为标准RFC 6455，并由RFC7936补充规范。WebSocket API也被定为标准。WebSocket使得客户端和服务器之间的数据交换变得更加简单，允许服务端主动向客户端推送数据。在WebSocket API中，浏览器和服务器只需要完成一次握手，两者之间就直接可以创建持久性的连接，并进行双向数据传输。
C#笔记 之 Oracle.ManagedDataAccess包的安装及配置
weixin_50648794的博客
07-29 5703
使用Oracle.ManagedDataAccess完成c#对Oracle数据库的操作
OracleHelper.cs文件
03-07
OracleHelper.cs文件
OracleHelper.cs+System.Data.OracleClient.dll
04-07
在使用"OracleHelper.cs"时，开发者需要引用"System.Data.OracleClient.dll"，以便可以利用其提供的类型和方法。这可以通过在项目中添加引用或者在代码中使用`using System.Data.OracleClient;`来实现。然后，...
C# OracleHelper类, DbHelperOracle.cs.rar
07-31
在提供的压缩包中，除了`DbHelperOracle.cs.cs`文件外，还有`新建 PPTX 演示文稿.pptx`和`新建 XLSX 工作表.xlsx`两个文件，它们可能是关于`OracleHelper`类的演示或说明材料，包含类的使用示例、最佳实践或其他相关...
连接Oracle数据库的OracleHelper.cs
weixin_30653023的博客
07-31 228
using System; using System.Configuration; using System.Data; using System.Data.OracleClient; using System.Collections; namespace DBUtility { /// <summary> /// A helper class...
Oraclehelper.cs
05-28
Oraclehelper.cs,用于Oracle与c#的数据连接
C# OracleHelper类, DbHelperOracle.cs
08-17
C#封装的操作Oracle数据库的帮助类，DbHelperOracle.cs
MysqlHelper.cs
06-22
MysqlHelper.cs文件 主要是对数据库的操作封装
ORACLEHELPER.cs文件，比较全，好用《转》
03-04 756
转至：https://blog.csdn.net/xwnxwn/article/details/50386558(略微修改，以便初学者) .Net 分页调用存储过程，可参考：https://blog.csdn.net/wysdong/article/details/88105313 //在oracle 安装目录...\product\11.2.0\dbhome_1\ODP.NET\bin\2...
C# 连接 Oracle 数据库
Roki_Zhang的博客
03-28 3693
C# 连接 Oracle 数据库 C# 连接数据库 C# 数据库连接 Oracle.DataAccess.dll 连接数据库
c oracle类库,C#操作oracle通用类OracleHelper.cs下载与使用
weixin_32786041的博客
04-06 459
来源：cms对于使用C#的程序员来说，sqlhelper.cs文件并不陌生，这是一个基于.NET Framework的数据库操作组件，它主要是用来操作sqlserver数据库的封装类。但是要操作oracle这个封装类需要进行修改，25亿CMS的程序员根据sqlhelper.cs修改成了可以操作oracle通用类OracleHelper.cs。C#操作oracle通用类OracleHelper.cs...
JAVA下的OracleHelper包
福娃儿 的专栏
10-27 4762
 JAVA下的OracleHelper包在.NET平台下有个被使用的很广泛的SqlHelper工具类，是微软专门针对SQL Server数据库所编写的数据访问层中间件，很好的对ADO.NET进行了封装。在实际应用中，由于项目需求，当时我曾对SqlHelper进行了若干改造，变成了能够针对Oracle数据库进行访问的OracleHelper工具类，这些都是在.NET平台下使用C#实现的。
oracle 关于数据库编码字符集和乱码问题（终）
ye43191的博客
05-04 2788
修改环境变量NLS_LANG值为 select userenv('language') from dual 的查询结果。（但是我测试了一下，在比较高版本的数据库连接软件中，客户端编码默认就是和服务器端一致的，在环境变量修改并没有起作用）可以看到，数据库服务器端的编码字符集是ZHS16GBK（简体中文 16位GBK编码）如果客户端（PLSQL，Dbeaver等数据库连接软件）查询乱码，这个参数是数据库建立的时候设置的，一般不会轻易改变。这两个参数的具体作用喔不太明白。
C#连接字符集为Ascii的Oracle
笨笨鸟吃柠檬的专栏
04-11 469
C#连接字符集为Ascii的Oracle
sqlitehelper.cs
最新发布
08-05
1. 连接数据库：SQLiteHelper.cs提供了连接数据库的方法，通过传入数据库文件路径等参数，可以建立与SQLite数据库的连接。 2. 创建表格：通过SQLiteHelper.cs，可以执行SQL语句来创建数据库表格。可以根据实际需求...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

xjzdr

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值