用C#实现的数据库抽象工厂(全)

最新推荐文章于 2024-07-23 17:52:34 发布
最新推荐文章于 2024-07-23 17:52:34 发布
阅读量1.5k 收藏
点赞数
分类专栏： 软件工程 文章标签： 数据库 c# string dataset sqlserver command

     最近学习了一下设计模式，便尝试用C#对数据库的访问操作采用抽象工厂的模式实现一下，其中与标准的模式略有不同，加入了一些自己的想法，希望大家批评指正，代码共分为6个类：

(1)AbstractDbFactory.cs

using System;
using System.Data;

namespace DbService
{
    /// <summary>
    /// 数据库抽象工厂接口
    /// </summary>
    public interface AbstractDbFactory
    {
        /// <summary>
        /// 建立默认连接
        /// </summary>
        /// <returns>数据库连接</returns>
        IDbConnection CreateConnection();

        /// <summary>
        /// 根据连接字符串建立Connection对象
        /// </summary>
        /// <param name="strConn">连接字符串</param>
        /// <returns>Connection对象</returns>
        IDbConnection CreateConnection(string strConn);

        /// <summary>
        /// 建立Command对象
        /// </summary>
        /// <returns>Command对象</returns>
        IDbCommand CreateCommand();

        /// <summary>
        /// 建立DataAdapter对象
        /// </summary>
        /// <returns>DataAdapter对象</returns>
        IDbDataAdapter CreateDataAdapter();

        /// <summary>
        /// 根据Connection建立Transaction
        /// </summary>
        /// <param name="myDbConnection">Connection对象</param>
        /// <returns>Transaction对象</returns>
        IDbTransaction CreateTransaction(IDbConnection myDbConnection);

        /// <summary>
        /// 根据Command建立DataReader
        /// </summary>
        /// <param name="myDbCommand">Command对象</param>
        /// <returns>DataReader对象</returns>
        IDataReader CreateDataReader(IDbCommand myDbCommand);

        /// <summary>
        /// 获得连接字符串
        /// </summary>
        /// <returns>连接字符串</returns>
        string GetConnectionString();
    }
}

(2)Factory.cs

using System;
using System.Configuration;

namespace DbService
{
    /// <summary>
    /// Factory类
    /// </summary>
    public sealed class Factory
    {
        private static volatile Factory singleFactory = null;
        private static object syncObj = new object();
        
        /// <summary>
        /// Factory类构造函数
        /// </summary>
        private Factory()
        {
        }

        /// <summary>
        /// 获得Factory类的实例
        /// </summary>
        /// <returns>Factory类实例</returns>
        public static Factory GetInstance()
        {
            if(singleFactory == null)
            {
                lock(syncObj)
                {
                    if(singleFactory == null)
                    {
                        singleFactory = new Factory();
                    }
                }
            }
            return singleFactory;
        }

        /// <summary>
        /// 建立Factory类实例
        /// </summary>
        /// <returns>Factory类实例</returns>
        public AbstractDbFactory CreateInstance()
        {
            AbstractDbFactory abstractDbFactory = null;
            switch(ConfigurationSettings.AppSettings["DatabaseType"].ToLower())
            {
                case "sqlserver":
                {
                    abstractDbFactory = new SqlFactory();
                    break;
                }
                case "oledb":
                {
                    abstractDbFactory = new OleDbFactory();
                    break;
                }
                case "odbc":
                {
                    abstractDbFactory = new OdbcFactory();
                    break;
                }
            }   
            return abstractDbFactory;
        }
    }
}

     以下3个类分别是Factory针对SqlServer专用连接、OleDb连接和Odbc连接时的具体实现：

(3)SqlFactory.cs

using System;
using System.Data;
using System.Data.SqlClient;
using System.Configuration;

namespace DbService
{
    /// <summary>
    /// 针对SqlServer专用连接的工厂
    /// </summary>
    public class SqlFactory : AbstractDbFactory
    {
        /// <summary>
        /// 构造函数
        /// </summary>
        public SqlFactory()
        {
        }

        /// <summary>
        /// 建立默认Connection对象
        /// </summary>
        /// <returns>Connection对象</returns>
        public IDbConnection CreateConnection()
        {
            return new SqlConnection();
        }

