[C#]實現任何數據庫類型的DbHelper幫助類使用C#建立SQLite控制檯應用程序

時間 2019-12-09

標籤 c# 實現任何數據庫類型 dbhelper 幫助使用建立 sqlite 控制檯應用程序欄目 C# 简体版

原文原文鏈接

本文章爲原創內容，如需轉載，請註明做者及出處，謝謝！html

1、在System.Data.Common命名空間下，存在這樣的一個類：sql

    //
    // 摘要:
    //     表示一組方法，這些方法用於建立提供程序對數據源類的實現的實例。
    public abstract class DbProviderFactory
    {
        //
        // 摘要:
        //     初始化 System.Data.Common.DbProviderFactory 類的新實例。
        protected DbProviderFactory();

        //
        // 摘要:
        //     指定特定的 System.Data.Common.DbProviderFactory 是否支持 System.Data.Common.DbDataSourceEnumerator
        //     類。
        //
        // 返回結果:
        //     若是 System.Data.Common.DbProviderFactory 的實例支持 System.Data.Common.DbDataSourceEnumerator
        //     類，則爲 true；不然爲 false。
        public virtual bool CanCreateDataSourceEnumerator { get; }

        //
        // 摘要:
        //     返回實現 System.Data.Common.DbCommand 類的提供程序的類的一個新實例。
        //
        // 返回結果:
        //     System.Data.Common.DbCommand 的新實例。
        public virtual DbCommand CreateCommand();
        //
        // 摘要:
        //     返回實現 System.Data.Common.DbCommandBuilder 類的提供程序的類的一個新實例。
        //
        // 返回結果:
        //     System.Data.Common.DbCommandBuilder 的新實例。
        public virtual DbCommandBuilder CreateCommandBuilder();
        //
        // 摘要:
        //     返回實現 System.Data.Common.DbConnection 類的提供程序的類的一個新實例。
        //
        // 返回結果:
        //     System.Data.Common.DbConnection 的新實例。
        public virtual DbConnection CreateConnection();
        //
        // 摘要:
        //     返回實現 System.Data.Common.DbConnectionStringBuilder 類的提供程序的類的一個新實例。
        //
        // 返回結果:
        //     System.Data.Common.DbConnectionStringBuilder 的新實例。
        public virtual DbConnectionStringBuilder CreateConnectionStringBuilder();
        //
        // 摘要:
        //     返回實現 System.Data.Common.DbDataAdapter 類的提供程序的類的一個新實例。
        //
        // 返回結果:
        //     System.Data.Common.DbDataAdapter 的新實例。
        public virtual DbDataAdapter CreateDataAdapter();
        //
        // 摘要:
        //     返回實現 System.Data.Common.DbDataSourceEnumerator 類的提供程序的類的一個新實例。
        //
        // 返回結果:
        //     System.Data.Common.DbDataSourceEnumerator 的新實例。
        public virtual DbDataSourceEnumerator CreateDataSourceEnumerator();
        //
        // 摘要:
        //     返回實現 System.Data.Common.DbParameter 類的提供程序的類的一個新實例。
        //
        // 返回結果:
        //     System.Data.Common.DbParameter 的新實例。
        public virtual DbParameter CreateParameter();
        //
        // 摘要:
        //     返回提供程序的類的新實例，該實例可實現提供程序的 System.Security.CodeAccessPermission 類的版本。
        //
        // 參數:
        //   state:
        //     System.Security.Permissions.PermissionState 值之一。
        //
        // 返回結果:
        //     指定 System.Security.Permissions.PermissionState 的 System.Security.CodeAccessPermission
        //     對象。
        public virtual CodeAccessPermission CreatePermission(PermissionState state);
    }

咱們能夠看到，在此類中，有不少用於建立數據庫相關對象的類型，如DbConnection，DbCommand，DbDataAdapter等。數據庫

並且，實現諸如SqlConnection、SqlCommand、SqlDataAdapter（這裏用的是SQL Server）的類型，都分別繼承自DbConnection，DbCommand，DbDataAdapter，數組

所以，咱們可使用DbProviderFactory來建立咱們想要的、可實現任何數據庫的DbHelper。ide

2、實現基本的DbHelper幫助類函數

一、咱們將DbHelper定義爲抽象類，並在類中提供一個抽象可讀屬性，名稱叫DbProviderFactory，返回類型爲DbProviderFactory（注：名稱與返回類型能夠爲同樣，也能夠不同），post

二、咱們利用在該抽象類實現的子類中重寫DbProviderFactory方法，並在子類的構造函數中爲該屬性賦值，該值就是已經實現了具體數據庫類型的DbProviderFactory。ui

定義的代碼參考以下：this

    public abstract class DbHelper
    {
        public abstract DbProviderFactory DbProviderFactory { get; }
    }

三、咱們爲該抽象類編寫一個構造函數，傳進去的參數爲鏈接字符串，並將其存儲在可讀的ConnectionString字段裏，代碼以下：url

    public abstract class DbHelper
    {
        public DbHelper(string connectionString)
        {
            ConnectionString = connectionString;
        }
        public string ConnectionString { get; }
        public abstract DbProviderFactory DbProviderFactory { get; }
    }

四、在DbHelper編寫一些用於實現數據庫相關操做的方法，這裏就用到了DbProviderFactory類中的方法，如下方法僅供參考，具體請參照其餘完整的DbHelp幫助類，

DbHelper完整代碼以下：

//幫助類的基類(抽象類)
    public abstract class DbHelper
    {
        public DbHelper(string connectionString)
        {
            ConnectionString = connectionString;
        }

        public abstract DbProviderFactory DbProviderFactory {  get; } 

        public string ConnectionString { get; }

        //如下實現的幫助類方法，僅供該例子使用，具體請參照其餘完整的DbHelp幫助類
        private void ThrowExceptionIfLengthNotEqual(string[] sqls, params DbParameter[][] parameters)
        {
            if (parameters.GetLength(0) != 0 && sqls.Length != parameters.GetLength(0)) throw new ArgumentException($"一維數組{nameof(sqls)}的長度與二維數組{nameof(parameters)}長度的第一維長度不一致");
        }

        private T[] Execute<T>(string[] sqls, CommandType commandType = CommandType.Text, ExecuteMode executeMode = ExecuteMode.NonQuery, params DbParameter[][] parameters)
        {
            ThrowExceptionIfLengthNotEqual(sqls, parameters);
            if(executeMode == ExecuteMode.NonQuery && typeof(T) != typeof(int)) throw new InvalidCastException("使用NonQuery模式時，必須將類型T指定爲int");
            using (DbConnection connection = DbProviderFactory.CreateConnection())
            using (DbCommand command = DbProviderFactory.CreateCommand())
            {
                connection.ConnectionString = ConnectionString;
                connection.Open();
                command.Connection = connection;
                command.CommandType = commandType;
                DbTransaction transaction = connection.BeginTransaction();
                command.Transaction = transaction;
                try
                {
                    List<T> resultList = new List<T>();
                    for (int i = 0; i < sqls.Length; i++)
                    {
                        command.CommandText = sqls[i];
                        if (parameters.GetLength(0) != 0)
                        {
                            command.Parameters.Clear();
                            command.Parameters.AddRange(parameters[i]);
                        }
                        object result = null;
                        switch (executeMode)
                        {
                            case ExecuteMode.NonQuery:
                                result = command.ExecuteNonQuery(); break;
                            case ExecuteMode.Scalar:
                                result = command.ExecuteScalar(); break;
                            default: throw new NotImplementedException();
                        }
                        resultList.Add((T)Convert.ChangeType(result, typeof(T)));
                    }
                    transaction.Commit();
                    return resultList.ToArray();
                }
                catch
                {
                    transaction.Rollback();
                    throw;
                }
            }
        }

        public int ExecuteNonQuery(string sql, params DbParameter[] parameter) => ExecuteNonQuery(new string[] { sql }, new DbParameter[][] { parameter })[0];

        public int[] ExecuteNonQuery(string[] sqls, params DbParameter[][] parameters)=> Execute<int>(sqls, CommandType.Text, ExecuteMode.NonQuery,parameters);

        public int ExecuteNonQueryWithProc(string sql, params DbParameter[] parameter) => ExecuteNonQueryWithProc(new string[] { sql },  new DbParameter[][] { parameter })[0];

        public int[] ExecuteNonQueryWithProc(string[] sqls, params DbParameter[][] parameters) => Execute<int>(sqls, CommandType.StoredProcedure, ExecuteMode.NonQuery, parameters);

        public T ExecuteScalar<T>(string sql, params DbParameter[] parameter) => ExecuteNonQuery<T>(new string[] { sql }, new DbParameter[][] { parameter })[0];

        public T[] ExecuteNonQuery<T>(string[] sqls, params DbParameter[][] parameters) => Execute<T>(sqls, CommandType.Text,ExecuteMode.Scalar, parameters);
        
        public T ExecuteScalarWithProc<T>(string sql, params DbParameter[] parameter) => ExecuteNonQuery<T>(new string[] { sql }, new DbParameter[][] { parameter })[0];
        
        public T[] ExecuteNonQueryWithProc<T>(string[] sqls, params DbParameter[][] parameters) => Execute<T>(sqls, CommandType.StoredProcedure, ExecuteMode.Scalar, parameters);
        
        enum ExecuteMode
        {
            NonQuery,Scalar
        }

        private DataTable[] Fill(string[] selectSqls, CommandType commandType = CommandType.Text, params DbParameter[][] parameters)
        {
            ThrowExceptionIfLengthNotEqual(selectSqls, parameters);
            using (DbConnection connection = DbProviderFactory.CreateConnection())
            using (DbDataAdapter adapter = DbProviderFactory.CreateDataAdapter())
            using (DbCommand command = DbProviderFactory.CreateCommand())
            {
                connection.ConnectionString = ConnectionString;
                connection.Open();
                command.Connection = connection;
                command.CommandType = commandType;
                adapter.SelectCommand = command;
                List<DataTable> resultList = new List<DataTable>();
                for (int i = 0; i < selectSqls.Length; i++)
                {
                    command.CommandText = selectSqls[i];
                    if (parameters.GetLength(0) != 0)
                    {
                        command.Parameters.Clear();
                        command.Parameters.AddRange(parameters[i]);
                    }
                    DataTable table = new DataTable();
                    adapter.Fill(table);
                    resultList.Add(table);
                }
                return resultList.ToArray();
            }
        }

        public DataTable Fill(string selectSql, params DbParameter[] parameter) => Fill(new string[] { selectSql }, new DbParameter[][] { parameter })[0];

        public DataTable[] Fill(string[] selectSqls, params DbParameter[][] parameters) => Fill(selectSqls, CommandType.Text, parameters);

        public DataTable FillWithProc(string selectSql, params DbParameter[] parameter) => FillWithProc(new string[] { selectSql }, new DbParameter[][] { parameter })[0];

        public DataTable[] FillWithProc(string[] selectSqls, params DbParameter[][] parameters) => Fill(selectSqls, CommandType.StoredProcedure, parameters);
    }

3、實現具體的數據庫幫助類

一、實現Sql Server的幫助類，具體方法：只要重寫DbHelper類的DbProviderFactory屬性並在構造函數爲其賦值便可，其餘的數據庫幫助類亦是如此，

代碼以下：

    //用於Sql Server的幫助類
    public class SqlClientHelper : DbHelper
    {
        public SqlClientHelper(string connectionString) : base(connectionString)
        {
            this.DbProviderFactory = SqlClientFactory.Instance;
        }
        public override DbProviderFactory DbProviderFactory { get; }
    }

二、參照以上，實現SQLite幫助類以下：

    //用於SQLite的幫助類
    public class SQLiteHelper : DbHelper
    {
        public SQLiteHelper(string connectionString) : base(connectionString)
        {
            DbProviderFactory = SQLiteFactory.Instance;
        }
        public override DbProviderFactory DbProviderFactory  { get; }
    }

三、其餘數據庫的幫助類，正如以上所說的，只要重寫DbHelper類的DbProviderFactory屬性並在構造函數爲其賦值便可。

4、示例演示

使用前，必須引用了System.Data.SQLite，具體請參考一下文章：

使用C#建立SQLite控制檯應用程序

編寫的客戶端代碼，以下：

    class Program
    {
        //客戶端調用
        static void Main(string[] args)
        {
            string fileName = "Test.db";
            if (File.Exists(fileName)) File.Delete(fileName);
            SQLiteConnection.CreateFile(fileName);
            SQLiteHelper helper = new SQLiteHelper($"Data Source = {fileName}");
            helper.ExecuteNonQuery("CREATE TABLE IF NOT EXISTS Info(ID integer PRIMARY KEY AUTOINCREMENT, Guid text)");
            List<string> sqlList = new List<string>();
            for (int i = 0; i < 1000; i++)
            {
                sqlList.Add($"INSERT INTO Info VALUES(null,'{Guid.NewGuid()}')");
            }
            helper.ExecuteNonQuery(sqlList.ToArray());
            DataTable table = helper.Fill("SELECT * FROM Info");
            table.Rows.Cast<DataRow>().ToList().ForEach(x => Console.WriteLine($"{x[0]}\t{x[1]}"));
            Console.ReadKey();
        }
    }

輸出的結果以下：

5、完整代碼以下：

using System;
using System.Linq;
using System.Collections.Generic;
using System.Data;
using System.Data.Common;
using System.Data.SqlClient;
using System.Data.SQLite;
using System.IO;

namespace ConsoleApp
{
    class Program
    {
        //客戶端調用
        static void Main(string[] args)
        {
            string fileName = "Test.db";
            if (File.Exists(fileName)) File.Delete(fileName);
            SQLiteConnection.CreateFile(fileName);
            SQLiteHelper helper = new SQLiteHelper($"Data Source = {fileName}");
            helper.ExecuteNonQuery("CREATE TABLE IF NOT EXISTS Info(ID integer PRIMARY KEY AUTOINCREMENT, Guid text)");
            List<string> sqlList = new List<string>();
            for (int i = 0; i < 1000; i++)
            {
                sqlList.Add($"INSERT INTO Info VALUES(null,'{Guid.NewGuid()}')");
            }
            helper.ExecuteNonQuery(sqlList.ToArray());
            DataTable table = helper.Fill("SELECT * FROM Info");
            table.Rows.Cast<DataRow>().ToList().ForEach(x => Console.WriteLine($"{x[0]}\t{x[1]}"));
            Console.ReadKey();
        }
    }

    //用於Sql Server的幫助類
    public class SqlClientHelper : DbHelper
    {
        public SqlClientHelper(string connectionString) : base(connectionString)
        {
            this.DbProviderFactory = SqlClientFactory.Instance;
        }
        public override DbProviderFactory DbProviderFactory { get; }
    }

    //用於SQLite的幫助類
    public class SQLiteHelper : DbHelper
    {
        public SQLiteHelper(string connectionString) : base(connectionString)
        {
            DbProviderFactory = SQLiteFactory.Instance;
        }
        public override DbProviderFactory DbProviderFactory  { get; }
    }

    //--------------------------------------------------------------------------------
    //其餘數據庫的幫助類，只要重寫DbHelper類的DbProviderFactory屬性並在構造函數爲其賦值便可
    //--------------------------------------------------------------------------------

    //幫助類的基類(抽象類)
    public abstract class DbHelper
    {
        public DbHelper(string connectionString)
        {
            ConnectionString = connectionString;
        }

        public abstract DbProviderFactory DbProviderFactory {  get; } 

        public string ConnectionString { get; }

        //如下實現的幫助類方法，僅供該例子使用，具體請參照其餘完整的DbHelp幫助類
        private void ThrowExceptionIfLengthNotEqual(string[] sqls, params DbParameter[][] parameters)
        {
            if (parameters.GetLength(0) != 0 && sqls.Length != parameters.GetLength(0)) throw new ArgumentException($"一維數組{nameof(sqls)}的長度與二維數組{nameof(parameters)}長度的第一維長度不一致");
        }

        private T[] Execute<T>(string[] sqls, CommandType commandType = CommandType.Text, ExecuteMode executeMode = ExecuteMode.NonQuery, params DbParameter[][] parameters)
        {
            ThrowExceptionIfLengthNotEqual(sqls, parameters);
            if(executeMode == ExecuteMode.NonQuery && typeof(T) != typeof(int)) throw new InvalidCastException("使用NonQuery模式時，必須將類型T指定爲int");
            using (DbConnection connection = DbProviderFactory.CreateConnection())
            using (DbCommand command = DbProviderFactory.CreateCommand())
            {
                connection.ConnectionString = ConnectionString;
                connection.Open();
                command.Connection = connection;
                command.CommandType = commandType;
                DbTransaction transaction = connection.BeginTransaction();
                command.Transaction = transaction;
                try
                {
                    List<T> resultList = new List<T>();
                    for (int i = 0; i < sqls.Length; i++)
                    {
                        command.CommandText = sqls[i];
                        if (parameters.GetLength(0) != 0)
                        {
                            command.Parameters.Clear();
                            command.Parameters.AddRange(parameters[i]);
                        }
                        object result = null;
                        switch (executeMode)
                        {
                            case ExecuteMode.NonQuery:
                                result = command.ExecuteNonQuery(); break;
                            case ExecuteMode.Scalar:
                                result = command.ExecuteScalar(); break;
                            default: throw new NotImplementedException();
                        }
                        resultList.Add((T)Convert.ChangeType(result, typeof(T)));
                    }
                    transaction.Commit();
                    return resultList.ToArray();
                }
                catch
                {
                    transaction.Rollback();
                    throw;
                }
            }
        }

        public int ExecuteNonQuery(string sql, params DbParameter[] parameter) => ExecuteNonQuery(new string[] { sql }, new DbParameter[][] { parameter })[0];

        public int[] ExecuteNonQuery(string[] sqls, params DbParameter[][] parameters)=> Execute<int>(sqls, CommandType.Text, ExecuteMode.NonQuery,parameters);

        public int ExecuteNonQueryWithProc(string sql, params DbParameter[] parameter) => ExecuteNonQueryWithProc(new string[] { sql },  new DbParameter[][] { parameter })[0];

        public int[] ExecuteNonQueryWithProc(string[] sqls, params DbParameter[][] parameters) => Execute<int>(sqls, CommandType.StoredProcedure, ExecuteMode.NonQuery, parameters);

        public T ExecuteScalar<T>(string sql, params DbParameter[] parameter) => ExecuteNonQuery<T>(new string[] { sql }, new DbParameter[][] { parameter })[0];

        public T[] ExecuteNonQuery<T>(string[] sqls, params DbParameter[][] parameters) => Execute<T>(sqls, CommandType.Text,ExecuteMode.Scalar, parameters);
        
        public T ExecuteScalarWithProc<T>(string sql, params DbParameter[] parameter) => ExecuteNonQuery<T>(new string[] { sql }, new DbParameter[][] { parameter })[0];
        
        public T[] ExecuteNonQueryWithProc<T>(string[] sqls, params DbParameter[][] parameters) => Execute<T>(sqls, CommandType.StoredProcedure, ExecuteMode.Scalar, parameters);
        
        enum ExecuteMode
        {
            NonQuery,Scalar
        }

        private DataTable[] Fill(string[] selectSqls, CommandType commandType = CommandType.Text, params DbParameter[][] parameters)
        {
            ThrowExceptionIfLengthNotEqual(selectSqls, parameters);
            using (DbConnection connection = DbProviderFactory.CreateConnection())
            using (DbDataAdapter adapter = DbProviderFactory.CreateDataAdapter())
            using (DbCommand command = DbProviderFactory.CreateCommand())
            {
                connection.ConnectionString = ConnectionString;
                connection.Open();
                command.Connection = connection;
                command.CommandType = commandType;
                adapter.SelectCommand = command;
                List<DataTable> resultList = new List<DataTable>();
                for (int i = 0; i < selectSqls.Length; i++)
                {
                    command.CommandText = selectSqls[i];
                    if (parameters.GetLength(0) != 0)
                    {
                        command.Parameters.Clear();
                        command.Parameters.AddRange(parameters[i]);
                    }
                    DataTable table = new DataTable();
                    adapter.Fill(table);
                    resultList.Add(table);
                }
                return resultList.ToArray();
            }
        }

        public DataTable Fill(string selectSql, params DbParameter[] parameter) => Fill(new string[] { selectSql }, new DbParameter[][] { parameter })[0];

        public DataTable[] Fill(string[] selectSqls, params DbParameter[][] parameters) => Fill(selectSqls, CommandType.Text, parameters);

        public DataTable FillWithProc(string selectSql, params DbParameter[] parameter) => FillWithProc(new string[] { selectSql }, new DbParameter[][] { parameter })[0];

        public DataTable[] FillWithProc(string[] selectSqls, params DbParameter[][] parameters) => Fill(selectSqls, CommandType.StoredProcedure, parameters);
    }
}