public TargetMapperBuilder(IDynamicAssembly assembly)
{
Assembly = assembly;
var mapperCache = new MapperCache();
_classMapperBuilder = new ClassMapperBuilder(mapperCache, this);
_collectionMapperBuilder = new CollectionMapperBuilder(mapperCache, this);
_convertibleTypeMapperBuilder = new ConvertibleTypeMapperBuilder(this);
_customTypeMapperBuilder = new CustomTypeMapperBuilder(this);
NameMatching = DefaultNameMatching;
}
protected override object MapCoreLoop(object source, object target)
{
var key = GetKey(source);
object rst;
var flag = MapperCache.TryGet(key, out rst);
if (flag)
{
return(rst);
}
var result = innerMapper(source, target, 0);
MapperCache.Set(key, result);
innerMapperRef?.Invoke(source, result, 0);
return(result);
}
/// <summary>
/// 批量转换
/// </summary>
/// <typeparam name="TSource">源类型</typeparam>
/// <typeparam name="TTarget">目标类型</typeparam>
/// <param name="source">源对象集合</param>
/// <returns>转换结果</returns>
public static IEnumerable <TTarget> Map <TSource, TTarget>(IEnumerable <TSource> source)
{
try
{
MapperUtil.PreMap(source);
var target = MapperUtil.MapCores <TSource, TTarget>(source, 0);
MapperUtil.PostMap(target);
return(target);
}
catch (Exception ex)
{
MapperUtil.OnError(ex);
throw;
}
finally
{
if (mapperConfig.ReferencePropertyHandle == ReferencePropertyHandle.Loop)
{
MapperCache.Clear();
}
}
}
/// <summary>
/// 转换对象
/// </summary>
/// <typeparam name="TSource">源类型</typeparam>
/// <typeparam name="TTarget">目标类型</typeparam>
/// <param name="source">源对象</param>
/// <param name="target">目标对象</param>
/// <returns>返回转换结果</returns>
public static TTarget Map <TSource, TTarget>(TSource source, TTarget target = default)
{
try
{
MapperUtil.PreMap(source);
target = MapperUtil.MapCore <TSource, TTarget>(source, target, 0);
MapperUtil.PostMap(target);
return(target);
}
catch (Exception ex)
{
MapperUtil.OnError(ex);
throw;
}
finally
{
if (mapperConfig.ReferencePropertyHandle == ReferencePropertyHandle.Loop)
{
MapperCache.Clear();
}
}
}
public MemberMapper(MapperCache mapperCache, IMapperBuilderConfig config)
{
_mapperCache = mapperCache;
_config = config;
}
public void AddMapper(MapperCache value)
{
MapperCache = value.ToOption();
}
public MemberEmitterDescription(IEmitter emitter, MapperCache mappers)
{
Emitter = emitter;
MapperCache = new Option <MapperCache>(mappers, mappers.IsEmpty);
}
public CollectionMapperBuilder(MapperCache mapperCache, IMapperBuilderConfig config) : base(config)
{
_mapperCache = mapperCache;
}
public ClassMapperBuilder(MapperCache mapperCache, IMapperBuilderConfig config) : base(config)
{
_mapperCache = mapperCache;
_memberMapper = new MemberMapper(mapperCache, config);
_mappingMemberBuilder = new MappingMemberBuilder(config);
}
/// <summary>Get or create a new mapper for the specified type and mapper key</summary>
/// <typeparam name="T">Generic type parameter.</typeparam>
/// <param name="mapperKey">The mapper key.</param>
/// <returns>A DapperPlusConfig<T></returns>
public static DapperPlusEntityMapper <T> Entity <T>(string mapperKey = null)
{
var config = MapperCache.GetOrAdd(GetFullMapperKey <T>(mapperKey), s => new DapperPlusEntityMapper <T>());
return((DapperPlusEntityMapper <T>)config);
}
public static IClassInfo ClassInfo(Type type)
{
return(MapperCache.GetClassInfo(type, Config));
}
/// <summary>
/// Zeroes out the primary key, disconnecting an item from the database
/// </summary>
/// <param name="obj"></param>
public static void Disconnect(object obj)
{
MapperCache.GetClassInfo(obj.GetType()).PrimaryKeyField.SetValue(obj, 0);
}
/// <summary>
/// Track changes to an object
/// </summary>
/// <param name="obj"></param>
public static void Track(object obj)
{
IObjectData data = MapperCache.GetOrCreateObjectData(obj);
}
/// <summary>
/// Clears all cached class metadata
/// </summary>
public static void ClearCache()
{
MapperCache.ClearCache();
}
