public void RegisterAll(object mapper, Type interfaces, Type[] implementedInterfaces)
{
lock (_sync)
{
Type propertiesMapperType = typeof(IPropertiesMapper <,>);
foreach (Type interfaceType in implementedInterfaces.Where(i => i.GUID == propertiesMapperType.GUID))
{
Type[] genericArgs = interfaceType.GetGenericArguments();
var pairId = PairId.GetId(genericArgs[0], genericArgs[1]);
var methodInfo = interfaces.GetInterfaceMap(interfaceType).InterfaceMethods.Single();
Type delegateType = typeof(Action <,>).MakeGenericType(genericArgs[0], genericArgs[1]);
var factoryDelegate = Delegate.CreateDelegate(delegateType, mapper, methodInfo, true);
if (_cache.ContainsKey(pairId))
{
_cache[pairId] = factoryDelegate;
}
else
{
_cache.Add(pairId, factoryDelegate);
}
}
}
}
public void Register <TSource, TDest>(IPropertiesMapper <TSource, TDest> mapper)
{
lock (_sync)
{
PairId id = PairId.GetId <TSource, TDest>();
if (_cache.ContainsKey(id))
{
_cache[id] = (Action <TSource, TDest>)mapper.MapProperties;
}
else
{
_cache.Add(PairId.GetId <TSource, TDest>(), (Action <TSource, TDest>)mapper.MapProperties);
}
}
}
public bool TryGetMapperFromCache <TSource, TDest>(out Action <TSource, TDest> mapper)
{
PairId pairId = PairId.GetId <TSource, TDest>();
Delegate mapperObject;
if (_cache.TryGetValue(pairId, out mapperObject))
{
mapper = (Action <TSource, TDest>)mapperObject;
return(true);
}
else
{
mapper = null;
return(false);
}
}
public Action <TSource, TDest> GetMapper <TSource, TDest>(TSource source, TDest dest)
{
PairId pairId = PairId.GetId <TSource, TDest>();
Delegate mappingDelegate;
if (_cache.TryGetValue(pairId, out mappingDelegate))
{
return((Action <TSource, TDest>)mappingDelegate);
}
lock (_sync)
{
IPropertiesMapper <TSource, TDest> mapper;
Action <TSource, TDest> mappingAction;
if (_cache.TryGetValue(pairId, out mappingDelegate))
{
mappingAction = (Action <TSource, TDest>)mappingDelegate;
}
else
{
if ((mapper = dest as IPropertiesMapper <TSource, TDest>) != null)
{
mappingAction = mapper.MapProperties;
_cache.Add(pairId, mappingAction);
}
else
{
if ((mapper = source as IPropertiesMapper <TSource, TDest>) != null)
{
mappingAction = mapper.MapProperties;
_cache.Add(pairId, mappingAction);
}
else
{
throw new NotSupportedException(
String.Format("Convert expression for {0}->{1} does not exist.",
typeof(TSource).FullName, typeof(TDest).FullName));
}
}
}
return(mappingAction);
}
}
public void Register <TSource, TDest, TParam1, TParam2>(ISelectDynamicExpression <TSource, TDest, TParam1, TParam2> resolver)
{
PairId id = PairId.GetId <TSource, TDest>();
var factory = (Func <TParam1, TParam2, Expression <Func <TSource, TDest> > >)resolver.GetSelectExpression;
lock (_sync)
{
if (_dynamicExpressionFactories.ContainsKey(id))
{
_dynamicExpressionFactories[id] = factory;
}
else
{
_dynamicExpressionFactories.Add(id, factory);
}
}
}
public void Register <TSource, TDest>(ISelectExpression <TSource, TDest> resolver)
{
PairId id = PairId.GetId <TSource, TDest>();
var factory = (Func <Expression <Func <TSource, TDest> > >)resolver.GetSelectExpression;
lock (_sync)
{
if (_expressionFactories.ContainsKey(id))
{
_expressionFactories[id] = factory;
TryRemoveExpressions(id);
}
else
{
_expressionFactories.Add(id, factory);
}
}
}
private bool TryGetOrActivate <TSource, TDest, TParam1, TParam2>(TParam1 param1, TParam2 param2, Func <ISelectExpression <TSource, TDest, TParam1, TParam2> > activator, out Expression <Func <TSource, TDest> > expression)
{
PairId id = PairId.GetId <TSource, TDest>();
Dictionary <PairId, LambdaExpression> expressions = GetOrAddParamExpressionsDictionary(param1, param2, add: false);
Delegate factoryDelegate;
LambdaExpression lambdaExpression;
if (expressions != null && expressions.TryGetValue(id, out lambdaExpression))
{
expression = (Expression <Func <TSource, TDest> >)lambdaExpression;
return(true);
}
else if (_dynamicExpressionFactories.TryGetValue(id, out factoryDelegate))
{
expression = ((Func <TParam1, TParam2, Expression <Func <TSource, TDest> > >)factoryDelegate)(param1, param2);
return(true);
}
lock (_sync)
{
expressions = expressions ?? GetOrAddParamExpressionsDictionary(param1, param2, add: true);
if (expressions.TryGetValue(id, out lambdaExpression))
{
expression = (Expression <Func <TSource, TDest> >)lambdaExpression;
return(true);
}
Func <TParam1, TParam2, Expression <Func <TSource, TDest> > > factory;
if (_expressionFactories.TryGetValue(id, out factoryDelegate))
{
factory = (Func <TParam1, TParam2, Expression <Func <TSource, TDest> > >)factoryDelegate;
expression = factory(param1, param2);
expressions.Add(id, expression);
TryRemoveFactory(id);
return(true);
}
if (_dynamicExpressionFactories.TryGetValue(id, out factoryDelegate))
{
factory = (Func <TParam1, TParam2, Expression <Func <TSource, TDest> > >)factoryDelegate;
expression = factory(param1, param2);
return(true);
}
if (activator != null)
{
ISelectExpression <TSource, TDest, TParam1, TParam2> selectResolver = activator();
factory = selectResolver.GetSelectExpression;
if (selectResolver is ISelectDynamicExpression <TSource, TDest, TParam1, TParam2> )
{
_dynamicExpressionFactories.Add(id, factory);
expression = factory(param1, param2);
return(true);
}
else
{
_expressionFactories.Add(id, factory);
expression = factory(param1, param2);
expressions.Add(id, expression);
TryRemoveFactory(id);
return(true);
}
}
}
expression = null;
return(false);
}
public void RegisterAll(object mapper, Type mapperType, Type[] implementedInterfaces)
{
Type selectExpressionType = typeof(ISelectExpression <,>);
Type dynamicSelectExpressionType = typeof(ISelectDynamicExpression <,>);
var selectExpressions = implementedInterfaces.Where(i => i.GUID == selectExpressionType.GUID || i.GUID == dynamicSelectExpressionType.GUID)
.Select(i =>
{
var genericArgs = i.GetGenericArguments();
return(new
{
InterfaceType = i,
GenericArguments = genericArgs,
PairId = PairId.GetId(genericArgs[0], genericArgs[1])
});
})
.GroupBy(i => i.PairId)
.Select(
g => g.FirstOrDefault(i => i.InterfaceType.GUID == dynamicSelectExpressionType.GUID)
?? g.First(i => i.InterfaceType.GUID == selectExpressionType.GUID)
)
.Select(interfaceDescription =>
{
var methodInfo = mapperType.GetInterfaceMap(interfaceDescription.InterfaceType).InterfaceMethods.SingleOrDefault()
?? interfaceDescription.InterfaceType.GetInterfaces().SelectMany(i => mapperType.GetInterfaceMap(i).TargetMethods).Single();
Type delegateType = typeof(Func <>).MakeGenericType(
typeof(Expression <>).MakeGenericType(
typeof(Func <,>).MakeGenericType(interfaceDescription.PairId.SourceId, interfaceDescription.PairId.DestId)
)
);
var factoryDelegate = Delegate.CreateDelegate(delegateType, mapper, methodInfo, true);
return(new
{
InterfaceType = interfaceDescription.InterfaceType,
PairId = interfaceDescription.PairId,
FactoryDelegate = factoryDelegate
});
})
.ToList();
lock (_sync)
{
foreach (var selectExpression in selectExpressions)
{
Dictionary <PairId, Delegate> cacheDictionary;
if (selectExpression.InterfaceType.GUID == dynamicSelectExpressionType.GUID)
{
cacheDictionary = _dynamicExpressionFactories;
}
else if (selectExpression.InterfaceType.GUID == selectExpressionType.GUID)
{
cacheDictionary = _expressionFactories;
}
else
{
throw new NotSupportedException(String.Format("The interface {0} caching is not supported.", selectExpression.InterfaceType.FullName));
}
if (cacheDictionary.ContainsKey(selectExpression.PairId))
{
cacheDictionary[selectExpression.PairId] = selectExpression.FactoryDelegate;
}
else
{
cacheDictionary.Add(selectExpression.PairId, selectExpression.FactoryDelegate);
}
}
}
}