資料庫訪問層

来源:http://www.cnblogs.com/shouce/archive/2016/03/07/5249331.html
-Advertisement-
Play Games

簡易型： C# DBHelper Code using System; using System.Collections.Generic; using System.Text; using System.Data; using System.Data.SqlClient; using System.


簡易型：

C# DBHelper Code 
using System;
using System.Collections.Generic;
using System.Text;
using System.Data;
using System.Data.SqlClient;
using System.Configuration;

namespace ADODoNETDemo
{
    /// <summary>
    /// 針對SQL Server資料庫操作的通用類
    /// 作者：周公
    /// 日期：2009-01-08
    /// Version:1.0
    /// </summary>
    public class SqlDbHelper
    {
        private string connectionString;
        /// <summary>
        /// 設置資料庫連接字元串
        /// </summary>
        public string ConnectionString
        {
            set { connectionString = value; }
        }
        /// <summary>
        /// 構造函數
        /// </summary>
        public SqlDbHelper()
            : this(ConfigurationManager.ConnectionStrings["Conn"].ConnectionString)
        {

        }
        /// <summary>
        /// 構造函數
        /// </summary>
        /// <param name="connectionString">資料庫連接字元串</param>
        public SqlDbHelper(string connectionString)
        {
            this.connectionString = connectionString;
        }
        /// <summary>
        /// 執行一個查詢，並返回結果集
        /// </summary>
        /// <param name="sql">要執行的查詢SQL文本命令</param>
        /// <returns>返回查詢結果集</returns>
        public DataTable ExecuteDataTable(string sql)
        {
            return ExecuteDataTable(sql, CommandType.Text, null);
        }
        /// <summary>
        /// 執行一個查詢,並返回查詢結果
        /// </summary>
        /// <param name="sql">要執行的SQL語句</param>
        /// <param name="commandType">要執行的查詢語句的類型，如存儲過程或者SQL文本命令</param>
        /// <returns>返回查詢結果集</returns>
        public DataTable ExecuteDataTable(string sql, CommandType commandType)
        {
            return ExecuteDataTable(sql, commandType, null);
        }
        /// <summary>
        /// 執行一個查詢,並返回查詢結果
        /// </summary>
        /// <param name="sql">要執行的SQL語句</param>
        /// <param name="commandType">要執行的查詢語句的類型，如存儲過程或者SQL文本命令</param>
        /// <param name="parameters">Transact-SQL 語句或存儲過程的參數數組</param>
        /// <returns></returns>
        public DataTable ExecuteDataTable(string sql, CommandType commandType, SqlParameter[] parameters)
        {
            DataTable data = new DataTable();//實例化DataTable，用於裝載查詢結果集
            using (SqlConnection connection = new SqlConnection(connectionString))
            {
                using (SqlCommand command = new SqlCommand(sql, connection))
                {
                    command.CommandType = commandType;//設置command的CommandType為指定的CommandType
                    //如果同時傳入了參數，則添加這些參數
                    if (parameters != null)
                    {
                        foreach (SqlParameter parameter in parameters)
                        {
                            command.Parameters.Add(parameter);
                        }
                    }
                    //通過包含查詢SQL的SqlCommand實例來實例化SqlDataAdapter
                    SqlDataAdapter adapter = new SqlDataAdapter(command);

                    adapter.Fill(data);//填充DataTable
                }
            }
            return data;
        }
        /// <summary>
        /// 
        /// </summary>
        /// <param name="sql">要執行的查詢SQL文本命令</param>
        /// <returns></returns>
        public SqlDataReader ExecuteReader(string sql)
        {
            return ExecuteReader(sql, CommandType.Text, null);
        }
        /// <summary>
        /// 
        /// </summary>
        /// <param name="sql">要執行的SQL語句</param>
        /// <param name="commandType">要執行的查詢語句的類型，如存儲過程或者SQL文本命令</param>
        /// <returns></returns>
        public SqlDataReader ExecuteReader(string sql, CommandType commandType)
        {
            return ExecuteReader(sql, commandType, null);
        }
        /// <summary>
        /// 
        /// </summary>
        /// <param name="sql">要執行的SQL語句</param>
        /// <param name="commandType">要執行的查詢語句的類型，如存儲過程或者SQL文本命令</param>
        /// <param name="parameters">Transact-SQL 語句或存儲過程的參數數組</param>
        /// <returns></returns>
        public SqlDataReader ExecuteReader(string sql, CommandType commandType, SqlParameter[] parameters)
        {
            SqlConnection connection = new SqlConnection(connectionString);
            SqlCommand command = new SqlCommand(sql, connection);
            //如果同時傳入了參數，則添加這些參數
            if (parameters != null)
            {
                foreach (SqlParameter parameter in parameters)
                {
                    command.Parameters.Add(parameter);
                }
            }
            connection.Open();
            //CommandBehavior.CloseConnection參數指示關閉Reader對象時關閉與其關聯的Connection對象
            return command.ExecuteReader(CommandBehavior.CloseConnection);
        }
        /// <summary>
        /// 
        /// </summary>
        /// <param name="sql">要執行的查詢SQL文本命令</param>
        /// <returns></returns>
        public Object ExecuteScalar(string sql)
        {
            return ExecuteScalar(sql, CommandType.Text, null);
        }
        /// <summary>
        /// 
        /// </summary>
        /// <param name="sql">要執行的SQL語句</param>
        /// <param name="commandType">要執行的查詢語句的類型，如存儲過程或者SQL文本命令</param>
        /// <returns></returns>
        public Object ExecuteScalar(string sql, CommandType commandType)
        {
            return ExecuteScalar(sql, commandType, null);
        }
        /// <summary>
        /// 
        /// </summary>
        /// <param name="sql">要執行的SQL語句</param>
        /// <param name="commandType">要執行的查詢語句的類型，如存儲過程或者SQL文本命令</param>
        /// <param name="parameters">Transact-SQL 語句或存儲過程的參數數組</param>
        /// <returns></returns>
        public Object ExecuteScalar(string sql, CommandType commandType, SqlParameter[] parameters)
        {
            object result = null;
            using (SqlConnection connection = new SqlConnection(connectionString))
            {
                using (SqlCommand command = new SqlCommand(sql, connection))
                {
                    command.CommandType = commandType;//設置command的CommandType為指定的CommandType
                    //如果同時傳入了參數，則添加這些參數
                    if (parameters != null)
                    {
                        foreach (SqlParameter parameter in parameters)
                        {
                            command.Parameters.Add(parameter);
                        }
                    }
                    connection.Open();//打開資料庫連接
                    result = command.ExecuteScalar();
                }
            }
            return result;//返回查詢結果的第一行第一列，忽略其它行和列
        }
        /// <summary>
        /// 對資料庫執行增刪改操作
        /// </summary>
        /// <param name="sql">要執行的查詢SQL文本命令</param>
        /// <returns></returns>
        public int ExecuteNonQuery(string sql)
        {
            return ExecuteNonQuery(sql, CommandType.Text, null);
        }
        /// <summary>
        /// 對資料庫執行增刪改操作
        /// </summary>
        /// <param name="sql">要執行的SQL語句</param>
        /// <param name="commandType">要執行的查詢語句的類型，如存儲過程或者SQL文本命令</param>
        /// <returns></returns>
        public int ExecuteNonQuery(string sql, CommandType commandType)
        {
            return ExecuteNonQuery(sql, commandType, null);
        }
        /// <summary>
        /// 對資料庫執行增刪改操作
        /// </summary>
        /// <param name="sql">要執行的SQL語句</param>
        /// <param name="commandType">要執行的查詢語句的類型，如存儲過程或者SQL文本命令</param>
        /// <param name="parameters">Transact-SQL 語句或存儲過程的參數數組</param>
        /// <returns></returns>
        public int ExecuteNonQuery(string sql, CommandType commandType, SqlParameter[] parameters)
        {
            int count = 0;
            using (SqlConnection connection = new SqlConnection(connectionString))
            {
                using (SqlCommand command = new SqlCommand(sql, connection))
                {
                    command.CommandType = commandType;//設置command的CommandType為指定的CommandType
                    //如果同時傳入了參數，則添加這些參數
                    if (parameters != null)
                    {
                        foreach (SqlParameter parameter in parameters)
                        {
                            command.Parameters.Add(parameter);
                        }
                    }
                    connection.Open();//打開資料庫連接
                    count = command.ExecuteNonQuery();
                }
            }
            return count;//返回執行增刪改操作之後，資料庫中受影響的行數
        }
        /// <summary>
        /// 返回當前連接的資料庫中所有由用戶創建的資料庫
        /// </summary>
        /// <returns></returns>
        public DataTable GetTables()
        {
            DataTable data = null;
            using (SqlConnection connection = new SqlConnection(connectionString))
            {
                connection.Open();//打開資料庫連接
                data = connection.GetSchema("Tables");
            }
            return data;
        }

    }
}

