/// <summary>获取属性映射的数据库字段的名称
/// </summary>
protected static string GetMapName(MemberInfo memberInfo)
{
var entityMap = FluentMapConfiguration.GetMap(memberInfo.DeclaringType);
var propertyMap = entityMap?.PropertyMaps.FirstOrDefault(x => x.PropertyInfo.Name == memberInfo.Name);
return(propertyMap == null ? memberInfo.Name : propertyMap.ColumnName);
}
/// <summary>
///
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="config"></param>
/// <param name="mapping"></param>
public static void AddEntityMapping <T>(this FluentMapConfiguration config, IEntityMap <T> mapping) where T : class, IEntity
{
if (!FluentMapper.EntityMaps.ContainsKey(mapping.GetType()))
{
config.AddMap(mapping);
}
}
/// <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);
}
public static void Initialize(FluentMapConfiguration config)
{
config.AddMap(new BrandEntityMap());
config.AddMap(new CategoryEntityMap());
config.AddMap(new ProductEntityMap());
config.AddMap(new ProductCopyEntityMap());
config.AddMap(new ProductImageEntityMap());
}
/// <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 ForAgileMap(this FluentMapConfiguration config)
{
AgileMapper.SetColumnNameResolver(new AgileColumnNameResolver());
AgileMapper.SetKeyPropertyResolver(new AgileKeyPropertyResolver());
AgileMapper.SetTableNameResolver(new AgileTableNameResolver());
AgileMapper.SetPropertyResolver(new AgilePropertyResolver());
return(config);
}
private void AddMap <TMap, T>(FluentMapConfiguration mapConfiguration)
where TMap : DapperMapperBase <T>, new()
where T : class
{
TMap map = new TMap();
mapConfiguration.AddMap(map);
}
/// <summary>
/// Configures the specified configuration for Dapper.FluentMap.Nona.
/// </summary>
/// <param name="config">The Dapper.FluentMap configuration.</param>
/// <returns>
/// The Dapper.FluentMap configuration.
/// </returns>
public static FluentMapConfiguration ApplyToNona(this FluentMapConfiguration config)
{
NonaMapper.SetColumnNameResolver(new NonaColumnNameResolver());
NonaMapper.SetDataColumnResolver(new NonaDataColumnResolver());
NonaMapper.SetKeyPropertyResolver(new NonaKeyPropertyResolver());
NonaMapper.SetTableNameResolver(new NonaTableNameResolver());
NonaMapper.SetPropertyResolver(new NonaPropertyResolver());
return(config);
}
public static void AddMapFromCurrentAssembly(this FluentMapConfiguration configuration)
{
var method = configuration.GetType().GetMethod("AddMap");
Assembly.GetExecutingAssembly().GetTypes()
.Where(t => typeof(IEntityMap).IsAssignableFrom(t))
.Each(t =>
{
method.MakeGenericMethod(t.GetInterfaces()
.First(i => i.IsGenericType)
.GetGenericArguments().First())
.Invoke(configuration, new[] { Activator.CreateInstance(t) });
});
}
/// <summary>
/// Finds all types, from provided assemblies, implementing <see cref="EntityMap{TEntity}"/>
/// and applies them to <see cref="FluentMapConfiguration"/>,
/// by calling <see cref="FluentMapConfiguration.AddMap{TEntity}"/> and passing an instance of found type.
/// </summary>
/// <param name="configuration">The <see cref="FluentMapConfiguration"/> instance.</param>
/// <param name="assemblies">The assemblies to scan for entity maps.</param>
public static void ApplyMapsFromAssemblies(this FluentMapConfiguration configuration, params Assembly[] assemblies)
{
if (assemblies == null)
{
throw new ArgumentNullException(nameof(assemblies));
}
var entityMapTypes = FindTypesImplementingIEntityMap(assemblies);
if (!entityMapTypes.Any())
{
return;
}
EnsureNoDuplicateMapping(entityMapTypes);
AddMaps(configuration, entityMapTypes);
}
public void FluentMapConfiguration_Test()
{
var assemblyList = new List <Assembly>()
{
Assembly.GetExecutingAssembly()
};
FluentMapConfiguration.Register(() => new TestMapUser());
FluentMapConfiguration.Initialize(assemblyList);
var entityMap = FluentMapConfiguration.GetMap(typeof(TestUser));
var entityMap1 = FluentMapConfiguration.GetMap <TestUser>();
Assert.Equal(entityMap, entityMap1);
Assert.Equal("T1", entityMap.TableName);
Assert.Equal(3, entityMap.PropertyMaps.Count);
var type = typeof(TestUser);
Assert.Equal(type, entityMap.GetEntityType());
foreach (
var propertyInfo in type.GetProperties(BindingFlags.GetProperty | BindingFlags.Instance | BindingFlags.Public))
{
var propertyMap = entityMap.PropertyMaps.FirstOrDefault(x => x.PropertyInfo == propertyInfo);
if (propertyMap != null)
{
if (propertyInfo.Name == "UserId")
{
Assert.Equal("uid", propertyMap.ColumnName);
}
if (propertyInfo.Name == "UserName")
{
Assert.Equal("tb_UserName", propertyMap.ColumnName);
}
if (propertyInfo.Name == "Age")
{
Assert.Equal(true, propertyMap.Ignored);
}
}
}
}
/// <summary>根据类型获取表名称
/// </summary>
protected static string GetTableName(Type type)
{
var entityMap = FluentMapConfiguration.GetMap(type);
return(entityMap == null ? type.Name : entityMap.TableName);
}
