/// <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("YK.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>
/// 通过条件删除数据
/// </summary>
/// <typeparam name="T">实体类型</typeparam>
/// <param name="condition">条件</param>
public virtual void Delete_Sql <T>(Expression <Func <T, bool> > condition) where T : class, new()
{
var objectQuery = GetObjectQueryFromDbQueryable(GetIQueryable <T>().Where(condition));
string querySTr = objectQuery.ToTraceString();
string parttern = "^SELECT.*?FROM.*?AS(.*?)WHERE.*?$";
var match = Regex.Match(querySTr, parttern, RegexOptions.Singleline);
string extent1 = match.Groups[1].ToString();
parttern = "^SELECT.*?(FROM.*?AS.*?WHERE.*?$)";
match = Regex.Match(querySTr, parttern, RegexOptions.Singleline);
string fromSql = match.Groups[1].ToString();
string deleteSql = $"DELETE {extent1} {fromSql}";
List <DbParameter> dbParamters = new List <DbParameter>();
objectQuery.Parameters.ToList().ForEach(aParamter =>
{
var parameter = DbProviderFactoryHelper.GetDbParameter(_dbType);
parameter.ParameterName = aParamter.Name;
parameter.Value = aParamter.Value ?? DBNull.Value;
dbParamters.Add(parameter);
});
ExecuteSql(deleteSql, dbParamters);
}
/// <summary>
/// 通过Sql参数查询返回DataTable
/// </summary>
/// <param name="sql">Sql语句</param>
/// <param name="parameters">查询参数</param>
/// <returns></returns>
public DataTable GetDataTableWithSql(string sql, List <DbParameter> parameters)
{
DbProviderFactory dbProviderFactory = DbProviderFactoryHelper.GetDbProviderFactory(_dbType);
using (DbConnection conn = dbProviderFactory.CreateConnection())
{
conn.ConnectionString = _connectionString;
if (conn.State != ConnectionState.Open)
{
conn.Open();
}
using (DbCommand cmd = conn.CreateCommand())
{
cmd.Connection = conn;
cmd.CommandText = sql;
cmd.CommandTimeout = 5 * 60;
if (parameters != null && parameters?.Count > 0)
{
cmd.Parameters.AddRange(parameters.ToArray());
}
DbDataAdapter adapter = dbProviderFactory.CreateDataAdapter();
adapter.SelectCommand = cmd;
DataSet table = new DataSet();
adapter.Fill(table);
cmd.Parameters.Clear();
return(table.Tables[0]);
}
}
}
/// <summary>
/// 获取
/// </summary>
/// <param name="conString"></param>
/// <param name="dbType"></param>
/// <returns></returns>
internal static BaseDbContext GetDbContext([NotNull] string conString, DatabaseType dbType)
{
if (conString.IsNullOrEmpty())
{
throw new Exception("conString能为空");
}
var dbConnection = DbProviderFactoryHelper.GetDbConnection(conString, dbType);
var model = DbModelFactory.GetDbCompiledModel(conString, dbType);
DbContextOptionsBuilder builder = new DbContextOptionsBuilder();
switch (dbType)
{
case DatabaseType.SqlServer: builder.UseSqlServer(dbConnection, x => x.UseRowNumberForPaging()); break;
case DatabaseType.MySql: builder.UseMySql(dbConnection); break;
case DatabaseType.PostgreSql: builder.UseNpgsql(dbConnection); break;
case DatabaseType.Oracle: builder.UseOracle(dbConnection, x => x.UseOracleSQLCompatibility("11")); break;
default: throw new Exception("暂不支持该数据库！");
}
builder.EnableSensitiveDataLogging();
builder.UseModel(model);
builder.UseLoggerFactory(_loggerFactory);
return(new BaseDbContext(builder.Options));
}
public SugarRepository()
{
SugarDbContext.Init(DbProviderFactoryHelper.GetConnectionString(), (SqlSugar.DbType)DbProviderFactoryHelper.GetDBType());
_context = SugarDbContext.GetDbContext();
_db = _context.Db;
_entityDb = _context.GetEntityDB <TEntity>(_db);
}
/// <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);
}
/// <summary>
/// 获取DbConnection
/// </summary>
/// <param name="conStr">连接名或字符串</param>
/// <returns></returns>
private static DbConnection GetDbConnection(string conStr, DatabaseType dbType)
{
if (conStr.IsNullOrEmpty())
{
conStr = GlobalSwitch.DefaultDbConName;
}
DbConnection dbConnection = DbProviderFactoryHelper.GetDbConnection(dbType);
dbConnection.ConnectionString = DbProviderFactoryHelper.GetConStr(conStr);
return(dbConnection);
}
private void RefreshDb()
{
var oldDb = _db;
var con = DbProviderFactoryHelper.GetDbConnection(_conString, _dbType);
var dBCompiledModel = DbModelFactory.GetDbCompiledModel(_conString, _dbType);
_db = new BaseDbContext(con, dBCompiledModel);
if (oldDb != null)
{
_db.Database.Log += oldDb.Database.Log;
}
}
public void RefreshDb()
{
//重用DbConnection,使用底层相同的DbConnection,支持Model持热更新
DbConnection con = null;
if (_transaction != null)
{
con = _transaction.Connection;
}
else
{
con = _db?.Database?.GetDbConnection() ?? DbProviderFactoryHelper.GetDbConnection(_conString, _dbType);
}
var dBCompiledModel = DbModelFactory.GetDbCompiledModel(_conString, _dbType);
_db = new BaseDbContext(_dbType, con, dBCompiledModel);
_db.Database.UseTransaction(_transaction);
disposedValue = false;
}
/// <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);
}
protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
{
if (_nameOrConStr.IsNullOrEmpty())
{
_nameOrConStr = GlobalSwitch.DefaultDbConName;
}
string conStr = DbProviderFactoryHelper.GetConStr(_nameOrConStr);
switch (_dbType)
{
case DatabaseType.SqlServer: optionsBuilder.UseSqlServer(_nameOrConStr).EnableSensitiveDataLogging(); break;
case DatabaseType.MySql: optionsBuilder.UseMySQL(_nameOrConStr); break;
default: throw new Exception("暂不支持该数据库！");
}
optionsBuilder.UseLoggerFactory(_loger);
}
/// <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);
}
private static DbCompiledModelInfo BuildDbCompiledModelInfo(string nameOrConStr, DatabaseType dbType)
{
lock (_buildCompiledModelLock)
{
DbConnection connection = DbProviderFactoryHelper.GetDbConnection(nameOrConStr, dbType);
DbModelBuilder modelBuilder = new DbModelBuilder(DbModelBuilderVersion.Latest);
modelBuilder.HasDefaultSchema(GetSchema());
var entityMethod = typeof(DbModelBuilder).GetMethod("Entity");
_modelTypeMap.Values.ToList().ForEach(aModel =>
{
entityMethod.MakeGenericMethod(aModel).Invoke(modelBuilder, null);
});
var theModel = modelBuilder.Build(connection).Compile();
DbCompiledModelInfo info = new DbCompiledModelInfo
{
ConStr = connection.ConnectionString,
DatabaseType = dbType,
DbCompiledModel = theModel
};
return(info);
string GetSchema()
{
switch (dbType)
{
case DatabaseType.SqlServer: return("dbo");
case DatabaseType.MySql:
case DatabaseType.PostgreSql: return("public");
case DatabaseType.Oracle: return(new OracleConnectionStringBuilder(connection.ConnectionString).UserID);;
default: return("dbo");
}
}
}
}
/// <summary>
/// 获取指定的数据库帮助类
/// </summary>
/// <param name="dbType">数据库类型字符串</param>
/// <param name="conStr">连接字符串</param>
/// <returns></returns>
public static DbHelper GetDbHelper(string dbTypeStr, string conStr)
{
DatabaseType dbType = DbProviderFactoryHelper.DbTypeStrToDbType(dbTypeStr);
return(GetDbHelper(dbType, conStr));
}
