/// <summary>
/// 构造DAL对象
/// </summary>
/// <param name="userInfo">用户信息</param>
/// <param name="dbType">数据库类型</param>
private void BuildDal(UserInfo userInfo, DatabaseType?dbType)
{
//先判断有没有自定义重写数据层
try
{
Type customerDalType = Bridge.BridgeObject.GetDALType(typeof(T));
if (customerDalType != null) //有自定义重写类，取自定义数据层对象
{
object obj = Activator.CreateInstance(customerDalType, new object[] { userInfo });
if (obj != null)
{
_dal = obj as BaseDAL <T>;
}
else
{
_dal = new BaseDAL <T>(userInfo, dbType);
}
}
else
{
_dal = new BaseDAL <T>(userInfo, dbType);
}
}
catch
{
_dal = new BaseDAL <T>(userInfo, dbType);
}
}
/// <summary>
/// Returns the database provider type (e.g. MySql / Sql Server) that the filter is written for. This is determined by what <see cref="GetColumnInfoIfExists"/>
/// it is declared against.
/// </summary>
/// <returns></returns>
protected DatabaseType GetDatabaseType()
{
if (_cachedDatabaseTypeAnswer != null)
{
return(_cachedDatabaseTypeAnswer.Value);
}
var col = GetColumnInfoIfExists();
if (col != null)
{
_cachedDatabaseTypeAnswer = col.TableInfo.DatabaseType;
}
else
{
_cachedDatabaseTypeAnswer = GetCatalogue().GetDistinctLiveDatabaseServerType();
}
if (!_cachedDatabaseTypeAnswer.HasValue)
{
throw new AmbiguousDatabaseTypeException("Unable to determine DatabaseType for Filter '" + this + "'");
}
return(_cachedDatabaseTypeAnswer.Value);
}
/// <summary>
/// 获取添加左右标记 防止有关键字作为字段名/表名
/// </summary>
/// <param name="columnName"></param>
/// <param name="dbType"></param>
/// <returns></returns>
public static string ParamSql(this string columnName, DatabaseType?dbType)
{
switch (dbType)
{
case DatabaseType.SqlServer:
case DatabaseType.GteSqlServer2012:
if (columnName.StartsWith("["))
{
return(columnName);
}
return($"[{columnName}]");
case DatabaseType.MySql:
if (columnName.StartsWith("`"))
{
return(columnName);
}
return($"`{columnName}`");
case DatabaseType.SQLite:
if (columnName.StartsWith("`"))
{
return(columnName);
}
return($"`{columnName}`");
default:
return(columnName);
}
}
/// <summary>
/// 选择数据库
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void button1_Click(object sender, EventArgs e)
{
this.DialogResult = DialogResult.OK;
if (rbSqlServer.Checked)
{
databaseType = DatabaseType.SqlServer;
}
else if (rbOledb.Checked)
{
databaseType = DatabaseType.MsAccess;
}
else if (rbOracle.Checked)
{
databaseType = DatabaseType.Oracle;
}
else if (rbSQLite.Checked)
{
databaseType = DatabaseType.Sqlite3;
}
else if (rbMySql.Checked)
{
databaseType = DatabaseType.MySql;
}
else if (rbMariaDB.Checked)
{
databaseType = DatabaseType.MySql;
}
else if (rbMongoDB.Checked)
{
databaseType = DatabaseType.MongoDB;
}
this.Close();
}
/// <summary>
/// 根据配置文件获取数据库类型，并返回对应的工厂接口
/// </summary>
/// <param name="obj">初始化参数，可为连接字符串或者DbContext</param>
/// <returns></returns>
public static IRepository GetRepository(Object obj = null, DatabaseType?dbType = null, string entityNamespace = null)
{
IRepository res = null;
DatabaseType _dbType = GetDbType(dbType);
Type dbRepositoryType = Type.GetType("Coldairarrow.DataRepository." + DbProviderFactoryHelper.DbTypeToDbTypeStr(_dbType) + "Repository");
List <object> paramters = new List <object>();
void BuildParamters()
{
if (obj.IsNullOrEmpty())
{
return;
}
if (obj is DbContext)
{
paramters.Add(obj);
return;
}
else if (obj is string)
{
paramters.Add(obj);
paramters.Add(entityNamespace);
}
}
BuildParamters();
res = _dbrepositoryContainer.Resolve <IRepository>(_dbType.ToString(), paramters.ToArray());
return(res);
}
/// <summary>
/// Creates a new <see cref="AmendExpressionAttribute"/> that will request application of <paramref name="amendmentText"/>
/// for the specified <paramref name="targetDatabaseType"/>.
/// </summary>
/// <param name="amendmentText">Amendment text to apply.</param>
/// <param name="targetDatabaseType">Target <see cref="DatabaseType"/> for amendment text.</param>
public AmendExpressionAttribute(string amendmentText, DatabaseType targetDatabaseType)
{
AmendmentText = amendmentText;
TargetDatabaseType = targetDatabaseType;
TargetExpression = TargetExpression.TableName;
AffixPosition = AffixPosition.Suffix;
StatementTypes = StatementTypes.Select;
}
/// <summary>
/// 根据配置文件获取数据库类型，并返回对应的工厂接口
/// </summary>
/// <param name="conString">链接字符串</param>
/// <param name="dbType">数据库类型</param>
/// <returns></returns>
public static IRepository GetRepository(string conString = null, DatabaseType?dbType = null)
{
conString = conString.IsNullOrEmpty() ? GlobalSwitch.DefaultDbConName : conString;
conString = DbProviderFactoryHelper.GetConStr(conString);
dbType = dbType.IsNullOrEmpty() ? GlobalSwitch.DatabaseType : dbType;
Type dbRepositoryType = Type.GetType("Coldairarrow.DataRepository." + DbProviderFactoryHelper.DbTypeToDbTypeStr(dbType.Value) + "Repository");
return(Activator.CreateInstance(dbRepositoryType, new object[] { conString }) as IRepository);
}
private SaverSettings(SaverOption providerOption,
string?connectionString = null,
DatabaseType?databaseType = null,
string?fileName = null)
{
ProviderOption = providerOption;
ConnectionString = connectionString;
DatabaseType = databaseType;
FileName = fileName;
}
/// <summary>
/// 获取DbType
/// </summary>
/// <param name="dbType">数据库类型</param>
/// <returns></returns>
private static DatabaseType GetDbType(DatabaseType?dbType)
{
DatabaseType _dbType;
if (dbType.IsNullOrEmpty())
{
_dbType = GlobalSwitch.DatabaseType;
}
else
{
_dbType = dbType.Value;
}
return(_dbType);
}
/// <summary>
/// Scripts multiple tables schemas and optionally ports datatypes / constraints etc to alternate DBMS
/// </summary>
public ExecuteCommandScriptTables(IBasicActivateItems activator,
[DemandsInitialization("Tables to script")]
TableInfo[] tableInfos,
[DemandsInitialization("Optional alternate DBMS Type to port the schema to")]
DatabaseType?dbType,
[DemandsInitialization("Optional alternate database name to use in the script generated.")]
string dbName,
[DemandsInitialization("Optional file to write the resulting script out to. Pass Null to output to console.")]
FileInfo outFile) : base(activator)
{
_tableInfos = tableInfos;
this._dbType = dbType;
this._dbName = dbName;
this._outFile = outFile;
}
/// <summary>
/// 根据配置文件获取数据库类型，并返回对应的工厂接口
/// </summary>
/// <param name="conString">链接字符串</param>
/// <param name="dbType">数据库类型</param>
/// <returns></returns>
public static IRepository GetRepository(string conString = null, DatabaseType?dbType = null)
{
conString = conString.IsNullOrEmpty() ? GlobalSwitch.DefaultDbConName : conString;
conString = DbProviderFactoryHelper.GetConStr(conString);
dbType = dbType.IsNullOrEmpty() ? GlobalSwitch.DatabaseType : dbType;
Type dbRepositoryType = Type.GetType("Coldairarrow.DataRepository." + DbProviderFactoryHelper.DbTypeToDbTypeStr(dbType.Value) + "Repository");
var repository = Activator.CreateInstance(dbRepositoryType, new object[] { conString }) as IRepository;
//请求结束自动释放
try
{
AutofacHelper.GetScopeService <IDisposableContainer>().AddDisposableObj(repository);
}
catch
{
}
return(repository);
}
/// <summary>
/// 根据配置文件获取数据库类型，并返回对应的工厂接口
/// </summary>
/// <param name="conString">链接字符串</param>
/// <param name="dbType">数据库类型</param>
/// <returns></returns>
public static IRepository GetRepository(string conString, DatabaseType?dbType)
{
//conString = conString.IsNullOrEmpty() ? "sql" : conString;
//conString = DbProviderFactoryHelper.GetConStr(conString);
dbType = dbType.IsNullOrEmpty() ? DatabaseType.SqlServer : dbType;
Type dbRepositoryType = Type.GetType("Andy.Mes.Persistence." + DbProviderFactoryHelper.DbTypeToDbTypeStr(dbType.Value) + "Repository");
var repository = Activator.CreateInstance(dbRepositoryType, new object[] { conString }) as IRepository;
//请求结束自动释放
try
{
//AutofacHelper.GetScopeService<IDisposableContainer>().AddDisposableObj(repository);
}
catch
{
}
return(repository);
}
/// <summary>
/// 创建数据库事件提供程序
/// </summary>
/// <param name="assemblyName">Name of the assembly.</param>
/// <param name="className">Name of the class.</param>
/// <param name="connectionString">The conn STR.</param>
/// <param name="databaseType">The DatabaseType.</param>
/// <returns>The db provider.</returns>
public static DbProvider CreateDbProvider(string assemblyName, string className, string connectionString, DatabaseType?databaseType)
{
Check.Require(connectionString, "connectionString", Check.NotNullOrEmpty);
if (connectionString.IndexOf("microsoft.jet.oledb", StringComparison.OrdinalIgnoreCase) > -1 || connectionString.IndexOf(".db3", StringComparison.OrdinalIgnoreCase) > -1)
{
Check.Require(connectionString.IndexOf("data source", StringComparison.OrdinalIgnoreCase) > -1, "ConnectionString的格式有错误，请查证！");
string mdbPath = connectionString.Substring(connectionString.IndexOf("data source", StringComparison.OrdinalIgnoreCase) + "data source".Length + 1).TrimStart(' ', '=');
if (mdbPath.ToLower().StartsWith("|datadirectory|"))
{
mdbPath = AppDomain.CurrentDomain.BaseDirectory.TrimEnd('\\') + "\\App_Data" + mdbPath.Substring("|datadirectory|".Length);
}
else if (connectionString.StartsWith("./") || connectionString.EndsWith(".\\"))
{
connectionString = connectionString.Replace("/", "\\").Replace(".\\", AppDomain.CurrentDomain.BaseDirectory.TrimEnd('\\') + "\\");
}
connectionString = connectionString.Substring(0, connectionString.ToLower().IndexOf("data source")) + "Data Source=" + mdbPath;
}
//如果是~则表示当前目录
if (connectionString.Contains("~/") || connectionString.Contains("~\\"))
{
connectionString = connectionString.Replace("/", "\\").Replace("~\\", AppDomain.CurrentDomain.BaseDirectory.TrimEnd('\\') + "\\");
}
//by default, using sqlserver db provider
if (string.IsNullOrEmpty(className))
{
className = typeof(SqlServer.SqlServerProvider).ToString();
if (databaseType == null)
{
databaseType = DatabaseType.SqlServer;
}
}
else if (String.Compare(className, "System.Data.SqlClient", StringComparison.OrdinalIgnoreCase) == 0 || String.Compare(className, "Dos.ORM.SqlServer", StringComparison.OrdinalIgnoreCase) == 0)
{
className = typeof(SqlServer.SqlServerProvider).ToString();
if (databaseType == null)
{
databaseType = DatabaseType.SqlServer;
}
}
else if (String.Compare(className, "Dos.ORM.SqlServer9", StringComparison.OrdinalIgnoreCase) == 0 || className.IndexOf("SqlServer9", StringComparison.OrdinalIgnoreCase) >= 0 || className.IndexOf("sqlserver2005", StringComparison.OrdinalIgnoreCase) >= 0 || className.IndexOf("sql2005", StringComparison.OrdinalIgnoreCase) >= 0)
{
className = typeof(SqlServer9.SqlServer9Provider).ToString();
if (databaseType == null)
{
databaseType = DatabaseType.SqlServer9;
}
}
else if (className.IndexOf("oracle", StringComparison.OrdinalIgnoreCase) >= 0)
{
className = typeof(Oracle.OracleProvider).ToString();
if (databaseType == null)
{
databaseType = DatabaseType.Oracle;
}
}
else if (className.IndexOf("access", StringComparison.OrdinalIgnoreCase) >= 0)
{
className = typeof(MsAccess.MsAccessProvider).ToString();
if (databaseType == null)
{
databaseType = DatabaseType.MsAccess;
}
}
else if (className.IndexOf("mysql", StringComparison.OrdinalIgnoreCase) >= 0)
{
className = "Dos.ORM.MySql.MySqlProvider";
assemblyName = "Dos.ORM.MySql";
if (databaseType == null)
{
databaseType = DatabaseType.MySql;
}
}
else if (className.IndexOf("sqlite", StringComparison.OrdinalIgnoreCase) >= 0)
{
className = "Dos.ORM.Sqlite.SqliteProvider";
assemblyName = "Dos.ORM.Sqlite";
if (databaseType == null)
{
databaseType = DatabaseType.Sqlite3;
}
}
string cacheKey = string.Concat(assemblyName, className, connectionString);
if (providerCache.ContainsKey(cacheKey))
{
return(providerCache[cacheKey]);
}
else
{
System.Reflection.Assembly ass;
ass = assemblyName == null ? typeof(DbProvider).Assembly
: System.Reflection.Assembly.Load(assemblyName);
DbProvider retProvider = ass.CreateInstance(className, false, System.Reflection.BindingFlags.Default, null, new object[] { connectionString }, null, null) as DbProvider;
if (retProvider != null && databaseType != null)
{
retProvider.DatabaseType = databaseType.Value;
}
providerCache.Add(cacheKey, retProvider);
return(retProvider);
}
}
private SqlContext Initialize()
{
_logger.LogDebug("Initializing.");
if (ConnectionString.IsNullOrWhiteSpace())
{
throw new InvalidOperationException("The factory has not been configured with a proper connection string.");
}
if (ProviderName.IsNullOrWhiteSpace())
{
throw new InvalidOperationException("The factory has not been configured with a proper provider name.");
}
if (DbProviderFactory == null)
{
throw new Exception($"Can't find a provider factory for provider name \"{ProviderName}\".");
}
_databaseType = DatabaseType.Resolve(DbProviderFactory.GetType().Name, ProviderName);
if (_databaseType == null)
{
throw new Exception($"Can't find an NPoco database type for provider name \"{ProviderName}\".");
}
_sqlSyntax = _dbProviderFactoryCreator.GetSqlSyntaxProvider(ProviderName !);
if (_sqlSyntax == null)
{
throw new Exception($"Can't find a sql syntax provider for provider name \"{ProviderName}\".");
}
_bulkSqlInsertProvider = _dbProviderFactoryCreator.CreateBulkSqlInsertProvider(ProviderName !);
_databaseType = _sqlSyntax.GetUpdatedDatabaseType(_databaseType, ConnectionString);
// ensure we have only 1 set of mappers, and 1 PocoDataFactory, for all database
// so that everything NPoco is properly cached for the lifetime of the application
_pocoMappers = new NPoco.MapperCollection();
// add all registered mappers for NPoco
_pocoMappers.AddRange(_npocoMappers);
_pocoMappers.AddRange(_dbProviderFactoryCreator.ProviderSpecificMappers(ProviderName !));
var factory = new FluentPocoDataFactory(GetPocoDataFactoryResolver, _pocoMappers);
_pocoDataFactory = factory;
var config = new FluentConfig(xmappers => factory);
// create the database factory
_npocoDatabaseFactory = DatabaseFactory.Config(cfg =>
{
cfg.UsingDatabase(CreateDatabaseInstance) // creating UmbracoDatabase instances
.WithFluentConfig(config); // with proper configuration
foreach (IProviderSpecificInterceptor interceptor in _dbProviderFactoryCreator.GetProviderSpecificInterceptors(ProviderName !))
{
cfg.WithInterceptor(interceptor);
}
});
if (_npocoDatabaseFactory == null)
{
throw new NullReferenceException("The call to UmbracoDatabaseFactory.Config yielded a null UmbracoDatabaseFactory instance.");
}
_logger.LogDebug("Initialized.");
return(new SqlContext(_sqlSyntax, _databaseType, _pocoDataFactory, _mappers));
}
private static void Main(string[] args)
{
Console.OutputEncoding = Encoding.Default;
var deployType = Environment.GetEnvironmentVariable("roundhouse-deploy-type");
DatabaseType?databaseType = null;
DatabaseType t;
if (Enum.TryParse(Environment.GetEnvironmentVariable("roundhouse-database-type"), out t))
{
databaseType = t;
}
var server = Environment.GetEnvironmentVariable("roundhouse-server");
var login = Environment.GetEnvironmentVariable("roundhouse-login");
var password = Environment.GetEnvironmentVariable("roundhouse-password");
var database = Environment.GetEnvironmentVariable("roundhouse-database");
var folder = Environment.GetEnvironmentVariable("roundhouse-folder");
var environment = Environment.GetEnvironmentVariable("roundhouse-environment");
var version = Environment.GetEnvironmentVariable("roundhouse-version");
var failonNonUTF8 = Environment.GetEnvironmentVariable("roundhouse-failOnNonUTF8") == "true";
var verbose = Environment.GetEnvironmentVariable("roundhouse-verbose") == "true";
DeployType[] types;
switch (deployType)
{
case "deploy":
types = new[] { DeployType.Deploy };
break;
case "drop":
types = new[] { DeployType.Drop };
break;
case "dropDeploy":
types = new[] { DeployType.Drop, DeployType.Deploy };
break;
default:
throw new InvalidOperationException("Unknown deploy type");
}
var filesChecked = false;
foreach (var type in types)
{
var a = new List <string>(args);
if (databaseType != null)
{
a.Add("-dt");
a.Add(databaseType.ToString());
}
if (!string.IsNullOrWhiteSpace(server))
{
a.Add("-s");
a.Add(server);
}
if (!string.IsNullOrWhiteSpace(database))
{
a.Add("-d");
a.Add(database);
}
if (!string.IsNullOrWhiteSpace(folder))
{
a.Add("-f");
a.Add(folder);
}
if (!string.IsNullOrWhiteSpace(environment))
{
a.Add("-env");
a.Add(environment);
}
if (!string.IsNullOrWhiteSpace(version))
{
a.Add("-v");
a.Add(version);
}
if (!string.IsNullOrWhiteSpace(login))
{
switch (databaseType)
{
case DatabaseType.sqlserver:
case DatabaseType.sql2000:
a.Add("-c");
a.Add(
$"data source={server};initial catalog={database};Integrated Security=false;User ID={login};Password={password};");
break;
case DatabaseType.oracle:
a.Add("-c");
a.Add($"Data Source={server}/{database};User Id={login};Password={password};Integrated Security=no;");
a.Add("-csa");
a.Add($"Data Source={server};User Id={login};Password={password};Integrated Security=no;");
break;
case DatabaseType.mysql:
a.Add("-c");
a.Add($"Server={server};Database={database};Port=3306;Uid={login};Pwd={password};");
break;
case DatabaseType.postgres:
a.Add("-c");
a.Add($"Server={server};Database={database};Port=5432;UserId={login};Password={password};");
break;
default:
throw new ArgumentOutOfRangeException();
}
}
if (type == DeployType.Drop)
{
a.Add("--drop");
}
if (args.Length > 0)
{
a.AddRange(args);
}
var config = console.Program.set_up_configuration_and_build_the_container(a.ToArray());
var logger = new TeamCityServiceMessages().CreateWriter();
config.Silent = true;
config.Debug = verbose;
if (deployType != "drop" && !filesChecked)
{
var badFiles = new List <string>();
foreach (
var file in Directory.GetFiles(config.SqlFilesDirectory, "*.sql", SearchOption.AllDirectories))
{
var preamble = Encoding.UTF8.GetPreamble();
using (var f = new BufferedStream(File.OpenRead(file)))
{
if (f.Length >= preamble.Length)
{
var buffer = new byte[preamble.Length];
f.Read(buffer, 0, preamble.Length);
if (preamble.SequenceEqual(buffer))
{
continue;
}
}
f.Position = 0;
int b;
while ((b = f.ReadByte()) != -1)
{
if (b > 127)
{
badFiles.Add(file);
break;
}
}
}
}
if (badFiles.Count > 0)
{
var message = $"Found non UTF-8 files:{Environment.NewLine}{string.Join(Environment.NewLine, badFiles)}";
if (failonNonUTF8)
{
foreach (var badFile in badFiles)
{
var identity = SHA1.Create().ComputeHash(Encoding.UTF8.GetBytes(badFile));
logger.WriteBuildProblem(Convert.ToBase64String(identity),
$"File {badFile} is not in UTF8 encoding");
}
return;
}
logger.WriteWarning(message);
}
}
using (var l = logger.OpenBlock(type.ToString()))
{
config.Logger = new CustomLogger(l, verbose);
WriteStartupParameters(l, config);
var migrate = new Migrate();
migrate.Set(c => ApplyConfig(config, c));
migrate.Run();
}
}
}
/// <summary>
/// 构造函数
/// </summary>
/// <param name="userInfo">当前用户</param>
/// <param name="dbType">数据库类型</param>
public BaseBLL(UserInfo userInfo, DatabaseType?dbType = null)
{
currUser = userInfo;
BuildDal(userInfo, dbType);
}
/// <summary>
/// 构造函数
/// </summary>
/// <param name="dbType">数据库类型</param>
public BaseBLL(DatabaseType?dbType = null)
{
BuildDal(null, dbType);
}
/// <summary>
/// 实例化业务层或数据层对象
/// </summary>
/// <typeparam name="T">T为业务层接口类</typeparam>
/// <param name="currUser">当前用户</param>
/// <param name="dbType">数据库类型</param>
/// <returns>返回业务层或数据层对象</returns>
public static T Resolve <T>(UserInfo currUser, DatabaseType?dbType = null) where T : class
{
Type type = typeof(T);
return(Resolve(currUser, type, dbType) as T);
}
/// <summary>
/// 实体化业务层或数据层对象
/// </summary>
/// <param name="currUser">当前用户</param>
/// <param name="type">业务层或数据层接口类型</param>
/// <param name="dbType">数据库类型</param>
/// <returns>返回业务层或数据层对象</returns>
public static object Resolve(UserInfo currUser, Type type, DatabaseType?dbType = null)
{
string key = type.FullName;
if (currUser != null)
{
key += currUser.UserId.ToString();
}
object obj = null;
if (interfaceObjCaches.ContainsKey(key))
{
interfaceObjCaches.TryGetValue(key, out obj);
if (obj != null)
{
return(obj);
}
}
if (type.Name.EndsWith("BLL") || (type.IsGenericType && type.Name.StartsWith("IBaseBLL")))
{
#region 实例化业务层对象
List <Type> bllTypeList = GetAllBLLTypes();
if (bllTypeList != null && bllTypeList.Count > 0)
{
Type bllType = null;
if (type.IsGenericType && type.Name.StartsWith("IBaseBLL")) //业务层泛型类型
{
Type paramType = type.GetGenericArguments()[0]; //参数类型
//先判断有没有自定义业务层，有则调用自定义业务层
Type customerBLLType = bllTypeList.Where(x => x.Name == string.Format("{0}BLL", paramType.Name) && x.BaseType.Name.Contains("BaseBLL")).FirstOrDefault();
if (customerBLLType == null) //没有自定义业务层
{
Type genericBllType = bllTypeList.Where(x => x.Name.StartsWith("BaseBLL")).FirstOrDefault();
bllType = genericBllType.MakeGenericType(new Type[] { paramType });
obj = Activator.CreateInstance(bllType, new object[] { currUser, dbType });
}
else //有自定义业务层，实例化自定义业务层
{
obj = Activator.CreateInstance(customerBLLType, new object[] { currUser });
}
}
else //业务层类型
{
bllType = bllTypeList.Where(x => "I" + x.Name == type.Name).FirstOrDefault();
obj = Activator.CreateInstance(bllType, new object[] { currUser });
}
}
#endregion
}
else if (type.Name.EndsWith("DAL") || (type.IsGenericType && type.Name.StartsWith("IBaseDAL")))
{
#region 实例化数据层对象
List <Type> dalTypeList = GetAllDALTypes();
if (dalTypeList != null && dalTypeList.Count > 0)
{
Type dalType = null;
if (type.IsGenericType && type.Name.StartsWith("IBaseDAL")) //数据层泛型类型
{
Type paramType = type.GetGenericArguments()[0]; //参数类型
//先判断有没有自定义数据层，有则调用自定义数据层
Type customerDALType = dalTypeList.Where(x => x.Name == string.Format("{0}DAL", paramType.Name) && x.BaseType.Name.Contains("BaseDAL")).FirstOrDefault();
if (customerDALType == null) //没有自定义业务层
{
Type genericBllType = dalTypeList.Where(x => x.Name.StartsWith("BaseDAL")).FirstOrDefault();
dalType = genericBllType.MakeGenericType(new Type[] { paramType });
obj = Activator.CreateInstance(dalType, new object[] { currUser, dbType });
}
else //有自定义数据层，实例化自定义数据层
{
obj = Activator.CreateInstance(customerDALType, new object[] { currUser });
}
}
else //数据层类型
{
dalType = dalTypeList.Where(x => "I" + x.Name == type.Name).FirstOrDefault();
obj = Activator.CreateInstance(dalType, new object[] { currUser });
}
}
#endregion
}
if (obj != null)
{
interfaceObjCaches.TryAdd(key, obj);
}
return(obj);
}
/// <summary>
/// Creates a new <see cref="FieldDataTypeAttribute"/> that will request use of specific <see cref="DbType"/>
/// for the specified <see cref="DatabaseType"/>.
/// </summary>
/// <param name="fieldDataType">Specific <see cref="DbType"/> to target for field.</param>
/// <param name="targetDatabaseType">Target <see cref="DatabaseType"/> for applying <paramref name="fieldDataType"/>.</param>
public FieldDataTypeAttribute(DbType fieldDataType, DatabaseType targetDatabaseType)
{
FieldDataType = fieldDataType;
TargetDatabaseType = targetDatabaseType;
}
/// <summary>
/// Creates a new <see cref="FieldDataTypeAttribute"/> that will request use of specific <see cref="DbType"/>.
/// </summary>
/// <param name="fieldDataType">Specific <see cref="DbType"/> to target for field.</param>
public FieldDataTypeAttribute(DbType fieldDataType)
{
FieldDataType = fieldDataType;
TargetDatabaseType = null;
}
/// <summary>
/// 设置仓储服务
/// </summary>
/// <param name="conString">参数</param>
/// <param name="dbType">数据库类型</param>
/// <param name="entityNamespace">命名空间</param>
private void SetService(string conString, DatabaseType?dbType, string entityNamespace)
{
Service = DbFactory.GetRepository(conString, dbType, entityNamespace);
}
/// <summary>
/// 根据配置文件获取数据库类型，并返回对应的工厂接口
/// </summary>
/// <param name="connectionString">数据库连接字符串</param>
/// <param name="entityAssembly">实体类命名空间</param>
/// <param name="dbType">数据库类型</param>
/// <returns></returns>
public static IRepository GetRepository(string connectionString = null, string entityAssembly = null, DatabaseType?dbType = null)
{
//Type dbRepositoryType = Type.GetType("Library.DataRepository_" + DbTypeToDbTypeStr(dbType ?? DbOption.Option.DbType) + ".DbRepository");
var _dbType = DbTypeToDbTypeStr(dbType ?? DbOption.Option.DbType);
var assembly = Assembly.LoadFile($"{AppDomain.CurrentDomain.BaseDirectory}Library.DataRepository_{_dbType}.dll");
var type = assembly.GetType($"Library.DataRepository_{_dbType}.DbRepository");
//switch (dbType ?? DbOption.Option.DbType)
//{
// case DatabaseType.SqlServer:
// type = typeof(DataRepository_SqlServer.DbRepository);
// break;
// case DatabaseType.MySql:
// type = typeof(DataRepository_MySql.DbRepository);
// break;
// case DatabaseType.Oracle:
// type = typeof(DataRepository_PostgreSql.DbRepository);
// break;
// case DatabaseType.PostgreSQL:
// type = typeof(DataRepository_PostgreSql.DbRepository);
// break;
// case DatabaseType.OdbcDameng:
// type = typeof(DataRepository_DM.DbRepository);
// break;
// default:
// throw new Exception("数据库类型无效");
//}
if (type == null)
{
throw new Exception("数据库类型无效");
}
return(Activator.CreateInstance(type, new object[] { connectionString ?? DbOption.Option.ConnectionString, entityAssembly ?? DbOption.Option.EntityAssembly }) as IRepository);
}
/// <summary>
/// 设置仓储服务
/// </summary>
/// <param name="param">参数</param>
/// <param name="dbType">数据库类型</param>
/// <param name="entityNamespace">命名空间</param>
private void SetService(object param, DatabaseType?dbType, string entityNamespace)
{
Service = DbFactory.GetRepository(param, dbType, entityNamespace);
}
/// <summary>
/// 设置仓储服务
/// </summary>
/// <param name="conString">参数</param>
/// <param name="dbType">数据库类型</param>
/// <param name="entityNamespace">命名空间</param>
private void SetService(string conString, DatabaseType?dbType)
{
Service = DbFactory.GetRepository(conString, dbType);
}
/// <summary>
/// 获取指定的数据库帮助类
/// </summary>
/// <param name="dbType">数据库类型</param>
/// <param name="conStr">连接字符串</param>
/// <returns></returns>
public static DbHelper GetDbHelper(DatabaseType?dbType = null, string conStr = null)
{
return(_container.Resolve <DbHelper>((DbFactory.DbTypeToDbTypeStr(dbType ?? DbOption.Option.DbType)), conStr ?? DbOption.Option.ConnectionString));
}