　　複雜型：

C# DBUtility Code 
 using System;  
 using System.Collections;  
 using System.Collections.Specialized;  
 using System.Data;  
 using System.Data.SqlClient;  
 using System.Configuration;  
 using System.Data.Common;  
 using System.Collections.Generic;

using TL.DataAccess;

namespace TL.Business
{
     public enum EffentNextType  
     {  
         /// <summary>  
         /// 對其他語句無任何影響   
         /// </summary>  
         None,  
         /// <summary>  
         /// 當前語句必須為"SELECT COUNT(1) FROM .."格式，如果存在則繼續執行，不存在回滾事務  
         /// </summary>  
         WhenHaveContine,  
         /// <summary>  
         /// 當前語句必須為"SELECT COUNT(1) FROM .."格式，如果不存在則繼續執行，存在回滾事務  
         /// </summary>  
         WhenNoHaveContine,  
         /// <summary>  
         /// 當前語句影響到的行數必須大於0，否則回滾事務  
         /// </summary>  
         ExcuteEffectRows,  
         /// <summary>  
         /// 引發事件-當前語句必須為"SELECT COUNT(1) FROM .."格式，如果不存在則繼續執行，存在回滾事務  
         /// </summary>  
         SolicitationEvent  
     }  
     public class DBUtility  
     {  
         public object ShareObject = null;  
         public object OriginalData = null;  
         event EventHandler _solicitationEvent;  
         public event EventHandler SolicitationEvent  
         {  
             add  
             {  
                 _solicitationEvent += value;  
             }  
             remove  
             {  
                 _solicitationEvent -= value;  
             }  
         }  
         public void OnSolicitationEvent()  
         {  
             if (_solicitationEvent != null)  
             {  
                 _solicitationEvent(this,new EventArgs());  
             }  
         }  
         public string CommandText;  
         public System.Data.Common.DbParameter[] Parameters;  
         public EffentNextType EffentNextType = EffentNextType.None;  
         public DBUtility()  
         {  
         }
         public DBUtility(SqlParameter[] para)
         {
             this.Parameters = para;
         }
         public DBUtility(string sqlText, SqlParameter[] para)  
         {  
             this.CommandText = sqlText;  
             this.Parameters = para;  
         }  
         public DBUtility(string sqlText, SqlParameter[] para, EffentNextType type)  
         {  
             this.CommandText = sqlText;  
             this.Parameters = para;  
             this.EffentNextType = type;  
         }  
     }
     /// <summary>  
     /// 數據訪問抽象基礎類  
     /// Copyright (C) 2004-2008 By LiTianPing   
     /// </summary>  
     public class SQLHelper
     {  
         //資料庫連接字元串(web.config來配置)，可以動態更改connectionString支持多資料庫.       
         public string connectionString = "";
         public SQLHelper()
         {
             connectionString = @"DATA SOURCE=192.168.0.103,2433;UID=cdteam;PWD=cd-team2011_;DATABASE=TongLing";
         }  
         #region 公用方法  
         /// <summary>  
         /// 讀取指定圖片的二進位信息  
         /// </summary>  
         /// <param name="id"></param>  
         /// <returns></returns>  
         public object LoadImage(int id)  
         {  
             SqlConnection myConnection = new SqlConnection(connectionString);  
             SqlCommand myCommand = new SqlCommand("SELECT [bImage] FROM [tblCAIPIAO_NEWS_IMG] WHERE id=@id", myConnection);  
             myCommand.CommandType = CommandType.Text;  
             myCommand.Parameters.Add(new SqlParameter("@id", id));  
             myConnection.Open();  
             object result = myCommand.ExecuteScalar();  
             try  
             {  
                 return new System.IO.MemoryStream((byte[])result);  
             }  
             catch (ArgumentNullException e)  
             {  
                 return null;  
             }  
             finally  
             {  
                 myConnection.Close();  
             }  
         }  
         /// <summary>  
         /// 判斷是否存在某表的某個欄位  
         /// </summary>  
         /// <param name="tableName">表名稱</param>  
         /// <param name="columnName">列名稱</param>  
         /// <returns>是否存在</returns>  
         public bool ColumnExists(string tableName, string columnName)  
         {  
             string sql = "select count(1) from syscolumns where id=object_id(" + tableName + ") and name=" + columnName + "";  
             object res = GetSingle(sql);  
             if (res == null)  
             {  
                 return false;  
             }  
             return Convert.ToInt32(res) > 0;  
         }  
         public int GetMaxID(string FieldName, string TableName)  
         {  
             string strsql = "select max(" + FieldName + ")+1 from " + TableName;
             object obj = this.GetSingle(strsql);  
             if (obj == null)  
             {  
                 return 1;  
             }  
             else  
             {  
                 return int.Parse(obj.ToString());  
             }  
         }  
         public bool Exists(string strSql)  
         {
             object obj = this.GetSingle(strSql);  
             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;  
             }  
         }  
         /// <summary>  
         /// 表是否存在  
         /// </summary>  
         /// <param name="TableName"></param>  
         /// <returns></returns>  
         public bool TabExists(string TableName)  
         {  
             string strsql = "select count(*) from sysobjects where id = object_id(N[" + TableName + "]) and OBJECTPROPERTY(id, N[IsUserTable]) = 1";  
             //string strsql = "SELECT count(*) FROM sys.objects WHERE object_id = OBJECT_ID(N"[dbo].[" + TableName + "]") AND type in (N"U")";  
             object obj = this.GetSingle(strsql);  
             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;  
             }  
         }  
         public bool Exists(string strSql, params SqlParameter[] cmdParms)  
         {
             object obj = this.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語句  
         /// <summary>  
         /// 執行SQL語句，返回影響的記錄數  
         /// </summary>  
         /// <param name="SQLString">SQL語句</param>  
         /// <returns>影響的記錄數</returns>  
         public int ExecuteSql(string SQLString)  
         {  
             using (SqlConnection connection = new SqlConnection(connectionString))  
             {  
                 using (SqlCommand cmd = new SqlCommand(SQLString, connection))  
                 {  
                     try  
                     {  
                         connection.Open();  
                         int rows = cmd.ExecuteNonQuery();  
                         return rows;  
                     }  
                     catch (System.Data.SqlClient.SqlException e)  
                     {  
                         connection.Close();  
                         throw e;  
                     }  
                 }  
             }  
         }  
         public int ExecuteSqlByTime(string SQLString, int Times)  
         {  
             using (SqlConnection connection = new SqlConnection(connectionString))  
             {  
                 using (SqlCommand cmd = new SqlCommand(SQLString, connection))  
                 {  
                     try  
                     {  
                         connection.Open();  
                         cmd.CommandTimeout = Times;  
                         int rows = cmd.ExecuteNonQuery();  
                         return rows;  
                     }  
                     catch (System.Data.SqlClient.SqlException e)  
                     {  
                         connection.Close();  
                         throw e;  
                     }  
                 }  
             }  
         }  
         /// <summary>  
         /// 執行Sql和Oracle滴混合事務  
         /// </summary>  
         /// <param name="list">SQL命令行列表</param>  
         /// <param name="oracleCmdSqlList">Oracle命令行列表</param>  
         /// <returns>執行結果 0-由於SQL造成事務失敗 -1 由於Oracle造成事務失敗 1-整體事務執行成功</returns>  
         public int ExecuteSqlTran(List<DBUtility> list, List<DBUtility> oracleCmdSqlList)  
         {  
             using (SqlConnection conn = new SqlConnection(connectionString))  
             {  
                 conn.Open();  
                 SqlCommand cmd = new SqlCommand();  
                 cmd.Connection = conn;  
                 SqlTransaction tx = conn.BeginTransaction();  
                 cmd.Transaction = tx;  
                 try  
                 {  
                     foreach (DBUtility myDE in list)  
                     {  
                         string cmdText = myDE.CommandText;  
                         SqlParameter[] cmdParms = (SqlParameter[])myDE.Parameters;  
                         PrepareCommand(cmd, conn, tx, cmdText, cmdParms);  
                         if (myDE.EffentNextType == EffentNextType.SolicitationEvent)  
                         {  
                             if (myDE.CommandText.ToLower().IndexOf("count(") == -1)  
                             {  
                                 tx.Rollback();  
                                 throw new Exception("違背要求" + myDE.CommandText + "必須符合select count(..的格式");  
                                 //return 0;  
                             }  
                             object obj = cmd.ExecuteScalar();  
                             bool isHave = false;  
                             if (obj == null && obj == DBNull.Value)  
                             {  
                                 isHave = false;  
                             }  
                             isHave = Convert.ToInt32(obj) > 0;  
                             if (isHave)  
                             {  
                                 //引發事件  
                                 myDE.OnSolicitationEvent();  
                             }  
                         }  
                         if (myDE.EffentNextType == EffentNextType.WhenHaveContine || myDE.EffentNextType == EffentNextType.WhenNoHaveContine)  
                         {  
                             if (myDE.CommandText.ToLower().IndexOf("count(") == -1)  
                             {  
                                 tx.Rollback();  
                                 throw new Exception("SQL:違背要求" + myDE.CommandText + "必須符合select count(..的格式");  
                                 //return 0;  
                             }  
                             object obj = cmd.ExecuteScalar();  
                             bool isHave = false;  
                             if (obj == null && obj == DBNull.Value)  
                             {  
                                 isHave = false;  
                             }  
                             isHave = Convert.ToInt32(obj) > 0;  
                             if (myDE.EffentNextType == EffentNextType.WhenHaveContine && !isHave)  
                             {  
                                 tx.Rollback();  
                                 throw new Exception("SQL:違背要求" + myDE.CommandText + "返回值必須大於0");  
                                 //return 0;  
                             }  
                             if (myDE.EffentNextType == EffentNextType.WhenNoHaveContine && isHave)  
                             {  
                                 tx.Rollback();  
                                 throw new Exception("SQL:違背要求" + myDE.CommandText + "返回值必須等於0");  
                                 //return 0;  
                             }  
                             continue;  
                         }  
                         int val = cmd.ExecuteNonQuery();  
                         if (myDE.EffentNextType == EffentNextType.ExcuteEffectRows && val == 0)  
                         {  
                             tx.Rollback();  
                             throw new Exception("SQL:違背要求" + myDE.CommandText + "必須有影響行");  
                             //return 0;  
                         }  
                         cmd.Parameters.Clear();  
                     }  
                     //string oraConnectionString = PubConstant.GetConnectionString("ConnectionStringPPC");  
                     //bool res = OracleHelper.ExecuteSqlTran(oraConnectionString, oracleCmdSqlList);  
                     //if (!res)  
                     //{  
                     //    tx.Rollback();  
                     //    throw new Exception("Oracle執行失敗");  
                         // return -1;  
                     //}  
                     tx.Commit();  
                     return 1;  
                 }  
                 catch (System.Data.SqlClient.SqlException e)  
                 {  
                     tx.Rollback();  
                     throw e;  
                 }  
                 catch (Exception e)  
                 {  
                     tx.Rollback();  
                     throw e;  
                 }  
             }  
         }  
         /// <summary>  
         /// 執行多條SQL語句，實現資料庫事務。  
         /// </summary>  
         /// <param name="SQLStringList">多條SQL語句</param>       
         public int ExecuteSqlTran(List<String> SQLStringList)  
         {  
             using (SqlConnection conn = new SqlConnection(connectionString))  
             {  
                 conn.Open();  
                 SqlCommand cmd = new SqlCommand();  
                 cmd.Connection = conn;  
                 SqlTransaction tx = conn.BeginTransaction();  
                 cmd.Transaction = tx;  
                 try  
                 {  
                     int count = 0;  
                     for (int n = 0; n < SQLStringList.Count; n++)  
                     {  
                         string strsql = SQLStringList[n];  
                         if (strsql.Trim().Length > 1)  
                         {  
                             cmd.CommandText = strsql;  
                             count += cmd.ExecuteNonQuery();  
                         }  
                     }  
                     tx.Commit();  
                     return count;  
                 }  
                 catch  
                 {  
                     tx.Rollback();  
                     return 0;  
                 }  
             }  
         }  
         /// <summary>  
         /// 執行帶一個存儲過程參數的的SQL語句。  
         /// </summary>  
         /// <param name="SQLString">SQL語句</param>  
         /// <param name="content">參數內容,比如一個欄位是格式複雜的文章，有特殊符號，可以通過這個方式添加</param>  
         /// <returns>影響的記錄數</returns>  
         public int ExecuteSql(string SQLString, string content)  
         {  
             using (SqlConnection connection = new SqlConnection(connectionString))  
             {  
                 SqlCommand cmd = new SqlCommand(SQLString, connection);  
                 System.Data.SqlClient.SqlParameter myParameter = new System.Data.SqlClient.SqlParameter("@content", SqlDbType.NText);  
                 myParameter.Value = content;  
                 cmd.Parameters.Add(myParameter);  
                 try  
                 {  
                     connection.Open();  
                     int rows = cmd.ExecuteNonQuery();  
                     return rows;  
                 }  
                 catch (System.Data.SqlClient.SqlException e)  
                 {  
                     throw e;  
                 }  
                 finally  
                 {  
                     cmd.Dispose();  
                     connection.Close();  
                 }  
             }  
         }  
         /// <summary>  
         /// 執行帶一個存儲過程參數的的SQL語句。  
         /// </summary>  
         /// <param name="SQLString">SQL語句</param>  
         /// <param name="content">參數內容,比如一個欄位是格式複雜的文章，有特殊符號，可以通過這個方式添加</param>  
         /// <returns>影響的記錄數</returns>  
         public object ExecuteSqlGet(string SQLString, string content)  
         {  
             using (SqlConnection connection = new SqlConnection(connectionString))  
             {  
                 SqlCommand cmd = new SqlCommand(SQLString, connection);  
                 System.Data.SqlClient.SqlParameter myParameter = new System.Data.SqlClient.SqlParameter("@content", SqlDbType.NText);  
                 myParameter.Value = content;  
                 cmd.Parameters.Add(myParameter);  
                 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.SqlClient.SqlException e)  
                 {  
                     throw e;  
                 }  
                 finally  
                 {  
                     cmd.Dispose();  
                     connection.Close();  
                 }  
             }  
         }  
         /// <summary>  
         /// 向資料庫里插入圖像格式的欄位(和上面情況類似的另一種實例)  
         /// </summary>  
         /// <param name="strSQL">SQL語句</param>  
         /// <param name="fs">圖像位元組,資料庫的欄位類型為image的情況</param>  
         /// <returns>影響的記錄數</returns>  
         public int ExecuteSqlInsertImg(string strSQL, byte[] fs)  
         {  
             using (SqlConnection connection = new SqlConnection(connectionString))  
             {  
                 SqlCommand cmd = new SqlCommand(strSQL, connection);  
                 System.Data.SqlClient.SqlParameter myParameter = new System.Data.SqlClient.SqlParameter("@fs", SqlDbType.Image);  
                 myParameter.Value = fs;  
                 cmd.Parameters.Add(myParameter);  
                 try  
                 {  
                     connection.Open();  
                     int rows = cmd.ExecuteNonQuery();  
                     return rows;  
                 }  
                 catch (System.Data.SqlClient.SqlException e)  
                 {  
                     throw e;  
                 }  
                 finally  
                 {  
                     cmd.Dispose();  
                     connection.Close();  
                 }  
             }  
         }  
         /// <summary>  
         /// 執行一條計算查詢結果語句，返回查詢結果（object）。  
         /// </summary>  
         /// <param name="SQLString">計算查詢結果語句</param>  
         /// <returns>查詢結果（object）</returns>  
         public object GetSingle(string SQLString)  
         {  
             using (SqlConnection connection = new SqlConnection(connectionString))  
             {  
                 using (SqlCommand cmd = new SqlCommand(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.SqlClient.SqlException e)  
                     {  
                         connection.Close();  
                         throw e;  
                     }  
                 }  
             }  
         }  
         public object GetSingle(string SQLString, int Times)  
         {  
             using (SqlConnection connection = new SqlConnection(connectionString))  
             {  
                 using (SqlCommand cmd = new SqlCommand(SQLString, connection))  
                 {  
                     try  
                     {  
                         connection.Open();  
                         cmd.CommandTimeout = Times;  
                         object obj = cmd.ExecuteScalar();  
                         if ((Object.Equals(obj, null)) || (Object.Equals(obj, System.DBNull.Value)))  
                         {  
                             return null;  
                         }  
                         else  
                         {  
                             return obj;  
                         }  
                     }  
                     catch (System.Data.SqlClient.SqlException e)  
                     {  
                         connection.Close();  
                         throw e;  
                     }  
                 }  
             }  
         }  
         /// <summary>  
         /// 執行查詢語句，返回SqlDataReader ( 註意：調用該方法後，一定要對SqlDataReader進行Close )  
         /// </summary>  
         /// <param name="strSQL">查詢語句</param>  
         /// <returns>SqlDataReader</returns>  
         public SqlDataReader ExecuteReader(string strSQL)  
         {  
             SqlConnection connection = new SqlConnection(connectionString);  
             SqlCommand cmd = new SqlCommand(strSQL, connection);  
             try  
             {  
                 connection.Open();  
                 SqlDataReader myReader = cmd.ExecuteReader(CommandBehavior.CloseConnection);  
                 return myReader;  
             }  
             catch (System.Data.SqlClient.SqlException e)  
             {  
                 throw e;  
             }  
         }  
         /// <summary>  
         /// 執行查詢語句，返回DataSet  
         /// </summary>  
         /// <param name="SQLString">查詢語句</param>  
         /// <returns>DataSet</returns>  
         public DataSet Query(string SQLString)  
         {  
             using (SqlConnection connection = new SqlConnection(connectionString))  
             {  
                 DataSet ds = new DataSet();  
                 try  
                 {  
                     connection.Open();  
                     SqlDataAdapter command = new SqlDataAdapter(SQLString, connection);  
                     command.Fill(ds, "ds");  
                 }  
                 catch (System.Data.SqlClient.SqlException ex)  
                 {  
                     throw new Exception(ex.Message);  
                 }  
                 return ds;  
             }  
         }  
         /// <summary>  
         /// 查詢並得到數據集DataSet  
         /// </summary>  
         /// <param name="SQLString"></param>  
         /// <param name="Times"></param>  
         /// <returns></returns>  
         public DataSet Query(string SQLString, int Times)  
         {  
             using (SqlConnection connection = new SqlConnection(connectionString))  
             {  
                 DataSet ds = new DataSet();  
                 try  
                 {  
                     connection.Open();  
                     SqlDataAdapter command = new SqlDataAdapter(SQLString, connection);  
                     command.SelectCommand.CommandTimeout = Times;  
                     command.Fill(ds, "ds");  
                 }  
                 catch (System.Data.SqlClient.SqlException ex)  
                 {  
                     throw new Exception(ex.Message);  
                 }  
                 return ds;  
             }  
         }  
         #endregion  
         #region 執行帶參數的SQL語句  
         /// <summary>  
         /// 執行SQL語句，返回影響的記錄數  
         /// </summary>  
         /// <param name="SQLString">SQL語句</param>  
         /// <returns>影響的記錄數</returns>  
         public int ExecuteSql(string SQLString, params SqlParameter[] cmdParms)  
         {  
             using (SqlConnection connection = new SqlConnection(connectionString))  
             {  
                 using (SqlCommand cmd = new SqlCommand())  
                 {  
                     try  
                     {  
                         PrepareCommand(cmd, connection, null, SQLString, cmdParms);  
                         int rows = cmd.ExecuteNonQuery();  
                         cmd.Parameters.Clear();  
                         return rows;  
                     }  
                     catch (System.Data.SqlClient.SqlException e)  
                     {  
                         throw e;  
                     }  
                 }  
             }  
         }  
         /// <summary>  
         /// 執行多條SQL語句，實現資料庫事務。  
         /// </summary>  
         /// <param name="SQLStringList">SQL語句的哈希表（key為sql語句，value是該語句的SqlParameter[]）</param>  
         public void ExecuteSqlTran(Hashtable SQLStringList)  
         {  
             using (SqlConnection conn = new SqlConnection(connectionString))  
             {  
                 conn.Open();  
                 using (SqlTransaction trans = conn.BeginTransaction())  
                 {  
                     SqlCommand cmd = new SqlCommand();  
                     try  
                     {  
                         //迴圈  
                         foreach (DictionaryEntry myDE in SQLStringList)  
                         {  
                             string cmdText = myDE.Key.ToString();  
                             SqlParameter[] cmdParms = (SqlParameter[])myDE.Value;  
                             PrepareCommand(cmd, conn, trans, cmdText, cmdParms);  
                             int val = cmd.ExecuteNonQuery();  
                             cmd.Parameters.Clear();  
                         }  
                         trans.Commit();  
                     }  
                     catch  
                     {  
                         trans.Rollback();  
                         throw;  
                     }  
                 }  
             }  
         }  
         /// <summary>  
         /// 執行多條SQL語句，實現資料庫事務。  
         /// </summary>  
         /// <param name="SQLStringList">SQL語句的哈希表（key為sql語句，value是該語句的SqlParameter[]）</param>  
         public int ExecuteSqlTran(System.Collections.Generic.List<DBUtility> cmdList)  
         {  
             using (SqlConnection conn = new SqlConnection(connectionString))  
             {  
                 conn.Open();  
                 using (SqlTransaction trans = conn.BeginTransaction())  
                 {  
                     SqlCommand cmd = new SqlCommand();  
                     try  
                     {  
                         int count = 0;  
                         //迴圈  
                         foreach (DBUtility myDE in cmdList)  
                         {  
                             string cmdText = myDE.CommandText;  
                             SqlParameter[] cmdParms = (SqlParameter[])myDE.Parameters;  
                             PrepareCommand(cmd, conn, trans, cmdText, cmdParms);  
                             if (myDE.EffentNextType == EffentNextType.WhenHaveContine || myDE.EffentNextType == EffentNextType.WhenNoHaveContine)  
                             {  
                                 if (myDE.CommandText.ToLower().IndexOf("count(") == -1)  
                                 {  
                                     trans.Rollback();  
                                     return 0;  
                                 }  
                                 object obj = cmd.ExecuteScalar();  
                                 bool isHave = false;  
                                 if (obj == null && obj == DBNull.Value)  
                                 {  
                                     isHave = false;  
                                 }  
                                 isHave = Convert.ToInt32(obj) > 0;  
                                 if (myDE.EffentNextType == EffentNextType.WhenHaveContine && !isHave)  
                                 {  
                                     trans.Rollback();  
                                     return 0;  
                                 }  
                                 if (myDE.EffentNextType == EffentNextType.WhenNoHaveContine && isHave)  
                                 {  
                                     trans.Rollback();  
                                     return 0;  
                                 }  
                                 continue;  
                             }  
                             int val = cmd.ExecuteNonQuery();  
                             count += val;  
                             if (myDE.EffentNextType == EffentNextType.ExcuteEffectRows && val == 0)  
                             {  
                                 trans.Rollback();  
                                 return 0;  
                             }  
                             cmd.Parameters.Clear();  
                         }  
                         trans.Commit();  
                         return count;  
                     }  
                     catch  
                     {  
                         trans.Rollback();  
                         throw;  
                     }  
                 }  
             }  
         }  
         /// <summary>  
         /// 執行多條SQL語句，實現資料庫事務。  
         /// </summary>  
         /// <param name="SQLStringList">SQL語句的哈希表（key為sql語句，value是該語句的SqlParameter[]）</param>  
         public void ExecuteSqlTranWithIndentity(System.Collections.Generic.List<DBUtility> SQLStringList)  
         {  
             using (SqlConnection conn = new SqlConnection(connectionString))  
             {  
                 conn.Open();  
                 using (SqlTransaction trans = conn.BeginTransaction())  
                 {  
                     SqlCommand cmd = new SqlCommand();  
                     try  
                     {  
                         int indentity = 0;  
                         //迴圈  
                         foreach (DBUtility myDE in SQLStringList)  
                         {  
                             string cmdText = myDE.CommandText;  
                             SqlParameter[] cmdParms = (SqlParameter[])myDE.Parameters;  
                             foreach (SqlParameter q in cmdParms)  
                             {  
                                 if (q.Direction == ParameterDirection.InputOutput)  
                                 {  
                                     q.Value = indentity;  
                                 }  
                             }  
                             PrepareCommand(cmd, conn, trans, cmdText, cmdParms);  
                             int val = cmd.ExecuteNonQuery();  
                             foreach (SqlParameter q in cmdParms)  
                             {  
                                 if (q.Direction == ParameterDirection.Output)  
                                 {  
                                     indentity = Convert.ToInt32(q.Value);  
                                 }  
                             }  
                             cmd.Parameters.Clear();  
                         }  
                         trans.Commit();  
                     }  
                     catch  
                     {  
                         trans.Rollback();  
                         throw;  
                     }  
                 }  
             }  
         }  
         /// <summary>  
         /// 執行多條SQL語句，實現資料庫事務。  
         /// </summary>  
         /// <param name="SQLStringList">SQL語句的哈希表（key為sql語句，value是該語句的SqlParameter[]）</param>  
         public void ExecuteSqlTranWithIndentity(Hashtable SQLStringList)  
         {  
             using (SqlConnection conn = new SqlConnection(connectionString))  
             {  
                 conn.Open();  
                 using (SqlTransaction trans = conn.BeginTransaction())  
                 {  
                     SqlCommand cmd = new SqlCommand();  
                     try  
                     {  
                         int indentity = 0;  
                         //迴圈  
                         foreach (DictionaryEntry myDE in SQLStringList)  
                         {  
                             string cmdText = myDE.Key.ToString();  
                             SqlParameter[] cmdParms = (SqlParameter[])myDE.Value;  
                             foreach (SqlParameter q in cmdParms)  
                             {  
                                 if (q.Direction == ParameterDirection.InputOutput)  
                                 {  
                                     q.Value = indentity;  
                                 }  
                             }  
                             PrepareCommand(cmd, conn, trans, cmdText, cmdParms);  
                             int val = cmd.ExecuteNonQuery();  
                             foreach (SqlParameter q in cmdParms)  
                             {  
                                 if (q.Direction == ParameterDirection.Output)  
                                 {  
                                     indentity = Convert.ToInt32(q.Value);  
                                 }  
                             }  
                             cmd.Parameters.Clear();  
                         }  
                         trans.Commit();  
                     }  
                     catch  
                     {  
                         trans.Rollback();  
                         throw;  
                     }  
                 }  
             }  
         }  
         /// <summary>  
         /// 執行一條計算查詢結果語句，返回查詢結果（object）。  
         /// </summary>  
         /// <param name="SQLString">計算查詢結果語句</param>  
         /// <returns>查詢結果（object）</returns>  
         public object GetSingle(string SQLString, params SqlParameter[] cmdParms)  
         {  
             using (SqlConnection connection = new SqlConnection(connectionString))  
             {  
                 using (SqlCommand cmd = new SqlCommand())  
                 {  
                     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.SqlClient.SqlException e)  
                     {  
                         throw e;  
                     }  
                 }  
             }  
         }  
         /// <summary>  
         /// 執行查詢語句，返回SqlDataReader ( 註意：調用該方法後，一定要對SqlDataReader進行Close )  
         /// </summary>  
         /// <param name="strSQL">查詢語句</param>  
         /// <returns>SqlDataReader</returns>  
         public SqlDataReader ExecuteReader(string SQLString, params SqlParameter[] cmdParms)  
         {  
             SqlConnection connection = new SqlConnection(connectionString);  
             SqlCommand cmd = new SqlCommand();  
             try  
             {  
                 PrepareCommand(cmd, connection, null, SQLString, cmdParms);  
                 SqlDataReader myReader = cmd.ExecuteReader(CommandBehavior.CloseConnection);  
                 cmd.Parameters.Clear();  
                 return myReader;  
             }  
             catch (System.Data.SqlClient.SqlException e)  
             {  
                 throw e;  
             }  
             //          finally  
             //          {  
             //              cmd.Dispose();  
             //              connection.Close();  
             //          }     
         }  
         /// <summary>  
         /// 執行查詢語句，返回DataSet  
         /// </summary>  
         /// <param name="SQLString">查詢語句</param>  
         /// <returns>DataSet</returns>  
         public DataSet Query(string SQLString, params SqlParameter[] cmdParms)  
         {  
             using (SqlConnection connection = new SqlConnection(connectionString))  
             {  
                 SqlCommand cmd = new SqlCommand();  
                 PrepareCommand(cmd, connection, null, SQLString, cmdParms);  
                 using (SqlDataAdapter da = new SqlDataAdapter(cmd))  
                 {  
                     DataSet ds = new DataSet();  
                     try  
                     {  
                         da.Fill(ds, "ds");  
                         cmd.Parameters.Clear();  
                     }  
                     catch (System.Data.SqlClient.SqlException ex)  
                     {  
                         throw new Exception(ex.Message);  
                     }  
                     return ds;  
                 }  
             }  
         }  
         private void PrepareCommand(SqlCommand cmd, SqlConnection conn, SqlTransaction trans, string cmdText, SqlParameter[] 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 (SqlParameter parameter in cmdParms)  
                 {  
                     if ((parameter.Direction == ParameterDirection.InputOutput || parameter.Direction == ParameterDirection.Input) &&  
                         (parameter.Value == null))  
                     {  
                         parameter.Value = DBNull.Value;  
                     }  
                     cmd.Parameters.Add(parameter);  
                 }  
             }  
         }  
         #endregion  
         #region 存儲過程操作  
         /// <summary>  
         /// 執行存儲過程，返回SqlDataReader ( 註意：調用該方法後，一定要對SqlDataReader進行Close )  
         /// </summary>  
         /// <param name="storedProcName">存儲過程名</param>  
         /// <param name="parameters">存儲過程參數</param>  
         /// <returns>SqlDataReader</returns>  
         public SqlDataReader RunProcedure(string storedProcName, IDataParameter[] parameters)  
         {  
             SqlConnection connection = new SqlConnection(connectionString);  
             SqlDataReader returnReader;  
             connection.Open();  
             SqlCommand 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 DataSet RunProcedure(string storedProcName, IDataParameter[] parameters, string tableName)  
         {  
             using (SqlConnection connection = new SqlConnection(connectionString))  
             {  
                 DataSet dataSet = new DataSet();  
                 connection.Open();  
                 SqlDataAdapter sqlDA = new SqlDataAdapter();  
                 sqlDA.SelectCommand = BuildQueryCommand(connection, storedProcName, parameters);  
                 sqlDA.Fill(dataSet, tableName);  
                 connection.Close();  
                 return dataSet;  
             }  
         }

         public DataSet RunProcedure2(string storedProcName, string tableName)
         {
             using (SqlConnection connection = new SqlConnection(connectionString))
             {
                 DataSet dataSet = new DataSet();
                 connection.Open();
                 SqlDataAdapter sqlDA = new SqlDataAdapter();
                 sqlDA.SelectCommand = BuildQueryCommand(connection, storedProcName);
                 sqlDA.Fill(dataSet, tableName);
                 connection.Close();
                 return dataSet;
             }
         }
         public DataSet RunProcedure(string storedProcName, IDataParameter[] parameters, string tableName, int Times)  
         {  
             using (SqlConnection connection = new SqlConnection(connectionString))  
             {  
                 DataSet dataSet = new DataSet();  
                 connection.Open();  
                 SqlDataAdapter sqlDA = new SqlDataAdapter();  
                 sqlDA.SelectCommand = BuildQueryCommand(connection, storedProcName, parameters);  
                 sqlDA.SelectCommand.CommandTimeout = Times;  
                 sqlDA.Fill(dataSet, tableName);  
                 connection.Close();  
                 return dataSet;  
             }  
         }  
         /// <summary>  
         /// 構建 SqlCommand 對象(用來返回一個結果集，而不是一個整數值)  
         /// </summary>  
         /// <param name="connection">資料庫連接</param>  
         /// <param name="storedProcName">存儲過程名</param>  
         /// <param name="parameters">存儲過程參數</param>  
         /// <returns>SqlCommand</returns>  
         private SqlCommand BuildQueryCommand(SqlConnection connection, string storedProcName, IDataParameter[] parameters)  
         {  
             SqlCommand command = new SqlCommand(storedProcName, connection);  
             command.CommandType = CommandType.StoredProcedure;  
             foreach (SqlParameter parameter in parameters)  
             {  
                 if (parameter != null)  
                 {  
                     // 檢查未分配值的輸出參數,將其分配以DBNull.Value.  
                     if ((parameter.Direction == ParameterDirection.InputOutput || parameter.Direction == ParameterDirection.Input) &&  
                         (parameter.Value == null))  
                     {  
                         parameter.Value = DBNull.Value;  
                     }  
                     command.Parameters.Add(parameter);  
                 }  
             }  
             return command;  
         }
         private SqlCommand BuildQueryCommand(SqlConnection connection, string storedProcName)
         {
             SqlCommand command = new SqlCommand(storedProcName, connection);
             command.CommandType = CommandType.StoredProcedure; 
             return command;
         }
         /// <summary>  
         /// 執行存儲過程，返回影響的行數        
         /// </summary>  
         /// <param name="storedProcName">存儲過程名</param>  
         /// <param name="parameters">存儲過程參數</param>  
         /// <param name="rowsAffected">影響的行數</param>  
         /// <returns></returns>  
         public int RunProcedure(string storedProcName, IDataParameter[] parameters, out int rowsAffected)  
         {  
             using (SqlConnection connection = new SqlConnection(connectionString))  
             {  
                 int result;  
                 connection.Open();  
                 SqlCommand command = BuildIntCommand(connection, storedProcName, parameters);  
                 rowsAffected = command.ExecuteNonQuery();  
                 result = (int)command.Parameters["ReturnValue"].Value;  
                 //Connection.Close();  
                 return result;  
             }  
         }
         public int RunProcedure1(string storedProcName, IDataParameter[] parameters)
         {
             //connectionString = @"DATA SOURCE=192.168.0.103,2433;UID=cdteam;PWD=cd-team2011_;DATABASE=ShiNianCMS";
             using (SqlConnection connection = new SqlConnection(connectionString))
             {
                 int result;
                 connection.Open();
                 SqlCommand command = BuildIntCommand(connection, storedProcName, parameters);
                 command.ExecuteNonQuery();
                 result = (int)command.Parameters["ReturnValue"].Value;
                 //Connection.Close();  
                 return result;
             }
         }
         public int RunProcedure3(string storedProcName)
         {
             //connectionString = @"DATA SOURCE=192.168.0.103,2433;UID=cdteam;PWD=cd-team2011_;DATABASE=ShiNianCMS";
             using (SqlConnection connection = new SqlConnection(connectionString))
             {
                 int result;
                 connection.Open();
                 SqlCommand command = BuildQueryCommand(connection, storedProcName);
                 command.ExecuteNonQuery();
                 result = (int)command.Parameters["ReturnValue"].Value;
                 //Connection.Close();  
                 return result;
             }
         }
         /// <summary>  
         /// 創建 SqlCommand 對象實例(用來返回一個整數值)     
         /// </summary>  
         /// <param name="storedProcName">存儲過程名</param>  
         /// <param name="parameters">存儲過程參數</param>  
         /// <returns>SqlCommand 對象實例</returns>  
         private SqlCommand BuildIntCommand(SqlConnection connection, string storedProcName, IDataParameter[] parameters)  
         {  
             SqlCommand command = BuildQueryCommand(connection, storedProcName, parameters);  
             command.Parameters.Add(new SqlParameter("ReturnValue",  
                 SqlDbType.Int, 4, ParameterDirection.ReturnValue,  
                 false, 0, 0, string.Empty, DataRowVersion.Default, null));  
             return command;  
         }  
         #endregion  
     }  
}

　　