        /// <summary>
        /// 根据连接字符串建立Connection对象
        /// </summary>
        /// <param name="strConn">连接字符串</param>
        /// <returns>Connection对象</returns>
        public IDbConnection CreateConnection(string strConn)
        {
            return new SqlConnection(strConn);
        }

        /// <summary>
        /// 建立Command对象
        /// </summary>
        /// <returns>Command对象</returns>
        public IDbCommand CreateCommand()
        {
            return new SqlCommand();
        }

        /// <summary>
        /// 建立DataAdapter对象
        /// </summary>
        /// <returns>DataAdapter对象</returns>
        public IDbDataAdapter CreateDataAdapter()
        {
            return new SqlDataAdapter();
        }

        /// <summary>
        /// 根据Connection建立Transaction
        /// </summary>
        /// <param name="myDbConnection">Connection对象</param>
        /// <returns>Transaction对象</returns>
        public IDbTransaction CreateTransaction(IDbConnection myDbConnection)
        {
            return myDbConnection.BeginTransaction();
        }

        /// <summary>
        /// 根据Command建立DataReader
        /// </summary>
        /// <param name="myDbCommand">Command对象</param>
        /// <returns>DataReader对象</returns>
        public IDataReader CreateDataReader(IDbCommand myDbCommand)
        {
            return myDbCommand.ExecuteReader();
        }

        /// <summary>
        /// 获得连接字符串
        /// </summary>
        /// <returns>连接字符串</returns>
        public string GetConnectionString()
        {
            string strServer = ConfigurationSettings.AppSettings["SqlServerServer"];
            string strDatabase = ConfigurationSettings.AppSettings["SqlServerDatabase"];
            string strUid = ConfigurationSettings.AppSettings["SqlServerUid"];
            string strPwd = ConfigurationSettings.AppSettings["SqlServerPwd"];
            string strConnectionString = "Server = " + strServer + "; Database = " + strDatabase + "; Uid = " + strUid + "; Pwd = " + strPwd + ";";
            return strConnectionString;
        }
    }
}

(4)OleDbFactory.cs

using System;
using System.Data;
using System.Data.OleDb;
using System.Configuration;

namespace DbService
{
    /// <summary>
    /// 针对OleDb连接的工厂
    /// </summary>
    public class OleDbFactory : AbstractDbFactory
    {
        /// <summary>
        /// 构造函数
        /// </summary>
        public OleDbFactory()
        {
        }

        /// <summary>
        /// 建立默认Connection对象
        /// </summary>
        /// <returns>Connection对象</returns>
        public IDbConnection CreateConnection()
        {
            return new OleDbConnection();
        }

        /// <summary>
        /// 根据连接字符串建立Connection对象
        /// </summary>
        /// <param name="strConn">连接字符串</param>
        /// <returns>Connection对象</returns>
        public IDbConnection CreateConnection(string strConn)
        {
            return new OleDbConnection(strConn);
        }

        /// <summary>
        /// 建立Command对象
        /// </summary>
        /// <returns>Command对象</returns>
        public IDbCommand CreateCommand()
        {
            return new OleDbCommand();
        }

        /// <summary>
        /// 建立DataAdapter对象
        /// </summary>
        /// <returns>DataAdapter对象</returns>
        public IDbDataAdapter CreateDataAdapter()
        {
            return new OleDbDataAdapter();
        }

        /// <summary>
        /// 根据Connection建立Transaction
        /// </summary>
        /// <param name="myDbConnection">Connection对象</param>
        /// <returns>Transaction对象</returns>
        public IDbTransaction CreateTransaction(IDbConnection myDbConnection)
        {
            return myDbConnection.BeginTransaction();   
        }

        /// <summary>
        /// 根据Command建立DataReader
        /// </summary>
        /// <param name="myDbCommand">Command对象</param>
        /// <returns>DataReader对象</returns>
        public IDataReader CreateDataReader(IDbCommand myDbCommand)
        {
            return myDbCommand.ExecuteReader();
        }

