自己琢磨出来的数据库访问底层类

最新推荐文章于 2018-11-08 14:30:57 发布
最新推荐文章于 2018-11-08 14:30:57 发布
阅读量147 收藏
点赞数
文章标签： 数据库
原文链接：http://www.cnblogs.com/steven_jiangxf/archive/2010/04/19/dataaccesslayer.html
版权

为了让数据访问更加简单，我给数据库访问抽象了一下，

下面是我的数据访问底层的架构图：

 

ExpandedBlockStart.gif 代码
     ///   <summary>
     ///  数据库操作基类
     ///   </summary>
     public   class  BaseHelper < T >  : IDisposable
         where  T : AbsConnString,  new ()
    {
         // Database connection strings
         private   static  T _connString  =   new  T();

         private  IDbConnection _dbconnection;
         private  IDbCommand _dbcommand;
         ///   <summary>
         ///  实现构造函数
         ///   </summary>
         ///   <param name="conn"> 必须是集成自AbsConnString的类 </param>
         public  BaseHelper()
        {
            _dbconnection  =  CreateConnection();
            _dbcommand  =  CreateCommand(_dbconnection);
        }
         private   static  IDbCommand CreateCommand(IDbConnection conn)
        {
            IDbCommand cmd  =  conn.CreateCommand();
            cmd.CommandTimeout  =  _connString.TimeOut;
             return  cmd;
        }
         private   static  IDbConnection CreateConnection()
        {
            IDbConnection conn  =   new  SqlConnection();
            conn.ConnectionString  =  _connString.ConnectionString;
             return  conn;
        }

         public   int  ExecuteNonQuery( string  cmdText,  params  IDbDataParameter[] commandParameters)
        {
             return  ExecuteNonQuery(CommandType.Text, cmdText, commandParameters);
        }
         public   int  ExecuteNonQuery(CommandType cmdType,  string  cmdText,  params  IDbDataParameter[] commandParameters)
        {
            PrepareCommand(_dbcommand,  null , cmdType, cmdText, commandParameters);
             int  val  =  _dbcommand.ExecuteNonQuery();
            _dbcommand.Parameters.Clear();
             return  val;
        }

         public  IDataReader ExecuteReader( string  cmdText,  params  IDbDataParameter[] commandParameters)
        {
             return  ExecuteReader(CommandType.Text, cmdText, commandParameters);
        }
         public  IDataReader ExecuteReader(CommandType cmdType,  string  cmdText,  params  IDbDataParameter[] commandParameters)
        {
            PrepareCommand(_dbcommand,  null , cmdType, cmdText, commandParameters);
            IDataReader rdr  =  _dbcommand.ExecuteReader(CommandBehavior.CloseConnection);
            _dbcommand.Parameters.Clear();
             return  rdr;
        }
         public   object  ExecuteScalar( string  cmdText,  params  IDbDataParameter[] commandParameters)
        {
             return  ExecuteScalar(CommandType.Text, cmdText, commandParameters);
        }

         public   object  ExecuteScalar(CommandType cmdType,  string  cmdText,  params  IDbDataParameter[] commandParameters)
        {
            PrepareCommand(_dbcommand,  null , cmdType, cmdText, commandParameters);
             object  obj  =  _dbcommand.ExecuteScalar();
            _dbcommand.Parameters.Clear();
             return  obj;
        }
         public  DataTable ExecuteTable(CommandType cmdType,  string  cmdText,  params  IDbDataParameter[] commandParameters)
        {
            PrepareCommand(_dbcommand,  null , cmdType, cmdText, commandParameters);
             using  (DataSet st  =   new  DataSet())
            {
                IDbDataAdapter ap  =   new  SqlDataAdapter();
                ap.SelectCommand  =  _dbcommand;
                ap.Fill(st);
                _dbcommand.Parameters.Clear();
                 return  st.Tables[ 0 ];
            }
        }
         public  DataTable ExecuteTable( string  cmdText,  params  IDbDataParameter[] commandParameters)
        {
             return  ExecuteTable(CommandType.Text, cmdText, commandParameters);
        }
         public   object  ExecuteScalarByTrans(CommandType cmdType,  string  cmdText,  params  IDbDataParameter[] commandParameters)
        {
             using  (IDbTransaction trans  =  _dbconnection.BeginTransaction())
            {
                PrepareCommand(_dbcommand, trans, cmdType, cmdText, commandParameters);
                 try
                {
                     object  val  =  _dbcommand.ExecuteScalar();

                     if  (val  !=   null )
                    {
                        trans.Commit();
                        _dbcommand.Parameters.Clear();
                         return  val;
                    }
                     else
                    {
                        trans.Rollback();
                    }
                }
                 catch
                {
                    trans.Rollback();
                }
                 return   null ;
            }
        }

         public   int  ExecuteNonQueryByTrans(CommandType cmdType,  string  cmdText,  params  IDbDataParameter[] commandParameters)
        {
            PrepareCommand(_dbcommand,  null , cmdType, cmdText, commandParameters);
             using  (IDbTransaction trans  =  _dbconnection.BeginTransaction())
            {
                 try
                {
                     int  val  =  _dbcommand.ExecuteNonQuery();
                     if  (val  >   0 )
                    {
                        trans.Commit();
                        _dbcommand.Parameters.Clear();
                         return  val;
                    }
                     else
                    {
                        trans.Rollback();
                    }
                }
                 catch
                {
                    trans.Rollback();
                }
                 return   - 1 ;
            }
        }

         public  IDbDataParameter CreateParameter( string  parameterName)
        {
             return  StaticCreateParameter(parameterName);
        }
         public  IDbDataParameter CreateParameter( string  parameterName,  object  value)
        {
             return  StaticCreateParameter(parameterName, value);
        }
         public  IDbDataParameter CreateParameter( string  parameterName, SqlDbType dbType,  int  size,  object  value)
        {
             return  StaticCreateParameter(parameterName, dbType, size, value);
        }
         public  IDbDataParameter CreateParameter( string  parameterName, SqlDbType dbType,  object  value)
        {
             return  StaticCreateParameter(parameterName, dbType, value);
        }
         public   void  SetParameter(IDataParameter parameter,  object  value)
        {
            StaticSetParameter(parameter, value);
        }
         #region  Static Method

         ///   <summary>
         ///  Execute a SqlCommand (that returns no resultset) against the database specified in the connection string 
         ///  using the provided parameters.
         ///   </summary>
         ///   <remarks>
         ///  e.g.:  
         ///   int result = ExecuteNonQuery(connString, CommandType.StoredProcedure, "PublishOrders", new SqlParameter("@prodid", 24));
         ///   </remarks>
         ///   <param name="connectionString"> a valid connection string for a SqlConnection </param>
         ///   <param name="commandType"> the CommandType (stored procedure, text, etc.) </param>
         ///   <param name="commandText"> the stored procedure name or T-SQL command </param>
         ///   <param name="commandParameters"> an array of SqlParamters used to execute the command </param>
         ///   <returns> an int representing the number of rows affected by the command </returns>
         public   static   int  StaticExecuteNonQuery(CommandType cmdType,  string  cmdText,  params  IDbDataParameter[] commandParameters)
        {
             using  (IDbConnection conn  =  CreateConnection())
            {
                 using  (IDbCommand cmd  =  CreateCommand(conn))
                {
                    PrepareCommand(cmd,  null , cmdType, cmdText, commandParameters);
                     int  val  =  cmd.ExecuteNonQuery();
                    cmd.Parameters.Clear();
                     return  val;
                }
            }
        }
         ///   <summary>
         ///  
         ///   </summary>
         ///   <param name="cmdType"></param>
         ///   <param name="cmdText"></param>
         ///   <param name="commandParameters"></param>
         ///   <returns></returns>
         public   static  DataTable StaticExecuteTable(CommandType cmdType,  string  cmdText,  params  IDbDataParameter[] commandParameters)
        {
             using  (IDbConnection connection  =  CreateConnection())
            {
                 using  (IDbCommand cmd  =  CreateCommand(connection))
                {
                    PrepareCommand(cmd,  null , cmdType, cmdText, commandParameters);
                     using  (DataSet st  =   new  DataSet())
                    {
                        IDbDataAdapter ap  =   new  SqlDataAdapter();
                        ap.SelectCommand  =  cmd;
                        ap.Fill(st);
                        cmd.Parameters.Clear();
                         return  st.Tables[ 0 ];
                    }
                }
            }
        }
         ///   <summary>
         ///  Execute a SqlCommand that returns the first column of the first record against the database specified in the connection string 
         ///  using the provided parameters.
         ///   </summary>
         ///   <remarks>
         ///  e.g.:  
         ///   Object obj = ExecuteScalar(connString, CommandType.StoredProcedure, "PublishOrders", new SqlParameter("@prodid", 24));
         ///   </remarks>
         ///   <param name="connectionString"> a valid connection string for a SqlConnection </param>
         ///   <param name="commandType"> the CommandType (stored procedure, text, etc.) </param>
         ///   <param name="commandText"> the stored procedure name or T-SQL command </param>
         ///   <param name="commandParameters"> an array of SqlParamters used to execute the command </param>
         ///   <returns> An object that should be converted to the expected type using Convert.To{Type} </returns>
         public   static   object  StaticExecuteScalar(CommandType cmdType,  string  cmdText,  params  IDbDataParameter[] commandParameters)
        {
             using  (IDbConnection connection  =  CreateConnection())
            {
                 using  (IDbCommand cmd  =  CreateCommand(connection))
                {
                    PrepareCommand(cmd,  null , cmdType, cmdText, commandParameters);
                     object  val  =  cmd.ExecuteScalar();
                    cmd.Parameters.Clear();
                     return  val;
                }
            }
        }
         public   static  IDbDataParameter StaticCreateParameter( string  parameterName)
        {
            SqlParameter p  =   new  SqlParameter();
            p.ParameterName  =  parameterName;
             return  p;
        }

         public   static  IDbDataParameter StaticCreateParameter( string  parameterName,  object  value)
        {
             if  (value  ==   null )
            {
                value  =  ( object )DBNull.Value;
            }
            SqlParameter p  =   new  SqlParameter(parameterName, value);
             return  p;
        }

         public   static  IDbDataParameter StaticCreateParameter( string  parameterName, SqlDbType dbType,  int  size,  object  value)
        {
             if  (value  ==   null )
            {
                value  =  ( object )DBNull.Value;
            }
            SqlParameter p  =   new  SqlParameter(parameterName, dbType, size);
            p.Value  =  value;
             return  p;
        }

         public   static  IDbDataParameter StaticCreateParameter( string  parameterName, SqlDbType dbType,  object  value)
        {
             if  (value  ==   null )
            {
                value  =  ( object )DBNull.Value;
            }

            SqlParameter p  =   new  SqlParameter(parameterName, dbType);
            p.Value  =  value;
             return  p;
        }

         public   static   void  StaticSetParameter(IDataParameter parameter,  object  value)
        {
             if  (value  ==   null )
            {
                value  =  ( object )DBNull.Value;
            }
            parameter.Value  =  value;
        }

         ///   <summary>
         ///   Prepare a command for execution
         ///   </summary>
         ///   <param name="cmd"> IDbCommand Object </param>
         ///   <param name="trans"> IDbTransaction Object </param>
         ///   <param name="cmdType"> Cmd type e.g. stored procedure or text </param>
         ///   <param name="cmdText"> Command text, e.g. Select * from Products </param>
         ///   <param name="cmdParms"> IDbDataParameters to use in the command </param>
         private   static   void  PrepareCommand(IDbCommand cmd, IDbTransaction trans, CommandType cmdType,  string  cmdText, IDbDataParameter[] cmdParms)
        {
             if  (cmd.Connection.State  !=  ConnectionState.Open)
            {
                cmd.Connection.Open();
            }
            cmd.CommandText  =  cmdText;
             if  (trans  !=   null )
            {
                cmd.Transaction  =  trans;
            }
            cmd.CommandType  =  cmdType;

             if  (cmdParms  !=   null   &&  cmdParms.Length  >   0 )
            {
                 foreach  (IDbDataParameter parm  in  cmdParms)
                {
                    cmd.Parameters.Add(parm);
                }
            }
        }
         #endregion

         #region  IDisposable Members
         protected   void  Dispose()
        {
             // 托管代码
             if  (_dbcommand  !=   null )
            {
                _dbcommand.Dispose();
                _dbcommand  =   null ;
            }
             // 非托管代码
             if  (_dbconnection  !=   null )
            {
                _dbconnection.Dispose();
                _dbconnection  =   null ;
            }
        }
         #endregion
    }

 

 