您的分享是我們最大的動力!

-Advertisement-
Play Games
更多相關文章
  • RoboGuice 3.0 （一）入坑篇
    RoboGuice是什麼？ 一個Android上的依賴註入框架。 依賴註入是什麼？ 從字面理解，這個框架做了兩件事情，第一是去除依賴，第二是註入依賴。簡單理解就是，將對象的初始化委托給一個容器控制器，即去除依賴，再從容器控制器中構建依賴，註入回原本的對象中，即註入依賴。 依賴註入的好處是對象不需要在
  • 項目的維護
    現在我在做對於我們公司項目的維護，我的總體任務是 （1）拓展新功能 （2）解決bug和提升性能 （3）提高代碼的質量，主要是可維護性和可拓展性
  • Android之HTTP網路通信--GET傳遞(二)
    根據上一篇寫的是實現了通過url介面將介面中的數據顯示出來，這次根據上一篇的基礎，進一步說明一下AsynTask的使用。 AsynTask類有幾個函數是大家必須知道的。 doInBackGround() onPreExecute() onPostExecute() onProgressUpdate(
  • Android JSBridge的原理與實現
    原文出處： 安卓弟（@_安卓弟） 在Android中，JSBridge已經不是什麼新鮮的事物了，各家的實現方式也略有差異。大多數人都知道WebView存在一個漏洞，見WebView中介面隱患與手機掛馬利用，雖然該漏洞已經在Android 4.2上修複了，即使用@JavascriptInterface
  • 【入門篇】Android學習筆記——TextView
    要問Android開發中最常用的控制項是哪一個，那一定非TextView莫屬，TextView作為Android最常用的文字顯示控制項，具有簡易並且強大的特性。 首先通過一個示例看一看TextView的使用簡單到了一個什麼樣的程度，如下麵代碼……
  • 在iOS開發中如何優雅地進行圖片縮放?
    原文出處： martin_wjl(@martin_wjl) 對於圖片拉伸是移動開發中很常見的需求，在前一陣子做項目中需要做一個類似於QQ聊天氣泡，這個氣泡會根據文字的多少而變化，當時有了三種方案： 重寫drawRect方法，使用貝賽爾曲線畫一個氣泡 用一個大圖作為背景，管它怎麼拉伸，肯定不會變形 使
  • 使用Excel批量更改或插入SQL語句
    在平常中我們可以通過使用SQL批量更新或新增更新資料庫數據，對於這些都是有邏輯的數據可以這樣處理但是對於無邏輯的數據我們如何處理（這裡的數據比較多）。 我是通過Excel的方式來處理的。以下已插入為例。 第一步獲取要插入的語句獲取。 INSERT INTO dbo.Tuser( UserName,
  • 又來說一下順序~關於唯一索引和唯一約束的順序
    上次說了同一個對象裡面不同觸發器的執行順序。今天我也想分享一些我在同一個表裡面，建上不同的唯一約束，不同的唯一索引，看下結果會怎樣 首先簡單建個測試表，不多，就4列 CREATE TABLE AAA3 (ID INT IDENTITY(1,1),Col1 VARCHAR(50),Col2 VARCH
一周排行
    -Advertisement-
    Play Games
  • 移動開發（一）：使用.NET MAUI開發第一個安卓APP
    移動開發（一）：使用.NET MAUI開發第一個安卓APP 對於工作多年的C#程式員來說，近來想嘗試開發一款安卓APP，考慮了很久最終選擇使用.NET MAUI這個微軟官方的框架來嘗試體驗開發安卓APP，畢竟是使用Visual Studio開發工具，使用起來也比較的順手，結合微軟官方的教程進行了安卓 ...
  • wpf ToggleButton選中效果和一個登錄界面
    前言 QuestPDF 是一個開源 .NET 庫，用於生成 PDF 文檔。使用了C# Fluent API方式可簡化開發、減少錯誤並提高工作效率。利用它可以輕鬆生成 PDF 報告、發票、導出文件等。 項目介紹 QuestPDF 是一個革命性的開源 .NET 庫，它徹底改變了我們生成 PDF 文檔的方 ...
  • 彈幕樹洞項目功能新增篇
    項目地址 項目後端地址： https://github.com/ZyPLJ/ZYTteeHole 項目前端頁面地址： ZyPLJ/TreeHoleVue (github.com) https://github.com/ZyPLJ/TreeHoleVue 目前項目測試訪問地址： http://tree ...
  • 第27篇 sqlserver2022詳細安裝步驟
    話不多說，直接開乾 一.下載 1.官方鏈接下載： https://www.microsoft.com/zh-cn/sql-server/sql-server-downloads 2.在下載目錄中找到下麵這個小的安裝包 SQL2022-SSEI-Dev.exe，運行開始下載SQL server； 二. ...
  • .NET 開源高性能 MQTT 類庫
    前言 隨著物聯網（IoT）技術的迅猛發展，MQTT（消息隊列遙測傳輸）協議憑藉其輕量級和高效性，已成為眾多物聯網應用的首選通信標準。 MQTTnet 作為一個高性能的 .NET 開源庫，為 .NET 平臺上的 MQTT 客戶端與伺服器開發提供了強大的支持。 本文將全面介紹 MQTTnet 的核心功能 ...
  • Serilog文檔翻譯系列（六） - 可用的接收器、增強器、格式化輸出
    Serilog支持多種接收器用於日誌存儲，增強器用於添加屬性，LogContext管理動態屬性，支持多種輸出格式包括純文本、JSON及ExpressionTemplate。還提供了自定義格式化選項，適用於不同需求。 ...
  • 警惕 Visual Studio 屬性求值副作用導致邏輯不符合預期
    目錄簡介獲取 HTML 文檔解析 HTML 文檔測試參考文章 簡介 動態內容網站使用 JavaScript 腳本動態檢索和渲染數據，爬取信息時需要模擬瀏覽器行為，否則獲取到的源碼基本是空的。 本文使用的爬取步驟如下： 使用 Selenium 獲取渲染後的 HTML 文檔 使用 HtmlAgility ...
  • [使用目前最新版]HybridCLR6.9.0+YooAsset2.2.4實現純C# Unity熱更新方案 (一)
    1.前言 什麼是熱更新 游戲或者軟體更新時，無需重新下載客戶端進行安裝，而是在應用程式啟動的情況下，在內部進行資源或者代碼更新 Unity目前常用熱更新解決方案 HybridCLR，Xlua，ILRuntime等 Unity目前常用資源管理解決方案 AssetBundles，Addressable， ...
  • 在 ASP.NET Core Web API 中使用操作篩選器統一處理通用操作
    本文章主要是在C# ASP.NET Core Web API框架實現向手機發送驗證碼簡訊功能。這裡我選擇是一個互億無線簡訊驗證碼平臺，其實像阿裡雲，騰訊雲上面也可以。 首先我們先去 互億無線 https://www.ihuyi.com/api/sms.html 去註冊一個賬號 註冊完成賬號後，它會送 ...
  • 第28篇 如何.net中實現高效可靠數據同步api
    通過以下方式可以高效，並保證數據同步的可靠性 1.API設計 使用RESTful設計，確保API端點明確，並使用適當的HTTP方法（如POST用於創建，PUT用於更新）。 設計清晰的請求和響應模型，以確保客戶端能夠理解預期格式。 2.數據驗證 在伺服器端進行嚴格的數據驗證，確保接收到的數據符合預期格 ...
所有分類