        /// <summary>
        /// 获得连接字符串
        /// </summary>
        /// <returns>连接字符串</returns>
        public string GetConnectionString()
        {
            string strProvider = ConfigurationSettings.AppSettings["OleDbProvider"];
            string strDataSource = ConfigurationSettings.AppSettings["OleDbDataSource"];
            string strConnectionString = "Provider = " + strProvider + ";Data Source = " + strDataSource + ";";
            return strConnectionString;
        }
    }
}

(5)OdbcFactory.cs

using System;
using System.Data;
using System.Data.Odbc;
using System.Configuration;

namespace DbService
{
    /// <summary>
    /// 针对Odbc连接的工厂
    /// </summary>
    public class OdbcFactory : AbstractDbFactory
    {
        /// <summary>
        /// 构造函数
        /// </summary>
        public OdbcFactory()
        {
        }

        /// <summary>
        /// 建立默认Connection对象
        /// </summary>
        /// <returns>Connection对象</returns>
        public IDbConnection CreateConnection()
        {
            return new OdbcConnection();
        }

        /// <summary>
        /// 根据连接字符串建立Connection对象
        /// </summary>
        /// <param name="strConn">连接字符串</param>
        /// <returns>Connection对象</returns>
        public IDbConnection CreateConnection(string strConn)
        {
            return new OdbcConnection(strConn);
        }

        /// <summary>
        /// 建立Command对象
        /// </summary>
        /// <returns>Command对象</returns>
        public IDbCommand CreateCommand()
        {
            return new OdbcCommand();
        }

        /// <summary>
        /// 建立DataAdapter对象
        /// </summary>
        /// <returns>DataAdapter对象</returns>
        public IDbDataAdapter CreateDataAdapter()
        {
            return new OdbcDataAdapter();
        }

        /// <summary>
        /// 根据Connection建立Transaction
        /// </summary>
        /// <param name="myDbConnection">Connection对象</param>
        /// <returns>Transaction对象</returns>
        public IDbTransaction CreateTransaction(IDbConnection myDbConnection)
        {
            return myDbConnection.BeginTransaction();
        }

        /// <summary>
        /// 根据Command建立DataReader
        /// </summary>
        /// <param name="myDbCommand">Command对象</param>
        /// <returns>DataReader对象</returns>
        public IDataReader CreateDataReader(IDbCommand myDbCommand)
        {
            return myDbCommand.ExecuteReader();
        }

        /// <summary>
        /// 获得连接字符串
        /// </summary>
        /// <returns></returns>
        public string GetConnectionString()
        {
            string strDriver = ConfigurationSettings.AppSettings["OdbcDriver"];
            string strDBQ = ConfigurationSettings.AppSettings["OdbcDBQ"];
            string strConnectionString = "Driver={" + strDriver + "}; DBQ=" + strDBQ + ";";
            return strConnectionString;   
        }
    }
}

 

用C#实现的数据库抽象工厂(三)

     以下是在应用时真正要调用到的类：

(6)DbAccess.cs

using System;
using System.Data;

namespace DbService
{
    /// <summary>
    /// DbAccess类,即进行数据库访问时需要调用的类
    /// </summary>
    public sealed class DbAccess
    {
        /// <summary>
        /// DbAccess构造函数
        /// </summary>
        private DbAccess()
        {
        }

        /// <summary>
        /// 无条件查询操作,即查询表中所有记录
        /// </summary>
        /// <param name="strTableName">表名</param>
        /// <param name="strColumn">列名组</param>
        /// <returns>无条件查询结果</returns>
        public static DataSet SelectAll(string strTableName, string[] strColumn)
        {
            DataSet ds = new DataSet();
            Factory factory = Factory.GetInstance();
            AbstractDbFactory abstractDbFactory = factory.CreateInstance();
            IDbConnection concreteDbConn = abstractDbFactory.CreateConnection();
            concreteDbConn.ConnectionString = abstractDbFactory.GetConnectionString();
            concreteDbConn.Open();
            IDbCommand concreteDbCommand = abstractDbFactory.CreateCommand();
            IDbTransaction concreteDbTrans = abstractDbFactory.CreateTransaction(concreteDbConn);
            concreteDbCommand.Connection = concreteDbConn;
            concreteDbCommand.Transaction = concreteDbTrans;
            IDbDataAdapter concreteDbAdapter = abstractDbFactory.CreateDataAdapter();
            try
            {
                string strSql = "SELECT ";
                for(int i = 0; i < strColumn.Length - 1; i++)
                {
                    strSql += (strColumn[i] + ", ");
                }
                strSql += (strColumn[strColumn.Length - 1] + " FROM " + strTableName);
                concreteDbCommand.CommandText = strSql;
                concreteDbAdapter.SelectCommand = concreteDbCommand;    
                concreteDbAdapter.Fill(ds);
                concreteDbTrans.Commit();
            }
            catch
            {
                concreteDbTrans.Rollback();
                ds.Clear();
                throw;
            }
            finally
            {
                concreteDbConn.Close();
            }  
            return ds;
        }

