DbHelper and OracleHelper

1 连接Sql Server的ConnectionString:

Data Source=.;Initial Catalog=ViewVideo;User ID=sa;Password=XXXXXX;

2 连接MySql的ConnectionString:

Database=dbname;Data Source=192.168.1.1;Port=3306;User Id=root;Password=****;Charset=utf8;TreatTinyAsBoolean=false;

3 连接Oracle的ConnectionString：

Data Source=(DESCRIPTION =
(ADDRESS_LIST =
(ADDRESS = (PROTOCOL = TCP)(HOST = 192.168.1.117)(PORT = 1521))
)
(CONNECT_DATA =
(SERVER = DEDICATED)
(SERVICE_NAME = orcl.192.168.1.117)
)
);User Id=scott;Password=XXXXXX //不能有';'

 

OracleHelper.cs:

  1 public class OracleHepler
  2     {
  3         //链接字符串
  4         private static readonly string connStr = ConfigurationManager.ConnectionStrings["dbconnStr"].ConnectionString;
  5 
  6         /// <summary>
  7         /// 创建链接
  8         /// </summary>
  9         /// <returns>链接</returns>
 10         public static OracleConnection CreateConnection()
 11         {
 12             OracleConnection conn = new OracleConnection(connStr);
 13             conn.Open();
 14             return conn;
 15         }
 16 
 17         /// <summary>
 18         /// 使用亦有链接的 非查询
 19         /// </summary>
 20         /// <param name="conn">链接</param>
 21         /// <param name="sql">sql文本</param>
 22         /// <param name="parameters">sql参数</param>
 23         /// <returns>受影响行数</returns>
 24         public static int ExecuteNonQuery(OracleConnection conn, string sql, params OracleParameter[] parameters)
 25         {
 26             using (OracleCommand cmd = new OracleCommand(sql, conn))
 27             {
 28                 cmd.Parameters.AddRange(parameters);
 29                 return cmd.ExecuteNonQuery();
 30             }
 31         }
 32 
 33         /// <summary>
 34         /// 自己创建链接的 非查询
 35         /// </summary>
 36         /// <param name="sql">sql文本</param>
 37         /// <param name="parameters">sql参数</param>
 38         /// <returns>受影响行数</returns>
 39         public static int ExecuteNonQuery(string sql, params OracleParameter[] parameters)
 40         {
 41             using (OracleConnection conn = CreateConnection())
 42             {
 43                 return ExecuteNonQuery(conn, sql, parameters);
 44             }
 45         }
 46 
 47         /// <summary>
 48         /// 使用已有链接的 带存储过程的Insert非查询，直接写存储过程参数
 49         /// </summary>
 50         /// <param name="conn">已有链接</param>
 51         /// <param name="proName">存储过程名称</param>
 52         /// <param name="strInsertSQL">执行插入的sql语句，或者其他操作sql语句</param>
 53         /// <param name="seqName">序列的名称</param>
 54         /// <returns>当前序列号，即ID</returns>
 55         public static object ExecuteNonQueryWithProduce(OracleConnection conn, string proName, string strInsertSQL, string seqName)
 56         {
 57             using (OracleCommand cmd = new OracleCommand(proName, conn)) //命令中执行的不在是sql，而是存储过程
 58             {
 59                 try
 60                 {
 61                     cmd.CommandType = CommandType.StoredProcedure; //标记该命令的类型不是sql，而是存储过程
 62                     //存储过程中有参数名称，以及设置对应参数的值
 63                     cmd.Parameters.Add(new OracleParameter("strInsertSQL", OracleDbType.Varchar2) { Value = strInsertSQL }); ////存储过程中的参入参数 strInsertSQL
 64                     cmd.Parameters.Add(new OracleParameter("seqName", OracleDbType.Varchar2) { Value = seqName }); // //存储过程中的传入参数 seqName
 65                     cmd.Parameters.Add(new OracleParameter("ID", OracleDbType.Int32) { Direction = ParameterDirection.Output }); //存储过程中的传出参数ID，只需要声明
 66                     //cmd.Parameters.AddRange(parameters);
 67                     cmd.ExecuteNonQuery();
 68                     string newId = cmd.Parameters["ID"].Value.ToString(); //获得传出参数的ID的值
 69                     return newId;
 70                 }
 71                 catch (Exception ex)
 72                 {
 73                     throw new Exception(ex.ToString());
 74                 }
 75             }
 76         }
 77 
 78         /// <summary>
 79         /// 自己创建链接的 带存储过程的Insert非查询，直接写存储过程参数
 80         /// </summary>
 81         /// <param name="proName">存储过程名称</param>
 82         /// <param name="strInsertSQL">执行插入的sql语句，或者其他操作sql语句</param>
 83         /// <param name="seqName">序列的名称</param>
 84         /// <returns>当前序列号，即ID</returns>
 85         public static object ExecuteNonQueryWithProduce(string proName, string strInsertSQL, string seqName)
 86         {
 87             using (OracleConnection conn = CreateConnection())
 88             {
 89                 return ExecuteNonQueryWithProduce(conn, proName, strInsertSQL, seqName);
 90             }
 91         }
 92 
 93         /// <summary>
 94         /// 使用已有链接的 带存储过程的Insert非查询，传存储过程参数
 95         /// </summary>
 96         /// <param name="conn">已有链接</param>
 97         /// <param name="proName">存储过程名称</param>
 98         /// <param name="parameters">存储过程中的传入、传出参数 数组</param>
 99         /// <returns>当前序列号，即ID</returns>
100         public static object ExecuteNonQueryWithProduce(OracleConnection conn, string proName, params OracleParameter[] parameters)
101         {
102             using (OracleCommand cmd = new OracleCommand(proName, conn)) //命令中执行的不在是sql，而是存储过程
103             {
104                 //try
105                 //{
106                 cmd.CommandType = CommandType.StoredProcedure; //标记该命令的类型不是sql，而是存储过程
107                 ////存储过程中有参数名称，以及设置对应参数的值
108                 //cmd.Parameters.Add(new OracleParameter("strInsertSQL", OracleDbType.Varchar2) { Value = strInsertSQL }); ////存储过程中的参入参数 strInsertSQL
109                 //cmd.Parameters.Add(new OracleParameter("seqName", OracleDbType.Varchar2) { Value = seqName }); // //存储过程中的传入参数 seqName
110                 //cmd.Parameters.Add(new OracleParameter("ID", OracleDbType.Int32) { Direction = ParameterDirection.Output }); //存储过程中的传出参数ID，只需要声明
111                 cmd.Parameters.AddRange(parameters); //参数中包括存储过程的传入传出参数，以及子sql语句中的参数    --------------****-----------------
112                 int i = cmd.ExecuteNonQuery(); //直接返回执行插入之后，存储过程传出的变量值
113                 object newId = cmd.Parameters["ID"].Value; //获得传出参数的ID的值
114                 return newId;
115                 //}
116                 //catch (Exception ex)
117                 //{
118                 //    throw new Exception(ex.ToString());
119                 //}
120             }
121         }
122 
123         /// <summary>
124         /// 自己创建链接的 带存储过程的Insert非查询，传存储过程参数
125         /// </summary>
126         /// <param name="proName">存储过程名称</param>
127         /// <param name="parameters">存储过程中的传入、传出参数 数组</param>
128         /// <returns>当前序列号，即ID</returns>
129         public static object ExecuteNonQueryWithProduce(string proName, params OracleParameter[] parameters)
130         {
131             using (OracleConnection conn = CreateConnection())
132             {
133                 return ExecuteNonQueryWithProduce(conn, proName, parameters);
134             }
135         }
136 
137 
138         /// <summary>
139         /// 使用已有链接的 单查询
140         /// </summary>
141         /// <param name="conn">链接</param>
142         /// <param name="sql">sql文本</param>
143         /// <param name="parameters">sql参数</param>
144         /// <returns>查询到的一条结果</returns>
145         public static object ExecuteScalar(OracleConnection conn, string sql, params OracleParameter[] parameters)
146         {
147             using (OracleCommand cmd = new OracleCommand(sql, conn))
148             {
149                 cmd.Parameters.AddRange(parameters);
150                 return cmd.ExecuteScalar();
151             }
152         }
153 
154         /// <summary>
155         /// 自己创建链接的 单查询
156         /// </summary>
157         /// <param name="sql">sql文本</param>
158         /// <param name="parameters">sql参数</param>
159         /// <returns>查询到的一条结果</returns>
160         public static object ExecuteScalar(string sql, params OracleParameter[] parameters)
161         {
162             using (OracleConnection conn = CreateConnection())
163             {
164                 return ExecuteScalar(conn, sql, parameters);
165             }
166         }
167 
168         /// <summary>
169         /// 使用已有链接的 reader查询
170         /// </summary>
171         /// <param name="conn">链接</param>
172         /// <param name="sql">sql文本</param>
173         /// <param name="parameters">sql参数</param>
174         /// <returns>查询到的结果集table</returns>
175         public static DataTable ExecuteReader(OracleConnection conn, string sql, params OracleParameter[] parameters)
176         {
177             DataTable table = new DataTable();
178             using (OracleCommand cmd = new OracleCommand(sql, conn))
179             {
180                 cmd.Parameters.AddRange(parameters);
181                 using (OracleDataReader reader = cmd.ExecuteReader())
182                 {
183                     table.Load(reader);
184                 }
185             }
186             return table;
187         }
188 
189         /// <summary>
190         /// 自己创建链接的 reader查询
191         /// </summary>
192         /// <param name="sql">sql文本</param>
193         /// <param name="parameters">sql参数</param>
194         /// <returns>查询到的结果集table</returns>
195         public static DataTable ExecuteReader(string sql, params OracleParameter[] parameters)
196         {
197             using (OracleConnection conn = CreateConnection())
198             {
199                 return ExecuteReader(conn, sql, parameters);
200             }
201         }
202 
203         /// <summary>
204         /// 使用已有链接的 stream查询
205         /// </summary>
206         /// <param name="conn">链接</param>
207         /// <param name="sql">sql文本</param>
208         /// <param name="parameters">sql参数</param>
209         /// <returns>查询到的结果流stream</returns>
210         public static System.IO.Stream ExecuteStream(OracleConnection conn, string sql, params OracleParameter[] parameters)
211         {
212             using (OracleCommand cmd = new OracleCommand(sql, conn))
213             {
214                 cmd.Parameters.AddRange(parameters);
215                 using (System.IO.Stream stream = cmd.ExecuteStream())
216                 {
217                     return stream;
218                 }
219             }
220         }
221 
222         /// <summary>
223         /// 自己创建链接的stream查询
224         /// </summary>
225         /// <param name="sql">sql文本</param>
226         /// <param name="parameters">sql参数</param>
227         /// <returns>查询到的结果流stream</returns>
228         public static System.IO.Stream ExecuteStream(string sql, params OracleParameter[] parameters)
229         {
230             using (OracleConnection conn = CreateConnection())
231             {
232                 return ExecuteStream(conn, sql, parameters);
233             }
234         }
235     }

OracleHelper.cs