ExpandedBlockStart.gif 代码
     ///   <summary>
     ///  数据库连接抽象类类
     ///   </summary>
     public   abstract   class  AbsConnString
    {
         ///   <summary>
         ///  超时默认时间为30
         ///   </summary>
         private   int  _timeOut  =   30 ;
         ///   <summary>
         ///  超时时间
         ///   </summary>
         public   virtual   int  TimeOut
        {
             get
            {
                 return  _timeOut;
            }
        }
         ///   <summary>
         ///  数据库的连接字符串
         ///   </summary>
         public   abstract   string  ConnectionString {  get ; }
    }

 

 

ExpandedBlockStart.gif 代码
     public   class  OOSConnString : Base.AbsConnString
    {
         public  OOSConnString()
        {

        }
         private   string  _connectionstring;
         public   override   string  ConnectionString
        {
             get
            {
                 if  ( string .IsNullOrEmpty(_connectionstring))
                {
                    _connectionstring  =  System.Configuration.ConfigurationManager.ConnectionStrings[ " NewMaximOOSConnString " ].ConnectionString;
                }
                 return  _connectionstring;
            }
        }
    }

 

     ///   <summary>
     ///  对象型数据库操作类
     ///   </summary>
     public   class  OOSHelper : Base.BaseHelper < OOSConnString >
    {
    }