        /// <summary>
        /// 条件查询操作
        /// </summary>
        /// <param name="strTableName">表名</param>
        /// <param name="strColumn">列名组</param>
        /// <param name="strCondition">条件</param>
        /// <returns>条件查询结果</returns>
        public static DataSet Select(string strTableName, string[] strColumn, string strCondition)
        {
            DataSet ds = new DataSet();
            Factory factory = Factory.GetInstance();
            AbstractDbFactory abstractDbFactory = factory.CreateInstance();
            IDbConnection concreteDbConn = abstractDbFactory.CreateConnection();
            concreteDbConn.ConnectionString = abstractDbFactory.GetConnectionString();
            concreteDbConn.Open();
            IDbCommand concreteDbCommand = abstractDbFactory.CreateCommand();
            IDbTransaction concreteDbTrans = abstractDbFactory.CreateTransaction(concreteDbConn);
            concreteDbCommand.Connection = concreteDbConn;
            concreteDbCommand.Transaction = concreteDbTrans;
            IDbDataAdapter concreteDbAdapter = abstractDbFactory.CreateDataAdapter();
            try
            {
                string strSql = "SELECT ";
                for(int i = 0; i < strColumn.Length - 1; i++)
                {
                    strSql += (strColumn[i] + ", ");
                }
                strSql += (strColumn[strColumn.Length - 1] + " FROM " + strTableName + " WHERE " + strCondition);
                concreteDbCommand.CommandText = strSql;
                concreteDbAdapter.SelectCommand = concreteDbCommand;    
                concreteDbAdapter.Fill(ds);
                concreteDbTrans.Commit();
            }
            catch
            {
                concreteDbTrans.Rollback();
                ds.Clear();
                throw;
            }
            finally
            {
                concreteDbConn.Close();
            }
            return ds;
        }

        /// <summary>
        /// 单条记录的插入操作
        /// </summary>
        /// <param name="strTableName">表名</param>
        /// <param name="strColumn">列名组</param>
        /// <param name="strValue">值组</param>
        public static void Insert(string strTableName, string[] strColumn, object[] strValue)
        {
            Factory factory = Factory.GetInstance();
            AbstractDbFactory abstractDbFactory = factory.CreateInstance();
            IDbConnection concreteDbConn = abstractDbFactory.CreateConnection();
            concreteDbConn.ConnectionString = abstractDbFactory.GetConnectionString();   
            concreteDbConn.Open();
            IDbCommand concreteDbCommand = abstractDbFactory.CreateCommand();
            IDbTransaction concreteDbTrans = abstractDbFactory.CreateTransaction(concreteDbConn);
            concreteDbCommand.Connection = concreteDbConn;
            concreteDbCommand.Transaction = concreteDbTrans;
            try
            {
                string strSql = "INSERT INTO " + strTableName + " (";
                for(int i = 0; i < strColumn.Length - 1; i++)
                {
                    strSql += (strColumn[i] + ", ");
                }
                strSql += (strColumn[strColumn.Length - 1] + ") VALUES ('");
                for(int i = 0; i < strValue.Length - 1; i++)
                {
                    strSql += (strValue[i] + "', '");
                }
                strSql += (strValue[strValue.Length - 1] + "')");
                concreteDbCommand.CommandText = strSql;
                concreteDbCommand.ExecuteNonQuery();
                concreteDbTrans.Commit();
            }
            catch
            {
                concreteDbTrans.Rollback();
                throw;
            }
            finally
            {
                concreteDbConn.Close();
            }   
        }

