/// <summary>
/// Adds the configurator instance.
/// </summary>
/// <typeparam name="TFrom">The type of from.</typeparam>
/// <typeparam name="TTo">The type of to.</typeparam>
/// <param name="configurator">The configurator.</param>
public virtual void AddConfiguration <TFrom, TTo>(IMappingConfigurator configurator)
{
AssertCore.IsNotNull(configurator, "configurator");
MappingConfigurations.Add(new Tuple <Type, Type, IMappingConfigurator>(typeof(TFrom), typeof(TTo),
configurator));
}
private ObjectsMapperBaseImpl BuildObjectsMapper(
string MapperTypeName,
Type from,
Type to,
IMappingConfigurator mappingConfigurator)
{
TypeBuilder typeBuilder = DynamicAssemblyManager.DefineMapperType(MapperTypeName);
CreateTargetInstanceBuilder.BuildCreateTargetInstanceMethod(to, typeBuilder);
var mappingBuilder = new MappingBuilder(
this,
from,
to,
typeBuilder,
mappingConfigurator
);
mappingBuilder.BuildCopyImplMethod();
ObjectsMapperBaseImpl result =
(ObjectsMapperBaseImpl)Activator.CreateInstance(typeBuilder.CreateType());
result.Initialize(this, from, to, mappingConfigurator, mappingBuilder.storedObjects.ToArray());
return(result);
}
/// <summary>
/// Returns a mapper implementation instance for specified types.
/// </summary>
/// <Param name="from">Type of source object</Param>
/// <Param name="to">Type of destination object</Param>
/// <Param name="mappingConfigurator">Object which configures mapping.</Param>
/// <returns>Mapper</returns>
public ObjectsMapperBaseImpl GetMapperImpl(
Type from,
Type to,
IMappingConfigurator mappingConfigurator)
{
return(GetMapperInt(from, to, mappingConfigurator).mapper);
}
/// <summary>
/// 用自定义映射规则进行模型映射
/// </summary>
/// <param name="from"></param>
/// <param name="config">映射规则</param>
public static TTo Mapper <TFrom, TTo>(TFrom from, IMappingConfigurator mapConfig) where TFrom : class
{
var ignores = new List <string>();
//初始化忽略映射的属性
typeof(TFrom).GetProperties().ForEach(p =>
{
if (p.GetCustomAttributes(typeof(IgnoreMapperAttribute), false).Length > 0)
{
ignores.Add(p.Name);
}
});
typeof(TTo).GetProperties().ForEach(p =>
{
if (p.GetCustomAttributes(typeof(IgnoreMapperAttribute), false).Length > 0)
{
ignores.Add(p.Name);
}
});
if (mapConfig != null && mapConfig is MapConfigBase <TFrom> )
{
(mapConfig as MapConfigBase <TFrom>).IgnoreMembers <TFrom, TTo>(ignores.ToArray());
}
ObjectsMapper <TFrom, TTo> mapper = ObjectMapperManager.DefaultInstance.GetMapper <TFrom, TTo>(mapConfig);
return(mapper.Map(from));
}
public static QpDataContext Create(IMappingConfigurator configurator)
{
DbConnection connection;
connection = new NpgsqlConnection(DefaultConnectionString);
return(Create(configurator, connection));
}
public CustomMapperImpl(
ObjectMapperManager mapperMannager,
Type TypeFrom,
Type TypeTo,
IMappingConfigurator mappingConfigurator,
object[] storedObjects)
{
Initialize(mapperMannager, TypeFrom, TypeTo, mappingConfigurator, storedObjects);
}
public static void Map <TFrom, TTo>(TFrom from, TTo to, IMappingConfigurator mappingConfigurator = null)
{
//EmitMapper内部有缓存机制，故不需要再维护Mapper的缓存
var mapper = mappingConfigurator == null?
ObjectMapperManager.DefaultInstance.GetMapper <TFrom, TTo>() :
ObjectMapperManager.DefaultInstance.GetMapper <TFrom, TTo>(mappingConfigurator);
mapper.Map(from, to);
}
public CustomMapperImpl(
ObjectMapperManager mapperMannager,
Type TypeFrom,
Type TypeTo,
IMappingConfigurator mappingConfigurator,
object[] storedObjects)
{
Initialize(mapperMannager, TypeFrom, TypeTo, mappingConfigurator, storedObjects);
}
public static EF6Model Create(IMappingConfigurator configurator, SqlConnection connection, bool contextOwnsConnection)
{
var mapping = configurator.GetMappingInfo(connection);
var ctx = new EF6Model(connection, mapping.DbCompiledModel, mapping.Schema, contextOwnsConnection);
ctx.SiteName = mapping.Schema.Schema.SiteName;
ctx.ConnectionString = connection.ConnectionString;
return(ctx);
}
/// <summary>
/// Initializes a new instance of the <see cref="CustomMapper" /> class.
/// </summary>
/// <param name="objectMapperManager">The object mapper manager.</param>
/// <param name="typeFrom">The type from.</param>
/// <param name="typeTo">The type to.</param>
/// <param name="mappingConfigurator">The mapping configurator.</param>
/// <param name="storedObjects">The stored objects.</param>
protected CustomMapper(
Mapper objectMapperManager,
Type typeFrom,
Type typeTo,
IMappingConfigurator mappingConfigurator,
object[] storedObjects)
{
Initialize(objectMapperManager, typeFrom, typeTo, mappingConfigurator, storedObjects);
}
internal void Initialize(
EmitMapperManager MapperMannager,
Type TypeFrom,
Type TypeTo,
IMappingConfigurator mappingConfigurator,
object[] stroredObjects)
{
mapperMannager = MapperMannager;
typeFrom = TypeFrom;
typeTo = TypeTo;
_mappingConfigurator = mappingConfigurator;
StroredObjects = stroredObjects;
if (_mappingConfigurator != null)
{
_rootOperation = _mappingConfigurator.GetRootMappingOperation(TypeFrom, TypeTo);
if (_rootOperation == null)
{
_rootOperation = new RootMappingOperation(TypeFrom, TypeTo);
}
var constructor = _rootOperation.TargetConstructor;
if (constructor != null)
{
_targetConstructor = (DelegateInvokerFunc_0)DelegateInvoker.GetDelegateInvoker(constructor);
}
var valuesPostProcessor = _rootOperation.ValuesPostProcessor;
if (valuesPostProcessor != null)
{
_valuesPostProcessor = (DelegateInvokerFunc_2)DelegateInvoker.GetDelegateInvoker(valuesPostProcessor);
}
var converter = _rootOperation.Converter;
if (converter != null)
{
_converter = (DelegateInvokerFunc_2)DelegateInvoker.GetDelegateInvoker(converter);
}
var nullSubstitutor = _rootOperation.NullSubstitutor;
if (nullSubstitutor != null)
{
_nullSubstitutor = (DelegateInvokerFunc_0)DelegateInvoker.GetDelegateInvoker(nullSubstitutor);
}
var sourceFilter = _rootOperation.SourceFilter;
if (sourceFilter != null)
{
_sourceFilter = (DelegateInvokerFunc_2)DelegateInvoker.GetDelegateInvoker(sourceFilter);
}
var destinationFilter = _rootOperation.DestinationFilter;
if (destinationFilter != null)
{
_destinationFilter = (DelegateInvokerFunc_2)DelegateInvoker.GetDelegateInvoker(destinationFilter);
}
}
}
/// <summary>
/// Returns a Mapper instance for specified types.
/// </summary>
/// <typeparam name="TFrom">Type of source object</typeparam>
/// <typeparam name="TTo">Type of destination object</typeparam>
/// <Param name="mappingConfigurator">Object which configures mapping.</Param>
/// <returns>Mapper</returns>
public ObjectsMapper <TFrom, TTo> GetMapper <TFrom, TTo>(IMappingConfigurator mappingConfigurator)
{
return(new ObjectsMapper <TFrom, TTo>(
GetMapperImpl(
typeof(TFrom),
typeof(TTo),
mappingConfigurator
)
));
}
public TDestination Map <TSource, TDestination>(TSource tSource, IMappingConfigurator configs = null)
{
if (tSource == null)
{
return(default(TDestination));
}
var mapper = ObjectMapperManager.DefaultInstance.GetMapper <TSource, TDestination>(configs);
return(mapper.Map(tSource));
}
/// <summary>
/// 实体转换(EmitMapper)
/// </summary>
/// <typeparam name="TFrom">源类型</typeparam>
/// <typeparam name="TTo">目标类型</typeparam>
/// <param name="from">源对象</param>
/// <param name="mappingConfigurator">配置器</param>
/// <returns>目标对象</returns>
public static TTo Mapper <TFrom, TTo>(this TFrom from, IMappingConfigurator mappingConfigurator = null)
{
if (mappingConfigurator == null)
{
return(ObjectMapperManager.DefaultInstance.GetMapper <TFrom, TTo>().Map(from));
}
else
{
return(ObjectMapperManager.DefaultInstance.GetMapper <TFrom, TTo>(mappingConfigurator).Map(from));
}
}
public static QpDataContext Create(IMappingConfigurator configurator, DbConnection connection)
{
var mapping = configurator.GetMappingInfo();
var optionsBuilder = new DbContextOptionsBuilder <QpDataContext>();
optionsBuilder.UseNpgsql <QpDataContext>(connection);
optionsBuilder.UseModel(mapping.DbCompiledModel);
QpDataContext ctx = new QpDataContext(optionsBuilder.Options, mapping.Schema);
ctx.SiteName = mapping.Schema.Schema.SiteName;
ctx.ConnectionString = connection.ConnectionString;
return(ctx);
}
public MappingOperationsProcessor(MappingOperationsProcessor prototype)
{
LocFrom = prototype.LocFrom;
LocTo = prototype.LocTo;
LocState = prototype.LocState;
LocException = prototype.LocException;
CompilationContext = prototype.CompilationContext;
Operations = prototype.Operations;
StoredObjects = prototype.StoredObjects;
MappingConfigurator = prototype.MappingConfigurator;
ObjectsMapperManager = prototype.ObjectsMapperManager;
RootOperation = prototype.RootOperation;
StaticConvertersManager = prototype.StaticConvertersManager;
}
public MappingOperationsProcessor(MappingOperationsProcessor prototype)
{
locFrom = prototype.locFrom;
locTo = prototype.locTo;
locState = prototype.locState;
locException = prototype.locException;
compilationContext = prototype.compilationContext;
operations = prototype.operations;
storedObjects = prototype.storedObjects;
mappingConfigurator = prototype.mappingConfigurator;
objectsMapperManager = prototype.objectsMapperManager;
rootOperation = prototype.rootOperation;
staticConvertersManager = prototype.staticConvertersManager;
}
public MappingOperationsProcessor(MappingOperationsProcessor prototype)
{
locFrom = prototype.locFrom;
locTo = prototype.locTo;
locState = prototype.locState;
locException = prototype.locException;
compilationContext = prototype.compilationContext;
operations = prototype.operations;
storedObjects = prototype.storedObjects;
mappingConfigurator = prototype.mappingConfigurator;
objectsMapperManager = prototype.objectsMapperManager;
rootOperation = prototype.rootOperation;
staticConvertersManager = prototype.staticConvertersManager;
}
public MappingBuilder(
ObjectMapperManager objectsMapperManager,
Type from,
Type to,
TypeBuilder typeBuilder,
IMappingConfigurator mappingConfigurator
)
{
this._objectsMapperManager = objectsMapperManager;
this._from = from;
this._to = to;
this._typeBuilder = typeBuilder;
this.StoredObjects = new List <object>();
this._mappingConfigurator = mappingConfigurator;
}
public MappingBuilder(
EmitMapperManager objectsMapperManager,
Type from,
Type to,
TypeBuilder typeBuilder,
IMappingConfigurator mappingConfigurator
)
{
this.objectsMapperManager = objectsMapperManager;
this.from = from;
this.to = to;
this.typeBuilder = typeBuilder;
this.storedObjects = new List <object>();
this.mappingConfigurator = mappingConfigurator;
}
/// <summary>
/// Initializes a new instance of the <see cref="MappingBuilder" /> class.
/// </summary>
/// <param name="objectsMapperManager">The objects mapper manager.</param>
/// <param name="from">The from.</param>
/// <param name="to">The to.</param>
/// <param name="typeBuilder">The type builder.</param>
/// <param name="mappingConfigurator">The mapping configurator.</param>
public MappingBuilder(
Mapper objectsMapperManager,
Type from,
Type to,
TypeBuilder typeBuilder,
IMappingConfigurator mappingConfigurator)
{
_objectsMapperManager = objectsMapperManager;
_from = from;
_to = to;
_typeBuilder = typeBuilder;
StoredObjects = new List <object>();
_mappingConfigurator = mappingConfigurator;
}
public MappingBuilder(
ObjectMapperManager objectsMapperManager,
Type from,
Type to,
TypeBuilder typeBuilder,
IMappingConfigurator mappingConfigurator
)
{
this.objectsMapperManager = objectsMapperManager;
this.from = from;
this.to = to;
this.typeBuilder = typeBuilder;
this.storedObjects = new List<object>();
this.mappingConfigurator = mappingConfigurator;
}
protected NHConfigurationBuilder(
string defaultSchema,
string connectionString,
string dialect,
string showSql,
string useSecondLevelCache,
IMappingConfigurator mappingConfigurator)
{
DefaultSchema = defaultSchema;
ConnectionString = connectionString;
Dialect = dialect;
ShowSql = showSql;
UseSecondLevelCache = useSecondLevelCache;
_mappingConfigurator = mappingConfigurator;
}
public MapperPrimitiveImpl(ObjectMapperManager mapperMannager, Type TypeFrom, Type TypeTo, IMappingConfigurator mappingConfigurator)
: base(mapperMannager, TypeFrom, TypeTo, mappingConfigurator, null)
{
var to = TypeTo == typeof(IEnumerable) ? typeof(object) : TypeTo;
var from = TypeFrom == typeof(IEnumerable) ? typeof(object) : TypeFrom;
var staticConv = mappingConfigurator.GetStaticConvertersManager() ?? StaticConvertersManager.DefaultInstance;
var converterMethod = staticConv.GetStaticConverter(from, to);
if (converterMethod != null)
{
_converter = (MethodInvokerFunc_1)MethodInvoker.GetMethodInvoker(
null,
converterMethod
);
}
}
/// <summary>
/// object转换
/// </summary>
/// <typeparam name="TIn"></typeparam>
/// <typeparam name="TOut"></typeparam>
/// <param name="inData"></param>
/// <returns></returns>
public static void Register <TIn, TOut>(IMappingConfigurator config = null)
{
Type tin = typeof(TIn);
Type tout = typeof(TOut);
string typeKey = string.Concat(tin, "|", tout);
ObjectsMapper <TIn, TOut> mapper = null;
if (config == null)
{
mapper = ObjectMapperManager.DefaultInstance.GetMapper <TIn, TOut>();
}
else
{
mapper = ObjectMapperManager.DefaultInstance.GetMapper <TIn, TOut>(config);
}
_dictMapping[typeKey] = mapper.MapperImpl;
}
/// <summary>
/// Gets the configuration.
/// </summary>
/// <typeparam name="TFrom">The type of from.</typeparam>
/// <typeparam name="TTo">The type of to.</typeparam>
/// <returns>The configurator instance.</returns>
/// NOTE: Resolving from IoC can be added here.
protected virtual ObjectsMapper <TFrom, TTo> GetMapper <TFrom, TTo>()
{
var mapper = Mappers.FirstOrDefault(m => m is ObjectsMapper <TFrom, TTo>) as ObjectsMapper <TFrom, TTo>;
if (mapper == null)
{
Tuple <Type, Type, IMappingConfigurator> configuration =
MappingConfigurations.FirstOrDefault(mp =>
mp.Item1.IsAssignableFrom(typeof(TFrom)) && mp.Item2.IsAssignableFrom(typeof(TTo)));
IMappingConfigurator config = configuration == null ? DefaultConfigurator : configuration.Item3;
mapper = ObjectMapperManager.DefaultInstance.GetMapper <TFrom, TTo>(config);
Mappers.Add(mapper);
}
return(mapper);
}
/// <summary>
/// Creates an instance of Mapper for collections.
/// </summary>
/// <param name="MapperName">Mapper name. It is used for registration in Mappers repositories.</param>
/// <param name="mapperMannager">Mappers manager</param>
/// <param name="TypeFrom">Source type</param>
/// <param name="TypeTo">Destination type</param>
/// <param name="SubMapper"></param>
/// <returns></returns>
public static MapperForCollectionImpl CreateInstance(
string MapperName,
ObjectMapperManager mapperMannager,
Type TypeFrom,
Type TypeTo,
ObjectsMapperDescr SubMapper,
IMappingConfigurator mappingConfigurator
)
{
TypeBuilder tb = DynamicAssemblyManager.DefineType(
"GenericListInv_" + MapperName,
typeof(MapperForCollectionImpl)
);
if (TypeTo.IsGenericType() && TypeTo.GetGenericTypeDefinition() == typeof(List <>))
{
MethodBuilder methodBuilder = tb.DefineMethod(
"CopyToListInvoke",
MethodAttributes.Family | MethodAttributes.Virtual,
typeof(object),
new Type[] { typeof(IEnumerable) }
);
InvokeCopyImpl(TypeTo, "CopyToList").Compile(new CompilationContext(methodBuilder.GetILGenerator()));
methodBuilder = tb.DefineMethod(
"CopyToListScalarInvoke",
MethodAttributes.Family | MethodAttributes.Virtual,
typeof(object),
new Type[] { typeof(object) }
);
InvokeCopyImpl(TypeTo, "CopyToListScalar").Compile(
new CompilationContext(methodBuilder.GetILGenerator())
);
}
MapperForCollectionImpl result = (MapperForCollectionImpl)Activator.CreateInstance(tb.CreateTypeInfo().AsType());
result.Initialize(mapperMannager, TypeFrom, TypeTo, mappingConfigurator, null);
result.subMapper = SubMapper;
return(result);
}
public MapperPrimitiveImpl(ObjectMapperManager mapperMannager, Type TypeFrom, Type TypeTo, IMappingConfigurator mappingConfigurator)
: base(mapperMannager, TypeFrom, TypeTo, mappingConfigurator, null)
{
var to = TypeTo == typeof(IEnumerable) ? typeof(object) : TypeTo;
var from = TypeFrom == typeof(IEnumerable) ? typeof(object) : TypeFrom;
var staticConv = mappingConfigurator.GetStaticConvertersManager() ?? StaticConvertersManager.DefaultInstance;
var converterMethod = staticConv.GetStaticConverter(from, to);
if (converterMethod != null)
{
_converter = (MethodInvokerFunc_1)MethodInvoker.GetMethodInvoker(
null,
converterMethod
);
}
}
public static EF6Model Create(IMappingConfigurator configurator, SqlConnection connection)
{
return(Create(configurator, connection, true));
}
public static EF6Model Create(IMappingConfigurator configurator)
{
return(Create(configurator, new SqlConnection(DefaultConnectionString), true));
}
/// <summary>
/// Initializes the <see cref="MapperCore" /> class.
/// </summary>
static MapperCore()
{
_DefaultConfigurator = new DefaultMapConfig();
_Mappers = new ConcurrentBag <object>();
_MappingConfigurations = new ConcurrentBag <Tuple <Type, Type, IMappingConfigurator> >();
}
/// <summary>
/// </summary>
/// <param name="objectMapperManager">The object mapper manager.</param>
/// <param name="typeFrom">The type from.</param>
/// <param name="typeTo">The type to.</param>
/// <param name="mappingConfigurator">The mapping configurator.</param>
/// <param name="storedObjects">The stored objects.</param>
internal void Initialize(
Mapper objectMapperManager,
Type typeFrom,
Type typeTo,
IMappingConfigurator mappingConfigurator,
object[] storedObjects)
{
Mapper = objectMapperManager;
TypeFrom = typeFrom;
TypeTo = typeTo;
MappingConfigurator = mappingConfigurator;
StoredObjects = storedObjects;
if (MappingConfigurator != null)
{
RootOperation = MappingConfigurator.GetRootMappingOperation(typeFrom, typeTo)
?? new RootMappingOperation(typeFrom, typeTo);
var constructor = RootOperation.TargetConstructor;
if (constructor != null)
{
TargetConstructor = (DelegateInvokerFunc0)DelegateInvoker.GetDelegateInvoker(constructor);
}
var valuesPostProcessor = RootOperation.ValuesPostProcessor;
if (valuesPostProcessor != null)
{
ValuesPostProcessor = (DelegateInvokerFunc2)DelegateInvoker.GetDelegateInvoker(valuesPostProcessor);
}
var converter = RootOperation.Converter;
if (converter != null)
{
Converter = (DelegateInvokerFunc2)DelegateInvoker.GetDelegateInvoker(converter);
}
var nullSubstitutor = RootOperation.NullSubstitutor;
if (nullSubstitutor != null)
{
NullSubstitutor = (DelegateInvokerFunc0)DelegateInvoker.GetDelegateInvoker(nullSubstitutor);
}
var sourceFilter = RootOperation.SourceFilter;
if (sourceFilter != null)
{
SourceFilter = (DelegateInvokerFunc2)DelegateInvoker.GetDelegateInvoker(sourceFilter);
}
var destinationFilter = RootOperation.DestinationFilter;
if (destinationFilter != null)
{
DestinationFilter = (DelegateInvokerFunc2)DelegateInvoker.GetDelegateInvoker(destinationFilter);
}
}
}
public void Initialize(
ObjectMapperManager MapperMannager,
Type TypeFrom,
Type TypeTo,
IMappingConfigurator mappingConfigurator,
object[] stroredObjects)
{
mapperMannager = MapperMannager;
typeFrom = TypeFrom;
typeTo = TypeTo;
_mappingConfigurator = mappingConfigurator;
StroredObjects = stroredObjects;
if (_mappingConfigurator != null)
{
_rootOperation = _mappingConfigurator.GetRootMappingOperation(TypeFrom, TypeTo);
if (_rootOperation == null)
{
_rootOperation = new RootMappingOperation(TypeFrom, TypeTo);
}
var constructor = _rootOperation.TargetConstructor;
if (constructor != null)
{
_targetConstructor = (DelegateInvokerFunc_0)DelegateInvoker.GetDelegateInvoker(constructor);
}
var valuesPostProcessor = _rootOperation.ValuesPostProcessor;
if (valuesPostProcessor != null)
{
_valuesPostProcessor = (DelegateInvokerFunc_2)DelegateInvoker.GetDelegateInvoker(valuesPostProcessor);
}
var converter = _rootOperation.Converter;
if (converter != null)
{
_converter = (DelegateInvokerFunc_2)DelegateInvoker.GetDelegateInvoker(converter);
}
var nullSubstitutor = _rootOperation.NullSubstitutor;
if (nullSubstitutor != null)
{
_nullSubstitutor = (DelegateInvokerFunc_0)DelegateInvoker.GetDelegateInvoker(nullSubstitutor);
}
}
}
internal ObjectsMapperDescr GetMapperInt(
Type from,
Type to,
IMappingConfigurator mappingConfigurator)
{
lock (this)
{
if (to == null)
{
to = typeof(object);
}
if (from == null)
{
from = typeof(object);
}
MapperKey MapperTypeKey = new MapperKey(from, to, mappingConfigurator.GetConfigurationName());
ObjectsMapperDescr result;
int mapperId;
if (!objectsMapperIds.TryGetValue(MapperTypeKey, out mapperId))
{
result = new ObjectsMapperDescr(
null,
MapperTypeKey,
0
);
AddMapper(result);
string MapperTypeName = GetMapperTypeName(from, to);
ObjectsMapperBaseImpl createdMapper;
if (MapperPrimitiveImpl.IsSupportedType(to))
{
createdMapper = new MapperPrimitiveImpl(this, from, to, mappingConfigurator);
}
else if (MapperForCollectionImpl.IsSupportedType(to))
{
ObjectsMapperDescr Mapper = GetMapperInt(
MapperForCollectionImpl.GetSubMapperTypeFrom(from),
MapperForCollectionImpl.GetSubMapperTypeTo(to),
mappingConfigurator);
createdMapper = MapperForCollectionImpl.CreateInstance(
MapperTypeName + GetNextMapperId(),
this,
from,
to,
Mapper,
mappingConfigurator
);
}
else
{
createdMapper = BuildObjectsMapper(
MapperTypeName + GetNextMapperId(),
from,
to,
mappingConfigurator
);
}
result.mapper = createdMapper;
return(result);
}
else
{
return(objectsMappersList[mapperId]);
}
}
}
/// <summary>
/// 获取类型转换方法
/// </summary>
/// <typeparam name="TFrom">来源类型</typeparam>
/// <typeparam name="TTo">目标类型</typeparam>
/// <param name="mappingConfigurator">匹配配置</param>
/// <returns>类型转换方法</returns>
public static ObjectsMapper <TFrom, TTo> GetMapper <TFrom, TTo>(IMappingConfigurator mappingConfigurator)
{
return(ObjectMapperManager.DefaultInstance.GetMapper <TFrom, TTo>(mappingConfigurator));
}