有了以上这个架构，我们数据库访问将更加方便，它支持静态调用和类的调用。

下面是采用类的调用方式（主要是应用于负责的访问方式，new时必须要用using 这样可以避免连接不能及时关闭的问题）

ExpandedBlockStart.gif 代码

using  System;
 using  System.Data;
 using  System.Text;
 using  System.Collections.Generic;

 using  Maxim.Entity;
 using  Maxim.DataAccess.Access;


 namespace  Maxim.DataAccess.Generated._Base
{
     ///   <summary>
     ///  Class:A_CustomerBase
     ///  Author:Steven
     ///  Create:2010-4-12 14:52:13
     ///   </summary>
     public   abstract   class  A_CustomerBase
    {        
         ///   <summary>
         ///  
         ///   </summary>
         public  A_CustomerBase()
        {
        }
         public  List < A_CustomerInfo >  GetA_CustomerInfoALL()
        {
            List < A_CustomerInfo >  list  =   new  List < A_CustomerInfo > ();
             string  sql = " SELECT * FROM [A_Customer] " ;
             using (OOSHelper dbhelper = new  OOSHelper())
            {
               using (IDataReader reader = dbhelper.ExecuteReader(sql))
              {
                 while (reader.Read())
                {
                   list.Add(A_CustomerInfo.SetValue(reader));
                }
              }
            }
             return  list;
        }
        
