MESProductionWeb/AntORM/Ant.Data/DataAccess/DataAccessFactory.cs

using System;
using System.Collections.Generic;
using System.Text;
using System.Configuration;
using System.Data.Common;
using Ant.Common;
using MySql.Data.MySqlClient;

namespace Ant.Data
{
    /// <summary>
    /// 数据库访问工厂类
    /// </summary>
    public class DataAccessFactory
    {

        #region 创建不同数据连接
        /// <summary>
        /// 创建不同数据连接
        /// </summary>
        /// <param name="ModuleName">模块</param>
        /// <param name="datatype">数据方式</param>
        /// <returns></returns>
        public static DataAccess CreateDataConnection(string ModuleName, DataConfigEnum data = DataConfigEnum.WriteData)
        {
            DataAccess db = null; var datalist = DataConfig.GetDataConfig();
            if (string.Compare(ModuleName, "default", true) == 0)
            {
                ModuleName = DatabaseDefault;
            }
            if (ModuleName.IsEmpty())
                ModuleName = ConfigurationManager.AppSettings["Default"];
            var dataconfig = datalist[ModuleName];
            string key = DecodeEncrypt.Decrypt(dataconfig.DatabaseKey);//解密
            string doc = DecodeEncrypt.Decode(key);//解密
            string strconnection = "";
            if (string.Compare(dataconfig.IsConStringEncrypt, "true", true) == 0)
            {
                //需要对数据库连接进行解密

            }
            if (!Environment.MachineName.IsEmpty())
            {

            }
            strconnection = (data == DataConfigEnum.ReadData) ? dataconfig.ReadData : dataconfig.WriteData;//默认连接数据库

            if (strconnection.IsIndexOf(doc) || dataconfig.DatabaseType.Equals(DatabaseType.SQLite.ToString(), StringComparison.CurrentCultureIgnoreCase))
            {
                DatabaseProperty config = new DatabaseProperty();
                config.ConnectionString = strconnection;
                config.DatabaseType = GetDatabaseType(dataconfig.DatabaseType);
                db = CreateDataAccess(config);//根据模块来创建不同数据库连接，没有模块就创建默认的数据连接
            }
            else
            {
                db = null;
            }
            return db;
        }



        /// <summary>
        /// 获取默认写库配置
        /// </summary>
        public static DataAccess GetWriteDataDefault
        {
            get { return CreateDataConnection(DatabaseDefault, DataConfigEnum.WriteData); }
        }

        /// <summary>
        /// 获取默认写库配置
        /// </summary>
        public static DataAccess GetReadDataDefault
        {
            get { return CreateDataConnection(DatabaseDefault, DataConfigEnum.ReadData); }
        }

        #endregion

        /// <summary>
        /// 创建数据库边连接字符串
        /// </summary>
        /// <param name="dbp"></param>
        /// <returns></returns>
        public static string CreateDbParmCharacter(DatabaseProperty dbp)
        {
            string character = string.Empty;

            switch (dbp.DatabaseType)
            {
                case DatabaseType.MSSQLServer:
                    character = "@";
                    break;
                case DatabaseType.Oracle:
                    character = ":";
                    break;
                case DatabaseType.MySQL:
                    character = "?";
                    break;
                case DatabaseType.OleDb:
                    character = "@";
                    break;
                case DatabaseType.SQLite:
                    character = "@";
                    break;
                default:
                    throw new Exception("数据库类型目前不支持！");
            }
            return character;
        }

        /// <summary>
        /// 创建一个数据库访问类
        /// </summary>
        /// <param name="dbp"></param>
        /// <returns></returns>
        private static DataAccess CreateDataAccess(DatabaseProperty dbp)
        {
            DataAccess da = null;
            switch (dbp.DatabaseType)
            {
                case DatabaseType.MSSQLServer:
                    da = new MSSqlDataAccess(dbp.ConnectionString);
                    break;
                case DatabaseType.OleDb:
                    da = new OleDbDataAccess(dbp.ConnectionString);
                    break;
                case DatabaseType.Oracle:
                    da = new OracleDataAccess(dbp.ConnectionString);
                    break;
                case DatabaseType.MySQL:
                    da = new MySqlDataAccess(dbp.ConnectionString);
                    break;
                case DatabaseType.SQLite:
                    da = new SQLiteDataAccess(dbp.ConnectionString);
                    break;
                default:
                    da = new MSSqlDataAccess(dbp.ConnectionString);
                    break;
            }
            return da;
        }


        //public static DbParameter CreateDbParameter()
        //{
        //    //switch (DbHelper.DbType)
        //    //{
        //    //    case DatabaseType.Oracle:
        //    //        return new OracleParameter();

        //    //    case DatabaseType.SqlServer:
        //    //        return new SqlParameter();

        //    //    case DatabaseType.Access:
        //    //        return new OleDbParameter();

        //    //    case DatabaseType.MySql:
        //    //        return new MySqlParameter();

        //    //    case DatabaseType.SQLite:
        //    //       return new SQLiteParameter();
        //    //}
        //    throw new Exception("数据库类型目前不支持！");
        //}



        /// <summary>
        /// 获取数据库类型
        /// </summary>
        /// <param name="configName"></param>
        /// <returns></returns>
        public static DatabaseType GetDatabaseType(string configName)
        {
            switch (configName.ToLower())
            {
                case "mssql":
                    return DatabaseType.MSSQLServer;
                case "oledb":
                    return DatabaseType.OleDb;
                case "oracle":
                    return DatabaseType.Oracle;
                case "mysql":
                    return DatabaseType.MySQL;
                case "sqlite":
                    return DatabaseType.SQLite;
                default:
                    return DatabaseType.MSSQLServer;
            }
        }

        /// <summary>
        /// 默认数据库
        /// </summary>
        public static string DatabaseDefault
        {
            get { return ConfigurationManager.AppSettings["Default"].ToString(); }
        }

        /// <summary>
        /// 获取数据库类型
        /// </summary>
        /// <param name="configName"></param>
        /// <returns></returns>
        public static DatabaseType GetDatabaseType()
        {
            return GetDatabaseType("Default");
        }



    }
}