        /// <summary>
        /// 批量记录的插入操作,即可一次向多张表中插入不同的批量记录
        /// </summary>
        /// <param name="ds">批量记录组成的DataSet,DataSet中的各个DataTable名为表名,各DataTable中的DataColumn名为列名</param>
        public static void InsertSet(ref DataSet ds)
        {
            Factory factory = Factory.GetInstance();
            AbstractDbFactory abstractDbFactory = factory.CreateInstance();
            IDbConnection concreteDbConn = abstractDbFactory.CreateConnection();
            concreteDbConn.ConnectionString = abstractDbFactory.GetConnectionString();   
            concreteDbConn.Open();
            IDbCommand concreteDbCommand = abstractDbFactory.CreateCommand();
            IDbTransaction concreteDbTrans = abstractDbFactory.CreateTransaction(concreteDbConn);
            concreteDbCommand.Connection = concreteDbConn;
            concreteDbCommand.Transaction = concreteDbTrans;
            try
            {
                foreach(DataTable dt in ds.Tables)
                {
                    foreach(DataRow dr in dt.Rows)
                    {
                        string strSql = "INSERT INTO " + dt.TableName + " (";
                        for(int i = 0; i < dt.Columns.Count - 1; i++)
                        {
                            strSql += (dt.Columns[i].Caption + ", ");
                        }
                        strSql += (dt.Columns[dt.Columns.Count - 1].Caption + ") VALUES ('");
                        for(int i = 0; i < dt.Columns.Count - 1; i++)
                        {
                            strSql += (dr[i] + "', '");
                        }
                        strSql += (dr[dt.Columns.Count - 1] + "')");
                        concreteDbCommand.CommandText = strSql;
                        concreteDbCommand.ExecuteNonQuery();
                    }
                }
                concreteDbTrans.Commit();
            }

            catch
            {
                concreteDbTrans.Rollback();
                throw;
            }

            finally
            {
                concreteDbConn.Close();
            }   
        }

        /// <summary>
        /// 无条件删除操作,即删除表中所有记录
        /// </summary>
        /// <param name="strTableName">表名</param>
        public static void DeleteAll(string strTableName)
        {
            Factory factory = Factory.GetInstance();
            AbstractDbFactory abstractDbFactory = factory.CreateInstance();
            IDbConnection concreteDbConn = abstractDbFactory.CreateConnection();
            concreteDbConn.ConnectionString = abstractDbFactory.GetConnectionString();
            concreteDbConn.Open();
            IDbCommand concreteDbCommand = abstractDbFactory.CreateCommand();
            IDbTransaction concreteDbTrans = abstractDbFactory.CreateTransaction(concreteDbConn);
            concreteDbCommand.Connection = concreteDbConn;
            concreteDbCommand.Transaction = concreteDbTrans;
            try
            {
                string strSql = "DELETE FROM " + strTableName;
                concreteDbCommand.CommandText = strSql;
                concreteDbCommand.ExecuteNonQuery();
                concreteDbTrans.Commit();
            }
            catch
            {
                concreteDbTrans.Rollback();
                throw;
            }
            finally
            {
                concreteDbConn.Close();
            }   
        }

        /// <summary>
        /// 条件删除操作
        /// </summary>
        /// <param name="strTableName">表名</param>
        /// <param name="strCondition">条件</param>
        public static void Delete(string strTableName, string strCondition)
        {
            Factory factory = Factory.GetInstance();
            AbstractDbFactory abstractDbFactory = factory.CreateInstance();
            IDbConnection concreteDbConn = abstractDbFactory.CreateConnection();
            concreteDbConn.ConnectionString = abstractDbFactory.GetConnectionString();
            concreteDbConn.Open();
            IDbCommand concreteDbCommand = abstractDbFactory.CreateCommand();
            IDbTransaction concreteDbTrans = abstractDbFactory.CreateTransaction(concreteDbConn);
            concreteDbCommand.Connection = concreteDbConn;
            concreteDbCommand.Transaction = concreteDbTrans;
            try
            {
                string strSql = "DELETE FROM " + strTableName + " WHERE " + strCondition;
                concreteDbCommand.CommandText = strSql;
                concreteDbCommand.ExecuteNonQuery();
                concreteDbTrans.Commit();
            }
            catch
            {
                concreteDbTrans.Rollback();
                throw;
            }
            finally
            {
                concreteDbConn.Close();
            }   
        }