         public  A_CustomerInfo GetA_CustomerInfo( string  _eRPNO)
        {
            A_CustomerInfo aCustomerinfo  =   null ;
            StringBuilder sql =   new  StringBuilder();
            sql.Append( " SELECT * FROM " );
            sql.Append( "  [A_Customer] " );
            sql.Append( "  WHERE " );
            sql.Append( "  [ERPNO]=@ERPNO " );
             using (OOSHelper dbhelper = new  OOSHelper())
            {
              IDbDataParameter[] p_Parms  =   new  IDbDataParameter[]{
                dbhelper.CreateParameter( " @ERPNO " ,_eRPNO)
              };
               using (IDataReader reader = dbhelper.ExecuteReader(sql.ToString(),p_Parms))
              {
                 if (reader.Read())
                {
                    aCustomerinfo  =  A_CustomerInfo.SetValue(reader);
                }
              }
            }
             return  aCustomerinfo;
        }
         public   bool  Insert(A_CustomerInfo aCustomerinfo)
        {
            
            StringBuilder sql = new  StringBuilder();
            sql.Append( " INSERT INTO " );
            sql.Append( "  [A_Customer]( " );            
            sql.Append( " [ERPNO], " );
            sql.Append( " [CorpName], " );
            sql.Append( " [CorpAddress], " );
            sql.Append( " [CorpPhone], " );
            sql.Append( " [CorpContract], " );
            sql.Append( " [CorpTax], " );
            sql.Append( " [CorpBank], " );
            sql.Append( " [CorpBankNO], " );
            sql.Append( " [PayType], " );
            sql.Append( " [CustomerType], " );
            sql.Append( " [ERPContractType], " );
            sql.Append( " [IsDirectShip], " );
            sql.Append( " [IsEnabled], " );
            sql.Append( " [UpdateTime], " );
            sql.Append( " [CurrencyID], " );
            sql.Append( " [NeedProformaInvoice] " );
            sql.Append( " ) VALUES( " );
            sql.Append( " @ERPNO, " );
            sql.Append( " @CorpName, " );
            sql.Append( " @CorpAddress, " );
            sql.Append( " @CorpPhone, " );
            sql.Append( " @CorpContract, " );
            sql.Append( " @CorpTax, " );
            sql.Append( " @CorpBank, " );
            sql.Append( " @CorpBankNO, " );
            sql.Append( " @PayType, " );
            sql.Append( " @CustomerType, " );
            sql.Append( " @ERPContractType, " );
            sql.Append( " @IsDirectShip, " );
            sql.Append( " @IsEnabled, " );
            sql.Append( " @UpdateTime, " );
            sql.Append( " @CurrencyID, " );
            sql.Append( " @NeedProformaInvoice " );
            sql.Append( " ) " );
            
             using (OOSHelper dbhelper = new  OOSHelper())
            {
                IDbDataParameter[] p_Parms = new  IDbDataParameter[]{
                    dbhelper.CreateParameter( " @ERPNO " ,aCustomerinfo.ERPNO),
                    dbhelper.CreateParameter( " @CorpName " ,aCustomerinfo.CorpName),
                    dbhelper.CreateParameter( " @CorpAddress " ,aCustomerinfo.CorpAddress),
                    dbhelper.CreateParameter( " @CorpPhone " ,aCustomerinfo.CorpPhone),
                    dbhelper.CreateParameter( " @CorpContract " ,aCustomerinfo.CorpContract),
                    dbhelper.CreateParameter( " @CorpTax " ,aCustomerinfo.CorpTax),
                    dbhelper.CreateParameter( " @CorpBank " ,aCustomerinfo.CorpBank),
                    dbhelper.CreateParameter( " @CorpBankNO " ,aCustomerinfo.CorpBankNO),
                    dbhelper.CreateParameter( " @PayType " ,aCustomerinfo.PayType),
                    dbhelper.CreateParameter( " @CustomerType " ,aCustomerinfo.CustomerType),
                    dbhelper.CreateParameter( " @ERPContractType " ,aCustomerinfo.ERPContractType),
                    dbhelper.CreateParameter( " @IsDirectShip " ,aCustomerinfo.IsDirectShip),
                    dbhelper.CreateParameter( " @IsEnabled " ,aCustomerinfo.IsEnabled),
                    dbhelper.CreateParameter( " @UpdateTime " ,aCustomerinfo.UpdateTime),
                    dbhelper.CreateParameter( " @CurrencyID " ,aCustomerinfo.CurrencyID),
                    dbhelper.CreateParameter( " @NeedProformaInvoice " ,aCustomerinfo.NeedProformaInvoice)
                };
             return   0   <  dbhelper.ExecuteNonQuery(sql.ToString(),p_Parms);
            }
        }
         public   bool  Update(A_CustomerInfo aCustomerinfo)
        {
            StringBuilder sql  =   new  StringBuilder();
            sql.Append( " UPDATE " );
            sql.Append( "  [A_Customer] " );
            sql.Append( "  SET " );
            sql.Append( "  [CorpName]=@CorpName, " );
            sql.Append( "  [CorpAddress]=@CorpAddress, " );
            sql.Append( "  [CorpPhone]=@CorpPhone, " );
            sql.Append( "  [CorpContract]=@CorpContract, " );
            sql.Append( "  [CorpTax]=@CorpTax, " );
            sql.Append( "  [CorpBank]=@CorpBank, " );
            sql.Append( "  [CorpBankNO]=@CorpBankNO, " );
            sql.Append( "  [PayType]=@PayType, " );
            sql.Append( "  [CustomerType]=@CustomerType, " );
            sql.Append( "  [ERPContractType]=@ERPContractType, " );
            sql.Append( "  [IsDirectShip]=@IsDirectShip, " );
            sql.Append( "  [IsEnabled]=@IsEnabled, " );
            sql.Append( "  [UpdateTime]=@UpdateTime, " );
            sql.Append( "  [CurrencyID]=@CurrencyID, " );
            sql.Append( "  [NeedProformaInvoice]=@NeedProformaInvoice " );
            sql.Append( "  WHERE " );
            sql.Append( "  [ERPNO]=@ERPNO " );
             using (OOSHelper dbhelper = new  OOSHelper())
            {
              IDbDataParameter[] p_Parms  =   new  IDbDataParameter[]{
                dbhelper.CreateParameter( " @CorpName " ,aCustomerinfo.CorpName),
                dbhelper.CreateParameter( " @CorpAddress " ,aCustomerinfo.CorpAddress),
                dbhelper.CreateParameter( " @CorpPhone " ,aCustomerinfo.CorpPhone),
                dbhelper.CreateParameter( " @CorpContract " ,aCustomerinfo.CorpContract),
                dbhelper.CreateParameter( " @CorpTax " ,aCustomerinfo.CorpTax),
                dbhelper.CreateParameter( " @CorpBank " ,aCustomerinfo.CorpBank),
                dbhelper.CreateParameter( " @CorpBankNO " ,aCustomerinfo.CorpBankNO),
                dbhelper.CreateParameter( " @PayType " ,aCustomerinfo.PayType),
                dbhelper.CreateParameter( " @CustomerType " ,aCustomerinfo.CustomerType),
                dbhelper.CreateParameter( " @ERPContractType " ,aCustomerinfo.ERPContractType),
                dbhelper.CreateParameter( " @IsDirectShip " ,aCustomerinfo.IsDirectShip),
                dbhelper.CreateParameter( " @IsEnabled " ,aCustomerinfo.IsEnabled),
                dbhelper.CreateParameter( " @UpdateTime " ,aCustomerinfo.UpdateTime),
                dbhelper.CreateParameter( " @CurrencyID " ,aCustomerinfo.CurrencyID),
                dbhelper.CreateParameter( " @NeedProformaInvoice " ,aCustomerinfo.NeedProformaInvoice),
                dbhelper.CreateParameter( " @ERPNO " ,aCustomerinfo.ERPNO)
              };
              return   0   <  dbhelper.ExecuteNonQuery(sql.ToString(),p_Parms);             
            }
        }
         public   bool  Delete( string  _eRPNO)
        {
            StringBuilder sql  =   new  StringBuilder();
            sql.Append( " DELETE FROM " );
            sql.Append( "  [A_Customer] " );
            sql.Append( "  WHERE " );
            sql.Append( "  [ERPNO]=@ERPNO " );
             using (OOSHelper dbhelper = new  OOSHelper())
            {
              IDbDataParameter[] p_Parms  =   new  IDbDataParameter[]{
                dbhelper.CreateParameter( " @ERPNO " ,_eRPNO)
              };
              return   0   <  dbhelper.ExecuteNonQuery(sql.ToString(),p_Parms);             
            }
        }
        
    }
}

 

