public EntityQuery(IDapperImplementor implementor, IDapperSession session, Expression <Func <T, bool> > expression)
{
_session = session;
_expression = expression;
_implementor = implementor;
_sort = new List <ISort>();
}
public EntityBuilder(IDapperSession session, Expression <Func <T, bool> > expression, IDapperImplementor dapperImplementor)
{
_dapperImplementor = dapperImplementor;
_session = session;
_expression = expression;
_sort = new List <ISort>();
}
/// <summary>
/// Gets the Dapper Extensions Implementation
/// </summary>
public static IDapperImplementor Instance(DataBaseType dbType = DefaultDBType)
{
IDapperImplementor instance;
if (!_instanceList.TryGetValue(dbType, out instance))
{
ISqlDialect sqlDialect;
switch (dbType)
{
case DataBaseType.SqlServer: sqlDialect = new SqlServerDialect(); break;
case DataBaseType.Oracle: sqlDialect = new OracleDialect(); break;
case DataBaseType.MySql: sqlDialect = new MySqlDialect(); break;
default: sqlDialect = new SqlServerDialect(); break;
}
IDapperExtensionConfiguration iDapperExtensionsConfiguration = new DapperExtensionConfiguration(
typeof(AutoClassMapper <>),
new List <Assembly>(),
sqlDialect
);
instance = InstanceFactory(iDapperExtensionsConfiguration, dbType);
_instanceList[dbType] = instance;
}
if (null == _DapperImplementor || _DapperImplementor.DbType != dbType)
{
_DapperImplementor = instance;
}
return(instance);
}
/// <summary>
/// Gets the Dapper Extensions Implementation
/// </summary>
private static IDapperImplementor Instance(DatabaseType databaseType = DatabaseType.SqlServer)
{
if (!_instanceList.ContainsKey(databaseType))
{
lock (_instanceList)
{
if (!_instanceList.ContainsKey(databaseType))
{
switch (databaseType)
{
case DatabaseType.SqlServer:
_instance = InstanceFactory(new DapperExtensionsConfiguration(typeof(AutoClassMapper <>), new List <Assembly>(), new SqlServerDialect()));
_instanceList.Add(databaseType, _instance);
break;
case DatabaseType.Oracle:
_instance = InstanceFactory(new DapperExtensionsConfiguration(typeof(AutoClassMapper <>), new List <Assembly>(), new OracleDialect()));
_instanceList.Add(databaseType, _instance);
break;
case DatabaseType.MySql:
_instance = InstanceFactory(new DapperExtensionsConfiguration(typeof(AutoClassMapper <>), new List <Assembly>(), new MySqlDialect()));
_instanceList.Add(databaseType, _instance);
break;
default:
_instance = InstanceFactory(new DapperExtensionsConfiguration(typeof(AutoClassMapper <>), new List <Assembly>(), new SqlServerDialect()));
_instanceList.Add(databaseType, _instance);
break;
}
}
}
}
return(_instanceList[databaseType]);
}
public static void InsertUpdateOnDuplicateKey <T>(this IDapperImplementor implementor, IDbConnection connection, IEnumerable <T> entities, int?commandTimeout = null) where T : class
{
IClassMapper classMap = implementor.SqlGenerator.Configuration.GetMap <T>();
var properties = classMap.Properties.Where(p => p.KeyType != KeyType.NotAKey);
string emptyGuidString = Guid.Empty.ToString();
foreach (var e in entities)
{
foreach (var column in properties)
{
if (column.KeyType == KeyType.Guid)
{
object value = column.PropertyInfo.GetValue(e, null);
string stringValue = value.ToString();
if (!string.IsNullOrEmpty(stringValue) && stringValue != emptyGuidString)
{
continue;
}
Guid comb = implementor.SqlGenerator.Configuration.GetNextGuid();
column.PropertyInfo.SetValue(e, comb, null);
}
}
}
string sql = implementor.SqlGenerator.InsertUpdateOnDuplicateKey(classMap);
connection.Execute(sql, entities, null, commandTimeout, CommandType.Text);
}
public static SqlMapper.GridReader QueryMultiple(this IDapperImplementor impl, IDbConnection connection, string sql, object param, IDbTransaction transaction, int?commandTimeout)
{
if (connection.State != ConnectionState.Open)
{
connection.Open();
}
return(connection.QueryMultiple(sql, param, transaction, commandTimeout));
}
public static T ExecuteScalar <T>(this IDapperImplementor impl, IDbConnection connection, string sql, object param, IDbTransaction transaction, int?commandTimeout)
{
if (connection.State != ConnectionState.Open)
{
connection.Open();
}
return(connection.ExecuteScalar <T>(sql, param, transaction, commandTimeout, CommandType.Text));
}
private DbContext(bool enablePool)
{
_enablePool = enablePool;
var sqlGenerator = DapperConfigurationXml.ConfigurationInstance.GetSqlGenerator();
_dapperImplementor = new DapperImplementor(sqlGenerator);
_connection = DapperConfigurationXml.ConfigurationInstance.GetConnection();
}
public virtual void Setup()
{
string databaseName = string.Format("db_{0}.s3db", Guid.NewGuid().ToString());
TestHelpers.LoadDatabase(databaseName);
Connection = TestHelpers.GetConnection(databaseName);
Impl = new DapperImplementor(TestHelpers.GetGenerator());
}
public static T QueryFirstOrDefault <T>(this IDapperImplementor impl, IDbConnection connection, string sql, object param, IDbTransaction transaction, int?commandTimeout)
{
if (connection.State != ConnectionState.Open)
{
connection.Open();
}
return(connection.QueryFirst <T>(sql, param, transaction, commandTimeout));
}
public static IEnumerable <T> Query <T>(this IDapperImplementor impl, IDbConnection connection, string sql, object param, IDbTransaction transaction, int?commandTimeout)
{
if (connection.State != ConnectionState.Open)
{
connection.Open();
}
return(connection.Query <T>(sql, param, transaction, true, commandTimeout, CommandType.Text));
}
public Database(IDbConnection connection, IDapperImplementor dapperImplementor)
{
_dapper = dapperImplementor;
Connection = connection;
if (Connection.State != ConnectionState.Open)
{
Connection.Open();
}
}
public Database(IOptions <DataBaseOptions> options, IDapperExtensionsConfiguration Configuration)
{
_dapper = new DapperImplementor(new SqlGeneratorImpl(Configuration));
Connection = options.Value.DbConnection();
if (Connection.State != ConnectionState.Open)
{
Connection.Open();
}
}
public Database(IDbConnection connection, ISqlGenerator sqlGenerator)
{
_dapper = new DapperImplementor(sqlGenerator);
Connection = connection;
if (Connection.State != ConnectionState.Open)
{
Connection.Open();
}
}
public Database(IDbConnection connection, ISqlGenerator sqlGenerator)
{
_dapper = new DapperImplementor(sqlGenerator);
Connection = connection;
//SqlHelper = new Sql.SqlServerHelper(connection.ConnectionString);
if (Connection.State != ConnectionState.Open)
{
Connection.Open();
}
}
public Database(IDbConnection connection)
{
Connection = connection;
Commands = Create.New<ISqlCommandHelper>();
Transaction = Create.New<ITransactionHelper>();
_dapper = Create.New<IDapperImplementor>();
if (Connection.State != ConnectionState.Open)
Connection.Open();
}
static Repository()
{
//1
//DapperExtensions.Core20.DapperExtensions.DefaultMapper = typeof(CustomPluralizedAutoClassMapper<>);
//DapperExtensions.Core20.DapperExtensions.SqlDialect = new MySqlDialect();
//DapperExtensions.DapperExtensions.Configure(
// typeof(CustomPluralizedAutoClassMapper<>),
// new List<Assembly>(),
// new MySqlDialect());
_dapperConfig = new DapperExtensionsConfiguration(typeof(CustomPluralizedAutoClassMapper <>), new List <Assembly>(), new MySqlDialect());
//使用connection
DapperExtensionsCore.DapperExtensions.Configure(_dapperConfig);
DapperExtensionsCore.DapperAsyncExtensions.Configure(_dapperConfig);
//使用instance
_dapperInstance = DapperExtensionsCore.DapperExtensions.InstanceFactory.Invoke(_dapperConfig);
_dapperAsyncInstance = DapperExtensionsCore.DapperAsyncExtensions.InstanceFactory.Invoke(_dapperConfig);
}
/// <summary>
/// Configure DapperExtensions extension methods.
/// </summary>
/// <param name="defaultMapper"></param>
/// <param name="mappingAssemblies"></param>
/// <param name="sqlDialect"></param>
public static void Configure(IDapperExtensionsConfiguration configuration)
{
_instance = null;
_configuration = configuration;
}
/// <summary>
/// Gets the Dapper Extensions Implementation
/// </summary>
private static IDapperImplementor Instance()
{
_instance = InstanceFactory(new DapperExtensionsConfiguration(typeof(AutoClassMapper <>), new List <Assembly>(), new SqlServerDialect()));
return(_instance);
}
public Database(IDbConnection connection, ISqlGenerator sqlGenerator)
{
_dapper = new DapperImplementor(sqlGenerator);
Connection = connection;
}
public DapperRepository(IDapperSessionContext sessionContext, IDapperImplementor dapperImplementor)
{
_dapperImplementor = dapperImplementor;
_sessionContext = sessionContext;
}
public DapperInstances(IDapperImplementor dapperImplementor, IDapperAsyncImplementor dapperAsyncImplementor)
{
DapperImplementor = dapperImplementor;
DapperAsyncImplementor = dapperAsyncImplementor;
}
public DapperRepository()
{
_dapperImplementor = new DapperImplementor(new SqlGeneratorImpl(DapperConfiguration.Instance));
_sessionContext = new DapperSessionContext();
session = _sessionContext.GetSession <T>();
}
protected virtual void ClearCache(IDapperImplementor dapper)
{
dapper.SqlGenerator.Configuration.ClearCache();
}
/// <summary>
/// 活动Dapper扩展对象的实例
/// </summary>
/// <param name="dbType">DB类型，默认SqlServer</param>
/// <param name="ormMapperAssemblyList">ORM映射的程序集</param>
/// <returns></returns>
public static IDapperImplementor Instance(DataBaseType dbType = DefaultDBType, List <string> ormMapperAssemblyList = null)
{
IDapperImplementor instance;
if (!_instanceList.TryGetValue(dbType, out instance))
{
ISqlDialect sqlDialect;
switch (dbType)
{
case DataBaseType.SqlServer: sqlDialect = new SqlServerDialect(); break;
case DataBaseType.Oracle: sqlDialect = new OracleDialect(); break;
case DataBaseType.MySql: sqlDialect = new MySqlDialect(); break;
default: sqlDialect = new SqlServerDialect(); break;
}
List <Assembly> assemblyList = new List <Assembly>();
if (ormMapperAssemblyList != null)
{
foreach (var item in ormMapperAssemblyList)
{
assemblyList.Add(Assembly.Load(item));
}
}
else
{
if (!string.IsNullOrEmpty(ormMapperAssemblyStr))
{
foreach (var item in ormMapperAssemblyStr.Split(';'))
{
if (!string.IsNullOrEmpty(item))
{
assemblyList.Add(Assembly.Load(item));
}
}
}
}
IDapperExtensionConfiguration iDapperExtensionsConfiguration = new DapperExtensionConfiguration(
typeof(AutoClassMapper <>),
assemblyList,
sqlDialect
);
instance = InstanceFactory(iDapperExtensionsConfiguration, dbType);
_instanceList[dbType] = instance;
}
if (!IsEnabledMultipleDBType)
{
if (null == _DapperImplementor)
{
_DapperImplementor = instance;
}
}
else
{
if (null == _DapperImplementor_MultipleDBType || _DapperImplementor_MultipleDBType.DbType != dbType)
{
_DapperImplementor_MultipleDBType = instance;
}
}
return(instance);
}
public Db(IDbConnection connection, ISqlGenerator sqlGenerator) : base(connection, sqlGenerator)
{
_dapperIml = new DapperImplementor(sqlGenerator);
}
/// <summary>
/// Configure DapperExtensions extension methods.
/// </summary>
/// <param name="configuration"></param>
public static void Configure(IDapperExtensionsConfiguration configuration)
{
_implementorInstance = null;
_extensionsConfiguration = configuration;
}
/// <summary>
/// Configure Cissy.Dapper extension methods.
/// </summary>
/// <param name="defaultMapper"></param>
/// <param name="mappingAssemblies"></param>
/// <param name="sqlDialect"></param>
public static void Configure(ICissyDapperConfiguration configuration)
{
_instance = null;
_configuration = configuration;
}
