/// <summary>
/// Query ALL
/// 查询全部。
/// </summary>
/// <typeparam name="TEntity">类型参数</typeparam>
/// <param name="connection">DbConnection</param>
/// <returns>TEntity 集合</returns>
public static IEnumerable <TEntity> QueryALL <TEntity>(this IDbConnection connection) where TEntity : class
{
try
{
return(DommelMapper.GetAll <TEntity>(connection));
}
catch (Exception ex) { throw new Exception(ex.Message); }
}
/// <summary>
/// Configures the specified configuration for Dapper.FluentMap.Dommel.
/// </summary>
/// <param name="config">The Dapper.FluentMap configuration.</param>
/// <returns>The Dapper.FluentMap configuration.</returns>
public static FluentMapConfiguration ForDommel(this FluentMapConfiguration config)
{
DommelMapper.SetColumnNameResolver(new DommelColumnNameResolver());
DommelMapper.SetKeyPropertyResolver(new DommelKeyPropertyResolver());
DommelMapper.SetTableNameResolver(new DommelTableNameResolver());
DommelMapper.SetPropertyResolver(new DommelPropertyResolver());
return(config);
}
/// <summary>
/// Delete
/// 根据条件删除。
/// </summary>
/// <typeparam name="TEntity">类型参数</typeparam>
/// <param name="connection">DbConnection</param>
/// <param name="predicate">表达式目录树</param>
/// <param name="transaction">事务</param>
/// <returns>bool</returns>
public static bool Delete <TEntity>(this IDbConnection connection, Expression <Func <TEntity, bool> > predicate, IDbTransaction transaction = null)
{
try
{
return(DommelMapper.DeleteMultiple <TEntity>(connection, predicate, transaction));
}
catch (Exception ex) { throw new Exception(ex.Message); }
}
/// <summary>
/// Query FirstOrDefault
/// 匹配的第一个实体，如果没有匹配的实体，则选择默认值。
/// </summary>
/// <typeparam name="TEntity">类型参数</typeparam>
/// <param name="connection">DbConnection</param>
/// <param name="predicate">条件表达式目录树</param>
/// <returns>TEntity 集合</returns>
public static TEntity FirstOrDefault <TEntity>(this IDbConnection connection, Expression <Func <TEntity, bool> > predicate)
{
try
{
return(DommelMapper.FirstOrDefault(connection, predicate));
}
catch (Exception ex) { throw new Exception(ex.Message); }
}
public Repository()
{
DommelMapper.SetTableNameResolver(new DefaultTableNameResolver());
DommelMapper.SetKeyPropertyResolver(new DefaultKeyPropertyResolver());
DommelMapper.SetColumnNameResolver(new DefaultColumnNameResolver());
DommelMapper.SetPropertyResolver(new DefaultPropertyResolver());
DommelMapper.SetForeignKeyPropertyResolver(new DefaultForeignKeyPropertyResolver());
}
/// <summary>
/// Delete ALL
/// 删除全部。
/// </summary>
/// <typeparam name="TEntity">类型参数</typeparam>
/// <param name="connection">DbConnection</param>
/// <param name="transaction">事务</param>
/// <returns>bool</returns>
public static bool DeleteAll <TEntity>(this IDbConnection connection, IDbTransaction transaction = null)
{
try
{
return(DommelMapper.DeleteAll <TEntity>(connection, transaction));
}
catch (Exception ex) { throw new Exception(ex.Message); }
}
/// <summary>
/// Update
/// 根据传入实体修改。
/// </summary>
/// <typeparam name="TEntity">类型参数</typeparam>
/// <param name="connection">DbConnection</param>
/// <param name="entity">实体数据信息</param>
/// <param name="transaction">事务</param>
/// <returns>bool</returns>
public static bool Update <TEntity>(this IDbConnection connection, TEntity entity, IDbTransaction transaction = null)
{
try
{
return(DommelMapper.Update <TEntity>(connection, entity, transaction));
}
catch (Exception ex) { throw new Exception(ex.Message); }
}
/// <summary>
/// Query
/// 根据主键“ID”
/// </summary>
/// <typeparam name="TEntity">类型参数</typeparam>
/// <param name="connection">DbConnection</param>
/// <param name="id">主键ID值</param>
/// <returns>TEntity</returns>
public static TEntity Query <TEntity>(this IDbConnection connection, object id) where TEntity : class
{
try
{
return(DommelMapper.Get <TEntity>(connection, id));
}
catch (Exception ex) { throw new Exception(ex.Message); }
}
public RuntimeInitializer DefaultMapper(Type type)
{
DapperExtensions.DapperExtensions.DefaultMapper = type;
DommelMapper.SetTableNameResolver(new TableNameResolver());
DommelMapper.SetKeyPropertyResolver(new KeyPropertyResolver());
DommelMapper.SetColumnNameResolver(new ColumnNameResolver());
return(this);
}
private void InitializeEntityMappings()
{
FluentMapper.Initialize(config =>
{
config.ForDommel();
DommelMapper.SetKeyPropertyResolver(new PrimaryKeyResolver());
DommelMapper.SetTableNameResolver(new TableNameResolver());
});
}
/// <summary>
/// Insert SQL
/// return bool
/// </summary>
/// <typeparam name="TEntity">类型参数</typeparam>
/// <param name="connection">DbConnection</param>
/// <param name="entity">entity</param>
/// <param name="transaction">DbTransaction</param>
/// <returns>object</returns>
public static bool Insert <TEntity>(this IDbConnection connection, TEntity entity, IDbTransaction transaction = null) where TEntity : class
{
try
{
DommelMapper.Insert <TEntity>(connection, entity, transaction);
return(true);
}
catch (Exception ex) { throw new Exception(ex.Message); }
}
public ParameterPrefixTest()
{
mock.As <IDbConnection>().SetupDapper(x => x.QueryFirstOrDefault <FooParameterPrefix>(It.IsAny <string>(), It.IsAny <object>(), null, null, null))
.Returns(new FooParameterPrefix());
var connectionType = mock.Object.GetType();
// Change the default Sql Connection
DommelMapper.AddSqlBuilder(connectionType, new ExampleBuilderBuilder());
}
/// <summary>
/// Configures Dommel JSON support using the specified <see cref="DommelJsonOptions"/>.
/// </summary>
/// <param name="options"></param>
public static void AddJson(DommelJsonOptions options)
{
if (options == null)
{
throw new ArgumentNullException(nameof(options));
}
if (options.EntityAssemblies == null || options.EntityAssemblies.Length == 0)
{
throw new ArgumentException("No entity assemblies specified.", nameof(options));
}
// Add SQL builders with JSON value support
DommelMapper.AddSqlBuilder("sqlconnection", new SqlServerSqlBuilder());
DommelMapper.AddSqlBuilder("sqlceconnection", new SqlServerCeSqlBuilder());
DommelMapper.AddSqlBuilder("sqliteconnection", new SqliteSqlBuilder());
DommelMapper.AddSqlBuilder("npgsqlconnection", new PostgresSqlBuiler());
DommelMapper.AddSqlBuilder("mysqlconnection", new MySqlSqlBuilder());
// Add a custom SqlExpression<T> factory with JSON support
DommelMapper.SqlExpressionFactory = (type, sqlBuilder) =>
{
if (!(sqlBuilder is IJsonSqlBuilder))
{
throw new InvalidOperationException($"The specified SQL builder type should be assignable from {nameof(IJsonSqlBuilder)}.");
}
var sqlExpression = typeof(JsonSqlExpression <>).MakeGenericType(type);
return(Activator.CreateInstance(sqlExpression, sqlBuilder));
};
// Add a Dapper type mapper with JSON support for
// properties annotated with the [JsonData] attribute.
var jsonTypeHander = options.JsonTypeHandler?.Invoke() ?? new JsonObjectTypeHandler();
var jsonTypes = new List <Type>();
foreach (var assembly in options.EntityAssemblies)
{
foreach (var type in assembly.ExportedTypes)
{
foreach (var property in type.GetRuntimeProperties())
{
var jsonAttr = property.GetCustomAttribute <JsonDataAttribute>();
if (jsonAttr != null)
{
SqlMapper.AddTypeHandler(property.PropertyType, jsonTypeHander);
jsonTypes.Add(property.PropertyType);
}
}
}
}
// Set a property resolver which considers the types discovered above
// as primitive types so they will be used in insert and update queries.
DommelMapper.SetPropertyResolver(new JsonPropertyResolver(jsonTypes));
}
static DataSource()
{
SqlMapper.AddTypeHandler <JObject>(new JObjectHandler());
FluentMapper.Initialize(config =>
{
config.AddMap(new TokenDbMap());
config.ApplyToDommel();
});
DommelMapper.SetPropertyResolver(new DommelPropertyResolverForCustomTypes());
}
public long GetList_Count(Expression <Func <T, bool> > filter = null)
{
_tableName = typeof(T).Name;
using (var connection = CreateConnection())
{
DommelMapper.SetTableNameResolver(new CustomTableNameResolver());
return(filter == null
? connection.QueryFirstOrDefault <long>($"SELECT COUNT(1) FROM {_tableName}")
: connection.Count <T>(filter));
}
}
public IEnumerable <T> GetList(Expression <Func <T, bool> > filter = null)
{
_tableName = typeof(T).Name;
using (var connection = CreateConnection())
{
DommelMapper.SetTableNameResolver(new CustomTableNameResolver());
return(filter == null
? connection.Query <T>($"SELECT * FROM {_tableName}")
: connection.Select(filter));
}
}
static GuildConfigRepository()
{
FluentMapper.Initialize(config =>
{
config
.AddConvention <LowerCaseConvention>()
.ForEntity <GuildConfigEntity>();
config.ForDommel();
DommelMapper.SetColumnNameResolver(new LowerCaseConvention());
DommelMapper.AddSqlBuilder(typeof(NpgsqlConnection), new PostgresSqlBuilder());
});
}
public void GetBuilderLogsChosenBuilder()
{
// Arrange
var logs = new List <string>();
var mock = new Mock <IDbConnection>();
DommelMapper.LogReceived = s => logs.Add(s);
// Act
DommelMapper.GetSqlBuilder(mock.Object);
// Assert
Assert.True(logs.Count > 0);
Assert.Contains("Selected SQL Builder 'SqlServerSqlBuilder' for connection type 'IDbConnectionProxy'", logs);
}
protected virtual async Task DropTables()
{
using var con = GetConnection(DefaultDatabaseName);
var sqlBuilder = DommelMapper.GetSqlBuilder(con);
string Quote(string s) => sqlBuilder.QuoteIdentifier(s);
await con.ExecuteAsync($@"
DROP TABLE {Quote("Categories")};
DROP TABLE {Quote("Products")};
DROP TABLE {Quote("ProductsCategories")};
DROP TABLE {Quote("ProductOptions")};
DROP TABLE {Quote("Orders")};
DROP TABLE {Quote("OrderLines")};
DROP TABLE {Quote("Foos")};
DROP TABLE {Quote("Bars")};
DROP TABLE {Quote("Bazs")};");
}
/// <summary>
/// Query
/// 根据条件查询。
/// </summary>
/// <typeparam name="TEntity">类型参数</typeparam>
/// <param name="connection">DbConnection</param>
/// <param name="predicate">条件表达式目录树</param>
/// <returns>TEntity 集合</returns>
public static IEnumerable <TEntity> Query <TEntity>(this IDbConnection connection, Expression <Func <TEntity, bool> > predicate)
{
try
{
if (SqlCheck.Check <TEntity>(predicate))
{
DynamicParameters parameters;
var querySQL = BuildSelectSql(predicate, out parameters);
return(SqlMapper.Query <TEntity>(connection, querySQL, parameters));
}
else
{
return(DommelMapper.Select <TEntity>(connection, predicate));
}
}
catch (Exception ex) { throw new Exception(ex.Message); }
}
static YuGiOhRepository()
{
FluentMapper.Initialize(config =>
{
config
.AddConvention <LowerCaseConvention>()
.ForEntity <CardEntity>()
.ForEntity <BoosterPackEntity>();
config.AddMap(new CardEntityMapper());
config.AddMap(new BoosterPackEntityMapper());
config.ForDommel();
var resolver = new LowerCaseConvention();
DommelMapper.SetColumnNameResolver(resolver);
DommelMapper.AddSqlBuilder(typeof(NpgsqlConnection), new PostgresSqlBuilder());
});
}
private void CreateMapper()
{
FluentMapper.Initialize(configuration =>
{
configuration.ForDommel();
DommelMapper.SetPropertyResolver(new CustomPropertyResolver());
});
foreach (KeyValuePair <Type, IEntityMap> key in FluentMapper.EntityMaps)
{
ICustomDapperMapper customMapper = key.Value as ICustomDapperMapper;
if (customMapper != null)
{
customMapper.Map();
}
}
SqlMapper.AddTypeHandler(new NullableLongHandler());
}
public async Task InsertGuidPrimaryKey()
{
if (CI.IsTravis)
{
// Don't run SQL Server test on Linux
return;
}
using (var con = new SqlServerDatabaseDriver().GetConnection())
{
await con.ExecuteAsync("CREATE TABLE dbo.Quxs (Id UNIQUEIDENTIFIER NOT NULL DEFAULT NEWID(), Name VARCHAR(255));");
try
{
object identity;
try
{
DommelMapper.AddSqlBuilder(typeof(SqlConnection), new GuidSqlServerSqlBuilder());
identity = await con.InsertAsync(new Qux { Name = "blah" });
}
finally
{
DommelMapper.AddSqlBuilder(typeof(SqlConnection), new DommelMapper.SqlServerSqlBuilder());
}
Assert.NotNull(identity);
var id = Assert.IsType <Guid>(identity);
var baz = await con.GetAsync <Qux>(id);
Assert.NotNull(baz);
Assert.Equal("blah", baz.Name);
Assert.Equal(id, baz.Id);
}
finally
{
await con.ExecuteAsync("DROP TABLE dbo.Quxs");
}
}
}
/// <summary>
/// 自定义相关解析注入
/// </summary>
static DapperExtensions()
{
DommelMapper.SetTableNameResolver(new CustomTableNameResolver()); //TableName
DommelMapper.SetKeyPropertyResolver(new CustomKeyPropertyResolver()); //Key
}
public override TEntity Get(TPrimaryKey id) => DommelMapper.Get <TEntity>(Connection, id, Transaction) ?? throw new Exception("EntityNotFoundException");
public Startup(IConfiguration configuration)
{
DommelMapper.SetTableNameResolver(new DommelTableNameResolver());
Configuration = configuration;
StaticConfig = configuration;
}
public static void Configure()
{
DommelMapper.SetTableNameResolver(new UnderscoreTableNameResolver());
DommelMapper.SetColumnNameResolver(new UnderscoreColumnNameResolver());
DefaultTypeMap.MatchNamesWithUnderscores = true;
}
public Startup(IConfiguration configuration)
{
this.Configuration = configuration;
DommelMapper.SetTableNameResolver(new CustomTableNameResolver());
}
