我们专注攀枝花网站设计 攀枝花网站制作 攀枝花网站建设
成都网站建设公司服务热线:400-028-6601

网站建设知识

十年网站开发经验 + 多家企业客户 + 靠谱的建站团队

量身定制 + 运营维护+专业推广+无忧售后,网站问题一站解决

三层结构视频中的DBHelper.cs

 

成都创新互联专注于汇川网站建设服务及定制,我们拥有丰富的企业做网站经验。 热诚为您提供汇川营销型网站建设,汇川网站制作、汇川网页设计、汇川网站官网定制、成都小程序开发服务,打造汇川网络公司原创品牌,更为您提供汇川网站排名全网营销落地服务。

 lyqConnectionString  要换

  1. using System; 
  2. using System.Collections.Generic; 
  3. using System.Text; 
  4. using System.Configuration; 
  5. using System.Data.Common; 
  6. using System.Data; 
  7. using System.Data.SqlClient; 
  8.  
  9.  
  10. namespace LyqDAL 
  11.     ///  
  12.     /// 自定义访问通用类 
  13.     ///  
  14.     public class DBHelper 
  15.     { 
  16.         private static readonly string connectionString = ConfigurationManager.ConnectionStrings["lyqConnectionString"].ConnectionString.ToString(); 
  17.         private static readonly string providerName = "System.Data.SqlClient"; 
  18.         private static SqlConnection connection = new SqlConnection(connectionString); 
  19.         ///  
  20.         /// GetConnection 用于获取连接数据库的 connection 对象 
  21.         ///  
  22.         ///  
  23.         private static DbConnection GetConnection() 
  24.         { 
  25.             DbProviderFactory _factory = DbProviderFactories.GetFactory(providerName); 
  26.             DbConnection connection = _factory.CreateConnection(); 
  27.             connection.ConnectionString = connectionString; 
  28.             return connection; 
  29.         } 
  30.         ///  
  31.         /// GetCommand 获取命令参数 command 对象 
  32.         ///  
  33.         ///  
  34.         ///  
  35.         ///  
  36.         ///  
  37.         private static DbCommand GetCommand(string commandText, CommandType commandType, DbConnection connection) 
  38.         { 
  39.             DbCommand command = connection.CreateCommand(); 
  40.             command.CommandText = commandText; 
  41.             command.CommandType = commandType; 
  42.             return command; 
  43.  
  44.  
  45.         } 
  46.         ///  
  47.         /// 读取数据 
  48.         ///  
  49.         /// sql语句 
  50.         /// 参数列表 
  51.         /// DataTable 
  52.         public static DataTable GetDataTable(string sql, params SqlParameter[] param) 
  53.         { 
  54.             DataTable dt = new DataTable(); 
  55.             using (SqlConnection conn = new SqlConnection(connectionString)) 
  56.             { 
  57.                 SqlDataAdapter da = new SqlDataAdapter(sql, conn); 
  58.                 if (param != null) 
  59.                     da.SelectCommand.Parameters.AddRange(param); 
  60.                 da.Fill(dt); 
  61.             } 
  62.             return dt; 
  63.         } 
  64.         ///  
  65.         /// GetCommand 方法重载 
  66.         ///  
  67.         /// sql语句 
  68.         ///  
  69.         ///  
  70.         private static DbCommand GetCommand(string commandText, DbConnection connection) 
  71.         { 
  72.             DbCommand command = connection.CreateCommand(); 
  73.             command.CommandText = commandText; 
  74.             command.CommandType = CommandType.Text; 
  75.             return command; 
  76.         } 
  77.         public DbCommand GetSqlStringCommond(string sqlQuery) 
  78.         { 
  79.             DbCommand dbCommand = connection.CreateCommand(); 
  80.             dbCommand.CommandText = sqlQuery; 
  81.             dbCommand.CommandType = CommandType.Text; 
  82.             return dbCommand; 
  83.         } 
  84.         ///  
  85.         /// GetParameter 用于为命令设置参数 
  86.         ///  
  87.         ///  
  88.         ///  
  89.         ///  
  90.         ///  
  91.         private static DbParameter GetParameter(string paramName, object paramValue, DbCommand command) 
  92.         { 
  93.             DbParameter parameter = command.CreateParameter(); 
  94.             parameter.ParameterName = paramName; 
  95.             parameter.Value = paramValue; 
  96.             return parameter; 
  97.         } 
  98.         ///  
  99.         /// 执行无参的存储过程 
  100.         ///  
  101.         /// 存储过程名 
  102.         ///  
  103.         public static int ExecuteNonQueryProc(string sqlCommand) 
  104.         { 
  105.             int result = 0; 
  106.             using (DbConnection connection = GetConnection()) 
  107.             { 
  108.                 DbCommand command = GetCommand(sqlCommand, CommandType.StoredProcedure, connection); 
  109.                 connection.Open(); 
  110.                 result = command.ExecuteNonQuery(); 
  111.                 command.Parameters.Clear(); 
  112.             } 
  113.             return result; 
  114.         } 
  115.         ///  
  116.         /// 执行无返回值有参数的存储过程 
  117.         ///  
  118.         /// 存储过程名 
  119.         /// 参数 
  120.         ///  
  121.         public static int ExecuteNonQueryProc(string sqlCommand, Dictionary parameters) 
  122.         { 
  123.             int result = 0; 
  124.             using (DbConnection connection = GetConnection()) 
  125.             { 
  126.                 DbCommand command = GetCommand(sqlCommand, CommandType.StoredProcedure, connection); 
  127.                 foreach (KeyValuePair p in parameters) 
  128.                 { 
  129.                     command.Parameters.Add(GetParameter(p.Key, p.Value, command)); 
  130.                 } 
  131.                 connection.Open(); 
  132.                 result = command.ExecuteNonQuery(); 
  133.                 command.Parameters.Clear(); 
  134.             } 
  135.             return result; 
  136.         } 
  137.  
  138.         ///  
  139.         /// 执行无返回值的sql语句 
  140.         ///  
  141.         ///  
  142.         ///  
  143.         public static int ExecuteNonQuery(string sqlCommand) 
  144.         { 
  145.             int result = 0; 
  146.             using (DbConnection connection = GetConnection()) 
  147.             { 
  148.                 DbCommand command = GetCommand(sqlCommand, CommandType.Text, connection); 
  149.                 connection.Open(); 
  150.                 result = command.ExecuteNonQuery(); 
  151.                 command.Parameters.Clear(); 
  152.                 return result; 
  153.             } 
  154.         } 
  155.         ///  
  156.         /// 执行有参数的sql语句 
  157.         ///  
  158.         ///  
  159.         ///  
  160.         ///  
  161.         public static int ExecuteNonQuery(string sqlCommand, Dictionary para) 
  162.         { 
  163.             int result = 0; 
  164.             using (DbConnection connection = GetConnection()) 
  165.             { 
  166.                 DbCommand command = GetCommand(sqlCommand, CommandType.Text, connection); 
  167.                 foreach (KeyValuePair p in para) 
  168.                 { 
  169.                     command.Parameters.Add(GetParameter(p.Key, p.Value, command)); 
  170.                 } 
  171.                 connection.Open(); 
  172.                 result = command.ExecuteNonQuery(); 
  173.                 command.Parameters.Clear(); 
  174.                 return result; 
  175.             } 
  176.         } 
  177.         ///  
  178.         /// 执行有返回值无参数的存储过程 
  179.         ///  
  180.         ///  
  181.         ///  
  182.         public static object ExecuteScalarProc(string cmdText) 
  183.         { 
  184.             using (DbConnection connection = GetConnection()) 
  185.             { 
  186.                 DbCommand command = GetCommand(cmdText, CommandType.StoredProcedure, connection); 
  187.                 connection.Open(); 
  188.                 object val = command.ExecuteScalar(); 
  189.                 command.Parameters.Clear(); 
  190.                 return val; 
  191.             } 
  192.         } 
  193.         ///  
  194.         /// 执行有返回值的有参数的存储过程 
  195.         ///  
  196.         /// 存储过程名 
  197.         /// 参数 
  198.         ///  
  199.         public static object ExecuteScalarProc(string cmdText, Dictionary para) 
  200.         { 
  201.             using (DbConnection connection = GetConnection()) 
  202.             { 
  203.                 DbCommand command = GetCommand(cmdText, CommandType.StoredProcedure, connection); 
  204.                 foreach (KeyValuePair p in para) 
  205.                 { 
  206.                     command.Parameters.Add(GetParameter(p.Key, p.Value, command)); 
  207.                 } 
  208.                 connection.Open(); 
  209.                 object val = command.ExecuteScalar(); 
  210.                 command.Parameters.Clear(); 
  211.                 return val; 
  212.             } 
  213.         } 
  214.         ///  
  215.         /// 执行有返回值的sql语句 
  216.         ///  
  217.         ///  
  218.         ///  
  219.         public static object ExecuteScalar(string cmdText) 
  220.         { 
  221.             using (DbConnection connection = GetConnection()) 
  222.             { 
  223.                 DbCommand command = GetCommand(cmdText, CommandType.Text, connection); 
  224.                 connection.Open(); 
  225.                 object val = command.ExecuteScalar(); 
  226.                 command.Parameters.Clear(); 
  227.                 return val; 
  228.             } 
  229.         } 
  230.         ///  
  231.         /// 执行有返回值有参数的sql语句 
  232.         ///  
  233.         ///  
  234.         ///  
  235.         ///  
  236.         public static object ExecuteScalar(string cmdText, Dictionary para) 
  237.         { 
  238.             using (DbConnection connection = GetConnection()) 
  239.             { 
  240.                 DbCommand command = GetCommand(cmdText, CommandType.Text, connection); 
  241.                 foreach (KeyValuePair p in para) 
  242.                 { 
  243.                     command.Parameters.Add(GetParameter(p.Key, p.Value, command)); 
  244.                 } 
  245.                 connection.Open(); 
  246.                 object val = command.ExecuteScalar(); 
  247.                 command.Parameters.Clear(); 
  248.                 return val; 
  249.             } 
  250.         } 
  251.         ///  
  252.         /// 执行无参数的存储过程,返回DbDataReader对象 
  253.         ///  
  254.         /// 存储过程名 
  255.         ///  
  256.         public static DbDataReader GetReaderProc(string sqlCommand) 
  257.         { 
  258.             try 
  259.             { 
  260.                 DbConnection connection = GetConnection(); 
  261.                 DbCommand command = GetCommand(sqlCommand, CommandType.StoredProcedure, connection); 
  262.                 connection.Open(); 
  263.                 DbDataReader reader = command.ExecuteReader(CommandBehavior.CloseConnection); 
  264.                 return reader; 
  265.             } 
  266.             catch (Exception ex) 
  267.             { 
  268.                 Console.Write("" + ex.Message); 
  269.                 return null; 
  270.             } 
  271.         } 
  272.         ///  
  273.         /// 执行有参数的存储过程,返回DbDataReader对象 
  274.         ///  
  275.         ///  
  276.         ///  
  277.         ///  
  278.         public static DbDataReader GetReaderProc(string sqlCommand, Dictionary parameters) 
  279.         { 
  280.             try 
  281.             { 
  282.                 DbConnection connection = GetConnection(); 
  283.                 DbCommand command = GetCommand(sqlCommand, CommandType.StoredProcedure, connection); 
  284.                 foreach (KeyValuePair p in parameters) 
  285.                 { 
  286.                     command.Parameters.Add(GetParameter(p.Key, p.Value, command)); 
  287.                 } 
  288.                 connection.Open(); 
  289.                 DbDataReader reader = command.ExecuteReader(CommandBehavior.CloseConnection); 
  290.                 command.Parameters.Clear(); 
  291.                 return reader; 
  292.             } 
  293.             catch 
  294.             { 
  295.                 return null; 
  296.             } 
  297.         } 
  298.         #region 
  299.         ///  
  300.         /// 执行无参数的sql语句,返回DbDataReader对象 
  301.         ///  
  302.         ///  
  303.         ///  
  304.         public static DbDataReader GetReader(string sqlCommand) 
  305.         { 
  306.             try 
  307.             { 
  308.                 DbConnection connection = GetConnection(); 
  309.                 DbCommand command = GetCommand(sqlCommand, CommandType.Text, connection); 
  310.                 connection.Open(); 
  311.                 DbDataReader reader = command.ExecuteReader(CommandBehavior.CloseConnection); 
  312.                 command.Parameters.Clear(); 
  313.                 return reader; 
  314.             } 
  315.             catch (Exception ex) 
  316.             { 
  317.                 Console.Write("" + ex.Message); 
  318.                 return null; 
  319.             } 
  320.         } 
  321.         #endregion 
  322.         ///  
  323.         /// 执行有参数的sql语句,返回DbDataReader对象 
  324.         ///  
  325.         ///  
  326.         ///  
  327.         ///  
  328.         public static DbDataReader GetReader(string sqlCommand, Dictionary parameters) 
  329.         { 
  330.             try 
  331.             { 
  332.                 DbConnection connection = GetConnection(); 
  333.                 DbCommand command = GetCommand(sqlCommand, CommandType.Text, connection); 
  334.                 foreach (KeyValuePair p in parameters) 
  335.                 { 
  336.                     command.Parameters.Add(GetParameter(p.Key, p.Value, command)); 
  337.                 } 
  338.                 connection.Open(); 
  339.                 DbDataReader reader = command.ExecuteReader(CommandBehavior.CloseConnection); 
  340.                 command.Parameters.Clear(); 
  341.                 return reader; 
  342.             } 
  343.             catch (Exception ex) 
  344.             { 
  345.                 Console.Write("" + ex.Message); 
  346.                 return null; 
  347.             } 
  348.         } 
  349.          
  350.         ///  
  351.         /// 返回DataTable对象 
  352.         ///  
  353.         ///  
  354.         ///  
  355.         public static DataTable GetDataSet(string safeSql) 
  356.         { 
  357.             /*DbProviderFactory _factory = DbProviderFactories.GetFactory(providerName); 
  358.             DbConnection connection = GetConnection(); 
  359.             connection.Open(); 
  360.             DbDataAdapter da = _factory.CreateDataAdapter(); 
  361.             da.SelectCommand = connection.CreateCommand(); 
  362.             da.SelectCommand.CommandText = safeSql; 
  363.             DataTable dt = new DataTable(); 
  364.             da.Fill(dt); 
  365.             return dt;*/ 
  366.             using (DbConnection connection = GetConnection()) 
  367.             { 
  368.                 DbProviderFactory _factory = DbProviderFactories.GetFactory(providerName); 
  369.                 DbCommand command = GetCommand(safeSql, CommandType.Text, connection); 
  370.                 connection.Open(); 
  371.                 DbDataAdapter da = _factory.CreateDataAdapter(); 
  372.                 da.SelectCommand = command; 
  373.                 DataTable datatable = new DataTable(); 
  374.                 da.Fill(datatable); 
  375.                 return datatable; 
  376.             } 
  377.         } 
  378.     } 

 


分享题目:三层结构视频中的DBHelper.cs
当前网址:http://shouzuofang.com/article/jdijio.html

其他资讯