        /// <summary>
        /// 无条件更新操作,即更新表中所有记录
        /// </summary>
        /// <param name="strTableName">表名</param>
        /// <param name="strColumn">列名组</param>
        /// <param name="strValue">值组</param>
        public static void UpdateAll(string strTableName, string[] strColumn, object[] strValue)
        {
            Factory factory = Factory.GetInstance();
            AbstractDbFactory abstractDbFactory = factory.CreateInstance();   
            IDbConnection concreteDbConn = abstractDbFactory.CreateConnection();
            concreteDbConn.ConnectionString = abstractDbFactory.GetConnectionString();
            concreteDbConn.Open();
            IDbCommand concreteDbCommand = abstractDbFactory.CreateCommand();
            IDbTransaction concreteDbTrans = abstractDbFactory.CreateTransaction(concreteDbConn);
            concreteDbCommand.Connection = concreteDbConn;
            concreteDbCommand.Transaction = concreteDbTrans;
            try
            {
                string strSql = "UPDATE " + strTableName + " SET ";
                for(int i = 0; i < strColumn.Length - 1; i++)
                {
                    strSql += (strColumn[i] + " = '" + strValue[i] + "', ");
                }
                strSql += (strColumn[strColumn.Length - 1] + " = '" + strValue[strValue.Length - 1] + "' ");
                concreteDbCommand.CommandText = strSql;
                concreteDbCommand.ExecuteNonQuery();
                concreteDbTrans.Commit();
            }
            catch
            {
                concreteDbTrans.Rollback();
                throw;
            }
            finally
            {
                concreteDbConn.Close();
            }
        }

        /// <summary>
        /// 条件更新操作
        /// </summary>
        /// <param name="strTableName">表名</param>
        /// <param name="strColumn">列名组</param>
        /// <param name="strValue">值组</param>
        /// <param name="strCondition">条件</param>
        public static void Update(string strTableName, string[] strColumn, object[] strValue, string strCondition)
        {
            Factory factory = Factory.GetInstance();
            AbstractDbFactory abstractDbFactory = factory.CreateInstance();   
            IDbConnection concreteDbConn = abstractDbFactory.CreateConnection();
            concreteDbConn.ConnectionString = abstractDbFactory.GetConnectionString();
            concreteDbConn.Open();
            IDbCommand concreteDbCommand = abstractDbFactory.CreateCommand();
            IDbTransaction concreteDbTrans = abstractDbFactory.CreateTransaction(concreteDbConn);
            concreteDbCommand.Connection = concreteDbConn;
            concreteDbCommand.Transaction = concreteDbTrans;
            try
            {
                string strSql = "UPDATE " + strTableName + " SET ";
                for(int i = 0; i < strColumn.Length - 1; i++)
                {
                    strSql += (strColumn[i] + " = '" + strValue[i] + "', ");
                }
                strSql += (strColumn[strColumn.Length - 1] + " = '" + strValue[strValue.Length - 1] + "' " + " WHERE " + strCondition);
                concreteDbCommand.CommandText = strSql;
                concreteDbCommand.ExecuteNonQuery();
                concreteDbTrans.Commit();
            }
            catch
            {
                concreteDbTrans.Rollback();
                throw;
            }
            finally
            {
                concreteDbConn.Close();
            }
        }
    }
}

最后一步，在Web.config中的根结点configuration下增加一些关于数据库连接字符串的变量：

<appSettings>
 
    <add key="DatabaseType" value="SqlServer" />
 
    <add key="SqlServerServer" value="Ricky" />
    <add key="SqlServerDatabase" value="test" />
    <add key="SqlServerUid" value="sa" />
    <add key="SqlServerPwd" value="henhaoba" />
 
    <add key="OleDbProvider" value="Microsoft.jet.oledb.4.0" />
    <add key="OleDbDataSource" value="D:/test.mdb" />
 
    <add key="OdbcDriver" value="Microsoft Access Driver (*.mdb)" />
    <add key="OdbcDBQ" value="d:/test.mdb" />
      