还有一种是采用静态调用的方式（尤其在对一些简单数据访问时为了方便就用静态调用方式）：

    public class WebServiceDAL
    {
        public DataTable Test()
        {
            string sql = "select * from test";
            return OOSHelper.StaticExecuteTable(System.Data.CommandType.Text, sql);
        }
    }

 

以上文章是小弟经过多年的经验无聊的时候想到的，该代码已经经过我的压力测试。

不好意思，小弟语文从高中以后从没有及格过，文章没有几个字，但是想分享给大家看看，提提意见，不懂可直接mail给我，

转载于:https://www.cnblogs.com/steven_jiangxf/archive/2010/04/19/dataaccesslayer.html

weixin_30920513
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
不用json文件不用数据库存储实现三级联动
12-15
琢磨了好几天，原来只需要简单的jquery语法可以实现了，顿时令人头晕的问题解决了，真好！ 　下面是我写的一个小示例： 　(1)首先是一点小说明： 　首先要引入一个jquery.js文件，使用到的几个基本方法参考帮助...
IDbCommand.Prepare()方法。
kingwkb的专栏
03-21 2537
这个方法可以把CommandType为Text的SQL语句提前在数据库中编译为一个临时的StoredProcedure然后再执行，这样对于需要多次执行的DbCommand来说，可以提高一定的执行效率：）注意：请在指定了Command的Connection之后再调用Prepare()方法。此方法在msdn上的介绍如下：Creates a prepared (or compiled) version
执行SqlCommand.Prepare出错;
weixin_30547797的博客
05-19 246
SqlCommand.Prepare()方法。在IDbCommand接口上就定义了Prepare()方法，这个方法可以把CommandType为Text的SQL语句提前在数据库中编译为一个临时的StoredProcedure然后再执行，这样对于需要多次执行的DbCommand来说，可以提高一定的执行效率：）注意：请在指定了Command的Connection之后再调用Prepare()方...
ADO.NET 的最佳实践技巧
alice_art的专栏
04-27 682
ADO.NET 的最佳实践技巧 这是我很早以前看过的微软的一篇文章，最近，一些网友问的问题很多理论都在里面，所以，整理一下放在这里，大家可以参考一下。简介本文为您提供了在 Microsoft ADO.NET 应用程序中实现和获得最佳性能、可伸缩性以及功能的最佳解决方案；同时也讲述了使用 ADO.NET 中可用对象的最佳实践；并提出一些有助于优化 ADO.NET 应用程序设计的建议。
[新手点滴] IDbCommand.Prepare()方法。
dengxuanka1837的博客
03-06 216
今天在逛新闻组的时候无意中看到了SqlCommand.Prepare()方法。在IDbCommand接口上就定义了Prepare()方法，这个方法可以把CommandType为Text的SQL语句提前在数据库中编译为一个临时的StoredProcedure然后再执行，这样对于需要多次执行的DbCommand来说，可以提高一定的执行效率：）注意：请在指定了Command的Connectio...
school.rar_数据库编程_Java_
08-12
本程序是数据库初级程序，一个学习系统，适合初级编程者学习和琢磨
远程linux服务器mysql数据库定期备份和删除
12-15
网上已经有部分关于Linux下定期备份mysql的方法，但是很多步骤不够详细，不适合新手，自己琢磨了很久，终于搞定了。 　1.Linux服务器一般是ssh协议，如果本地也是Linux环境，可以直接通过shell连接，命令： 　ssh...
功能很多，自己琢磨，用来处理处理数据，照片
11-18
有兴趣的再说，sssssssssssssssssss，wwwwwwwwwwwwwwww，ddddddddddddddddddd，aaaaaaaaaaaaaaaaaaa，xxxxxxxxxxxxxxxxxxx，数据数据影像，太阳高度角。
贡献一套自己琢磨的zfb永不掉线的思路-易语言
06-12
利用旺旺快捷登录zfb进行订单监控，理论上来说旺旺不掉我不掉！！！
ubase第三部分
06-19
ubase第三部分
常用的数据访问底层类
hhxxcj的专栏
01-29 636
using System;using System.Data;using System.Data.SqlClient;using System.Collections;using System.Configuration;/*  * 所属层次：数据访问类组件(数据操作) */namespace DBUtility{    ///     /// SqlHelper类用于操作数据库(可升级，扩展
数据库访问（底层访问）
hugejihu9的专栏
11-08 672
文章来自：源码在线https://www.shengli.me/server/192.html 数据阅读器：简单的了解一下什么是数据阅读器，通俗的说 数据阅读器是 只读 只取 的一个操作，返回的结果如果读到数据就返回true 如果没有访问到数据就返回  false，通过Read()的方法进行读取。简单介绍一下代码  ...
SQL数据库通用访问类
武安候的专栏
09-19 882
using System;using System.Configuration;using System.Data;using System.Data.SqlClient;using System.Collections;namespace CFCHINA.TOOLS.DataBase{    ///     /// 通用数据库类    ///     public class DataBas
数据库磁盘IO
dodomail的专栏
03-14 135
http://www.doc88.com/p-040876231811.html
这次作业刚开始不理解的是table widget插入数据，后来琢磨一下就知道了，然后难的应该就是信号的使用了，我一开始犯的错是信号connet那里使用了lambda，导致使用函数时还需要传值，后来发现不用lambda。然后就是我在app.py里的信号设置为了data_signal = Signal(str,str,str,str,str)， 导致传值时age一直是空值，但是我在add.py里print出来是age有值，后来就想到了age是int，然后改成data_signal = Signal(str,str,str,str,int)就行了。 根据这段话写一个风格不同 意思相近但有看出区别的段落
最新发布
06-02
在这次作业中，我遇到了一些困难。最初我对于table widget插入数据的操作有些疑惑但是随着不断尝试和思考，我逐渐掌握了这个操作的技巧。另外，信号的使用也是一个难点，我一开始犯了一个错误，即在connect信号时...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值