</appSettings>

     现在一切OK，大家可以通过改变Web.config中的变量来使用不同的数据库连接方式(SqlServer专用连接、OleDb连接和Odbc连接)连接不同的数据库，同时整个使用仍通过DbAccess，不受任何影响。欢迎大家批评指正!
flyingyoko1983
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
C#数据库工厂模式的实现
神赐书宝的专栏
06-04 6650
一、数据库工厂模式介绍 网上搜索下，有很多关于数据库工厂模式的资料，在这边提供个人对数据库工厂模式的理解，我认为的数据库工厂是这样的：把对数据库的操作组件交给工厂去做，而调用方不必知道需要调用什么组件来操作特定的数据库。比如：IDbConnection （数据库连接对象）、IDbCommand (Command对象)、IDbDataAdapter( 数据适配器对象)、IDbTransaction
C#优秀数据库操作底层，用工厂实现
01-22
C#优秀数据库操作底层，用工厂实现,里面包含一个接口，以及一个MSSQL，在现实中，应用在日访问量达到1000多WPV，并发数很高的时候，效能也不错
C#工厂模式多数据库(实现SQL和MYSQL的切换)
05-17
利用C#工厂模式实现ASP>NET下的多数据库切换问题，代码的简单实现
C# 工厂模式
生如夏花
04-09 1492
using System; namespace Factory { class Program { static void Main(string[] args) { //工厂模式，通过不同的工厂来创建对象，避免了臃肿的选择结构 //增加新的鼠标，只需要创建新的厂就行了。扩展而不是修改 ...
C#中的数据库访问工厂
似水流年
07-30 1944
C#已经自己为不同类型数据库的访问做了一个工厂。 首先是配置文件：其中的providerName就是指定的不同数据库类型 　　　　 　　　　 　　 　　下面看一下使用工厂的这个类： 　　 class DataBaseFac 　　{ 　　　　private DbConnection cnn;//抽象类型 　　　　private DbCommand cmd;//抽象类型
用C#实现的数据库抽象工厂(一)
虎啸博客
05-23 782
用C#实现的数据库抽象工厂(一)最近学习了一下设计模式，便尝试用C#对数据库的访问操作采用抽象工厂的模式实现一下，其中与标准的模式略有不同，加入了一些自己的想法，希望大家批评指正，代码共分为6个类：(1)AbstractDbFactory.csusing System;using System.Data;namespace DbService{ ///  /// 数据库抽象工厂接口 ///  
数据库连接工厂 - 抽象工厂的应用（C#）
&*焰火*&天堂
11-25 1513
也许很多人都有和我一样的经验，客户的数据库管理系统可能暂时没有定下来，或者是 受服务器的限制，在项目快进行完时需要更换DBMS。由于我们的系统中大量的存在数据库连接，如果类设计不恰当的话，造成数据库连接和其他逻辑的紧耦合，在更改DBMS时就会有很大的麻烦。我们几乎要搜索遍程序的每一个角落。设计模式里有一种很好的解决方案：把数据库连接做成一个抽象工厂（IDbFactory），每种具体的数据库接口
用C#实现的数据库抽象工厂
09-21
数据库抽象工厂模式是设计模式中的一种常见模式，旨在提供一种灵活的方式来访问数据库。使用抽象工厂模式可以使数据库...使用C#实现的数据库抽象工厂模式可以带来许多好处，例如提高系统的灵活性、可维护性和可靠性等。
抽象工厂Factory C# 数据库切换设计模式
10-13
本人做了一个抽象工厂的小案例,只要修改配置文件,就可以轻松的切换数据库,里面附有ACCESS数据库，不需要配置 sql数据库附加上去就好了,修改配置连接 就可以轻松切换 数据库 如有问题请联系qimenglin_aptech@163.com ...
C#数据库编程抽象工厂
11-06
总结来说，C#数据库编程中的抽象工厂模式是实现数据库交互的一种高效方式，它通过将数据库操作的细节封装在具体工厂类中，使得系统具有更好的扩展性，同时保持了代码的整洁和模块化。在实际项目中，如用户管理系统，...
抽象工厂模式实现
11-19
在描述中的链接中，可能会展示如何在C#中实现抽象工厂模式。通常，代码会包含以下步骤： 1. 定义抽象产品类，例如`ProductA`和`ProductB`，它们分别代表产品族中的不同对象。 2. 创建抽象工厂接口`AbstractFactory`...
C# 设计模式系列教程-抽象工厂模式
09-02
使用抽象工厂模式，当需要切换数据库时，只需改变创建产品的工厂类，无需修改使用这些产品的代码，提高了代码的可维护性和可扩展性。这种模式特别适合于那些需要在运行时动态地根据环境或配置信息来创建对象的情况。...
【设计模式】C#版三大工厂之简单工厂、工厂方法与抽象工厂
知世俗而不世俗
02-03 6651
引言         简单工厂、工厂方法、抽象工厂都属于设计模式中的创建型模式。其主要功能都是帮助我们把对象的实例化部分抽象取了出来，优化了系统的架构，并且增强了系统的扩展性。此篇博客是笔者对学完这三种模式之后一个小小的总结 简单工厂         简单工厂模式的工厂类一般是使用静态方法，通过接收的参数不同来返回不同的对象实例。不修改代码的话，是无法扩展的          优点
OAuth2.0 or Spring Session or 单点登录流程
qq_53374893的博客
07-20 433
一句话精辟解释： 在过滤器放行的时候，偷偷的把原生的 request 和 response 对象换成了它的实现，也就是 调用getSession 的时候拿到的 其实是对redis 操作的Session。但其他的操作还是使用原生的，只不过重写的方法，调用的是子类的，也就是往 redis 里放入 Session，把原生的操作给替换了！分布式Session原理，使用子域名，的时候放入父域名的 JsessionId 然后将这个ID 的所存的内容放入Redis ，这样实现不同域名共享同一sessionID.
redis+spring面试题
github_36510643的博客
07-21 408
redis+spring面试题
基于JSP的高校信息资源共享平台
heye0910032的博客
07-22 655
高校信息资源共享平台的开发和实现，为高校信息资源的管理和共享提供了一个有效的解决方案。通过使用JSP技术和MySQL数据库，本系统实现了一个稳定、安全、易用的高校信息资源管理平台。虽然在开发过程中遇到了一些技术挑战，但通过不断学习和实践，最终完成了一个能够满足用户需求的系统。未来，我们将继续优化系统功能，提升用户体验，以期达到更高的应用价值和社会效益。高校信息资源共享平台的开发和实现，为高校信息资源的管理和共享提供了一个有效的解决方案。
docker容器
2401_83945639的博客
07-20 946
root@lvs-server ~]# docker start 8a1e7f458daf --手动start启动。-v 目录映射【宿主机的目录映射给容器的某个目录，将容器中的目录挂载到宿主机的目录中】docker rm -f $(docker ps -aq) 删除所有的容器。docker rm -f cname 强制删除，可以删除正在运行的容器。-p 端口映射【宿主机的端口映射给容器的某个端口】创建容器并运行 --这个是mysql的容器。docker ps -q 查看所有容器id。
04-用户画像+sqoop使用
weixin_46567476的博客
07-21 541
sqoop的作用是实现数据的导入和导出，主要是对数据库和数据仓库之间的操作。qoop脚本就是将sqoop指令写入shell文件 后缀是 .sh。只要是支持jdbc连接的数据库都可以使用sqoop操作。
sqlalchemy使用json_unquote函数的mysql like查询
最新发布
ithongchou的博客
07-23 910
为您自己的数据库连接信息，并根据实际表结构修改模型类。函数查询MySQL JSON字段可以通过使用。下面是一个示例，假设有一个名为。请确保替换示例代码中的数据库连接字符串(在SQLAlchemy中使用。的表，其中包含一个名为。
C#三层架构示例：应用抽象工厂实现多数据库访问
本章的核心目标是升级一个在线考试系统，使其支持多数据库访问，包括Access和SQL Server，通过抽象工厂来实现不同数据库操作的统一管理。 抽象工厂模式的基本概念如下： 1. **抽象工厂**：它是定义接口或抽象类，...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值