private ConfiguredLambdaInfo GetValueLambdaInfo(Type targetValueType)
{
if (_customValueLambdaInfo != null)
{
return(_customValueLambdaInfo);
}
#if NET35
var customValueLambda = _customValueLambda.ToDlrExpression();
const ExprType CONSTANT = ExprType.Constant;
#else
var customValueLambda = _customValueLambda;
const ExprType CONSTANT = Constant;
#endif
if ((customValueLambda.Body.NodeType != CONSTANT) ||
(targetValueType == typeof(object)) ||
customValueLambda.ReturnType.IsAssignableTo(targetValueType) ||
_configInfo.HasTargetMemberMatcher())
{
return(_customValueLambdaInfo = ConfiguredLambdaInfo.For(customValueLambda, _configInfo));
}
var convertedConstantValue = MapperContext
.GetValueConversion(customValueLambda.Body, targetValueType);
var funcType = Expr.GetFuncType(targetValueType);
var valueLambda = Expr.Lambda(funcType, convertedConstantValue);
var valueFunc = valueLambda.Compile();
var value = valueFunc.DynamicInvoke().ToConstantExpression(targetValueType);
var constantValueLambda = Expr.Lambda(funcType, value);
var valueLambdaInfo = ConfiguredLambdaInfo.For(constantValueLambda, _configInfo);
return(_customValueLambdaInfo = valueLambdaInfo);
}
private void ThrowIfRedundantSourceMember(ConfiguredLambdaInfo valueLambdaInfo, QualifiedMember targetMember)
{
if (!valueLambdaInfo.TryGetSourceMember(out var sourceMemberLambda))
{
return;
}
var mappingData = _configInfo.ToMappingData <TSource, TTarget>();
var targetMemberMapperData = new ChildMemberMapperData(targetMember, mappingData.MapperData);
var targetMemberMappingData = mappingData.GetChildMappingData(targetMemberMapperData);
var bestSourceMemberMatch = SourceMemberMatcher.GetMatchFor(targetMemberMappingData);
if (!bestSourceMemberMatch.IsUseable)
{
return;
}
var configuredSourceMember = sourceMemberLambda.ToSourceMember(MapperContext);
if (!bestSourceMemberMatch.SourceMember.Matches(configuredSourceMember))
{
return;
}
throw new MappingConfigurationException(string.Format(
CultureInfo.InvariantCulture,
"Source member {0} will automatically be mapped to target {1} {2}, " +
"and does not need to be configured",
GetSourceMemberDescription(configuredSourceMember),
GetTargetMemberType(targetMember),
targetMember.GetFriendlyTargetPath(_configInfo)));
}
public ConfiguredDataSourceFactory CreateReverseIfAppropriate(bool isAutoReversal)
{
if (CannotBeReversed(out var targetMember, out _))
{
return(null);
}
var reverseConfigInfo = GetReverseConfigInfo();
var sourceParameter = Parameters.Create(reverseConfigInfo.SourceType, "source");
var sourceMemberAccess = TargetMember.GetQualifiedAccess(sourceParameter);
var sourceMemberAccessLambda = Expression.Lambda(
Expression.GetFuncType(sourceParameter.Type, sourceMemberAccess.Type),
sourceMemberAccess,
sourceParameter);
var sourceMemberLambdaInfo = ConfiguredLambdaInfo.For(sourceMemberAccessLambda);
return(new ConfiguredDataSourceFactory(reverseConfigInfo, sourceMemberLambdaInfo, targetMember)
{
_isReversal = true,
WasAutoCreated = isAutoReversal
});
}
public void Using <TFactory>(TFactory factory) where TFactory : class
{
var factoryInfo = ConfiguredLambdaInfo.ForFunc(factory, typeof(TSource), typeof(TTarget));
if (factoryInfo == null)
{
var contextTypeName = typeof(IMappingData <TSource, TTarget>).GetFriendlyName();
var sourceTypeName = typeof(TSource).GetFriendlyName();
var targetTypeName = typeof(TTarget).GetFriendlyName();
var objectTypeName = typeof(TObject).GetFriendlyName();
string[] validSignatures =
{
"Func<" + objectTypeName + ">",
$"Func<{contextTypeName}, {objectTypeName}>",
$"Func<{sourceTypeName}, {targetTypeName}, {objectTypeName}>",
$"Func<{sourceTypeName}, {targetTypeName}, int?, {objectTypeName}>"
};
throw new MappingConfigurationException(string.Format(
CultureInfo.InvariantCulture,
"Unable to create objects of type {0} using factory {1}: valid function signatures are {2}",
objectTypeName,
factory,
string.Join(", ", validSignatures)));
}
var objectFactory = ConfiguredObjectFactory.For(_configInfo, typeof(TObject), factoryInfo);
_configInfo.MapperContext.UserConfigurations.Add(objectFactory);
}
public ConfiguredDataSourceFactory(
MappingConfigInfo configInfo,
ConfiguredLambdaInfo dataSourceLambda,
QualifiedMember targetMember)
: base(configInfo, dataSourceLambda, targetMember)
{
}
private ConfiguredLambdaInfo GetValueLambdaInfo <TTargetValue>()
{
if (_customValueLambdaInfo != null)
{
return(_customValueLambdaInfo);
}
#if NET35
var customValueLambda = _customValueLambda.ToDlrExpression();
const Dlr.ExpressionType CONSTANT = Dlr.ExpressionType.Constant;
#else
var customValueLambda = _customValueLambda;
const ExpressionType CONSTANT = ExpressionType.Constant;
#endif
if ((customValueLambda.Body.NodeType != CONSTANT) ||
(typeof(TTargetValue) == typeof(object)) ||
customValueLambda.ReturnType.IsAssignableTo(typeof(TTargetValue)))
{
return(ConfiguredLambdaInfo.For(customValueLambda));
}
var convertedConstantValue = _configInfo
.MapperContext
.ValueConverters
.GetConversion(customValueLambda.Body, typeof(TTargetValue));
var valueLambda = Lambda <Func <TTargetValue> >(convertedConstantValue);
var valueFunc = valueLambda.Compile();
var value = valueFunc.Invoke().ToConstantExpression(typeof(TTargetValue));
var constantValueLambda = Lambda <Func <TTargetValue> >(value);
var valueLambdaInfo = ConfiguredLambdaInfo.For(constantValueLambda);
return(valueLambdaInfo);
}
public CustomDataSourceTargetMemberSpecifier(
MappingConfigInfo configInfo,
ConfiguredLambdaInfo customValueLambda)
{
_configInfo = configInfo;
_customValueLambdaInfo = customValueLambda;
}
public ConfiguredDataSourceFactory(
MappingConfigInfo configInfo,
ConfiguredLambdaInfo dataSourceLambda,
LambdaExpression targetMemberLambda)
: base(configInfo, targetMemberLambda)
{
_dataSourceLambda = dataSourceLambda;
}
public MappingCallbackFactory(
MappingConfigInfo configInfo,
ConfiguredLambdaInfo callbackLambda,
QualifiedMember targetMember)
: base(configInfo, targetMember)
{
_callbackLambda = callbackLambda;
}
protected ConfiguredDataSourceFactoryBase(
MappingConfigInfo configInfo,
ConfiguredLambdaInfo dataSourceLambda,
QualifiedMember targetMember)
: base(configInfo, targetMember)
{
DataSourceLambda = dataSourceLambda;
}
public ConfiguredDataSourceFactory(
MappingConfigInfo configInfo,
ConfiguredLambdaInfo dataSourceLambda,
LambdaExpression targetMemberLambda,
bool valueCouldBeSourceMember)
: base(configInfo, dataSourceLambda, targetMemberLambda, valueCouldBeSourceMember)
{
}
public ConfiguredDictionaryEntryDataSourceFactory(
MappingConfigInfo configInfo,
ConfiguredLambdaInfo dataSourceLambda,
DictionaryTargetMember targetDictionaryEntryMember)
: base(configInfo, dataSourceLambda, QualifiedMember.All)
{
TargetDictionaryEntryMember = targetDictionaryEntryMember;
}
public ObjectCreationCallbackFactory(
MappingConfigInfo configInfo,
Type creationTargetType,
ConfiguredLambdaInfo callbackLambda)
: base(configInfo, callbackLambda, QualifiedMember.All)
{
_creationTargetType = creationTargetType;
}
private ConfiguredObjectFactory(
MappingConfigInfo configInfo,
Type objectType,
ConfiguredLambdaInfo factoryInfo)
: base(configInfo)
{
_objectType = objectType;
_factoryInfo = factoryInfo;
}
protected ConfiguredDataSourceFactoryBase(
MappingConfigInfo configInfo,
ConfiguredLambdaInfo dataSourceLambda,
LambdaExpression targetMemberLambda,
bool valueCouldBeSourceMember)
: base(configInfo, targetMemberLambda)
{
DataSourceLambda = dataSourceLambda;
ValueCouldBeSourceMember = valueCouldBeSourceMember;
}
public CustomDataSourceTargetMemberSpecifier <TSource, TTarget> Map <TSourceValue>(TSourceValue value)
{
var valueLambdaInfo = ConfiguredLambdaInfo.ForFunc(value, typeof(TSource), typeof(TTarget));
return((valueLambdaInfo != null)
? new CustomDataSourceTargetMemberSpecifier <TSource, TTarget>(
_configInfo.ForSourceValueType(valueLambdaInfo.ReturnType),
valueLambdaInfo)
: GetConstantValueTargetMemberSpecifier(value));
}
private ConfiguredMatcherDataSourceFactory(
MappingConfigInfo configInfo,
Expression targetMemberMatcherExpression,
Func <TargetMemberSelector, bool> targetMemberMatcher,
ConfiguredLambdaInfo dataSourceLambda,
QualifiedMember toTargetMember)
: base(configInfo, dataSourceLambda, toTargetMember)
{
_targetMemberMatcherExpression = targetMemberMatcherExpression;
_targetMemberMatcher = targetMemberMatcher;
}
public ConfiguredMatcherDataSourceFactory(
MappingConfigInfo configInfo,
LinqExp.Expression <Func <TargetMemberSelector, bool> > targetMemberMatcher,
ConfiguredLambdaInfo dataSourceLambda,
QualifiedMember toTargetMember)
: this(
configInfo,
targetMemberMatcher.ToDlrExpression(),
dataSourceLambda,
toTargetMember)
{
}
public ConfiguredMatcherDataSourceFactory(
MappingConfigInfo configInfo,
Expression <Func <TargetMemberSelector, bool> > targetMemberMatcher,
ConfiguredLambdaInfo dataSourceLambda,
QualifiedMember toTargetMember)
: this(
configInfo,
targetMemberMatcher?.Body,
targetMemberMatcher?.Compile() ?? (_ => true),
dataSourceLambda,
toTargetMember)
{
}
private ConfiguredDataSourceFactory CreateDataSourceFactory(
ConfiguredLambdaInfo valueLambdaInfo,
LambdaExpression targetMemberLambda)
{
return(new ConfiguredDataSourceFactory(
_configInfo,
valueLambdaInfo,
#if NET35
targetMemberLambda.ToDlrExpression(),
#else
targetMemberLambda,
#endif
_valueCouldBeSourceMember));
}
private MappingConfigContinuation <TSource, TTarget> CreateCallbackFactory <TAction>(TAction callback)
{
var callbackLambda = ConfiguredLambdaInfo.ForAction(callback, typeof(TSource), typeof(TTarget), typeof(TObject));
var creationCallbackFactory = new ObjectCreationCallbackFactory(
ConfigInfo,
typeof(TObject),
CallbackPosition,
callbackLambda);
ConfigInfo.MapperContext.UserConfigurations.Add(creationCallbackFactory);
return(new MappingConfigContinuation <TSource, TTarget>(ConfigInfo));
}
private MappingConfigContinuation <TSource, TTarget> CreateCallbackFactory <TAction>(TAction callback)
{
ThrowIfStructMemberCallback();
var callbackLambda = ConfiguredLambdaInfo
.ForAction(callback, _configInfo, typeof(TSource), typeof(TTarget));
var creationCallbackFactory = new MappingCallbackFactory(
_configInfo,
callbackLambda,
_targetMember);
_configInfo.UserConfigurations.Add(creationCallbackFactory);
return(new MappingConfigContinuation <TSource, TTarget>(_configInfo));
}
private CustomDataSourceTargetMemberSpecifier <TSource, TTarget> GetConstantValueTargetMemberSpecifier <TSourceValue>(
TSourceValue value)
{
var valueLambdaInfo = ConfiguredLambdaInfo.ForFunc(value, typeof(TSource), typeof(TTarget));
if (valueLambdaInfo != null)
{
return(new CustomDataSourceTargetMemberSpecifier <TSource, TTarget>(
ConfigInfo.ForSourceValueType(valueLambdaInfo.ReturnType),
valueLambdaInfo));
}
#if NET35
var valueConstant = Expression.Constant(value, typeof(TSourceValue));
#else
var valueConstant = value.ToConstantExpression();
#endif
var valueLambda = Expression.Lambda <Func <TSourceValue> >(valueConstant);
return(new CustomDataSourceTargetMemberSpecifier <TSource, TTarget>(
ConfigInfo.ForSourceValueType(valueConstant.Type),
valueLambda));
}
private void ThrowIfRedundantSourceMember(ConfiguredLambdaInfo valueLambdaInfo, QualifiedMember targetMember)
{
if (!valueLambdaInfo.IsSourceMember(out var sourceMemberLambda))
{
return;
}
var mappingData = _configInfo.ToMappingData <TSource, TTarget>();
var targetMemberMapperData = new ChildMemberMapperData(targetMember, mappingData.MapperData);
var targetMemberMappingData = mappingData.GetChildMappingData(targetMemberMapperData);
var bestMatchingSourceMember = SourceMemberMatcher.GetMatchFor(targetMemberMappingData, out _);
if (bestMatchingSourceMember == null)
{
return;
}
var sourceMember = sourceMemberLambda.ToSourceMember(MapperContext);
if (!bestMatchingSourceMember.Matches(sourceMember))
{
return;
}
var targetMemberType = (targetMember.LeafMember.MemberType == MemberType.ConstructorParameter)
? "constructor parameter"
: "member";
throw new MappingConfigurationException(string.Format(
CultureInfo.InvariantCulture,
"Source member {0} will automatically be mapped to target {1} {2}, " +
"and does not need to be configured",
GetSourceMemberDescription(sourceMember),
targetMemberType,
targetMember.GetFriendlyTargetPath(_configInfo)));
}
internal CustomDataSourceTargetMemberSpecifier(MappingConfigInfo configInfo, LambdaExpression customValueLambda)
: this(configInfo, ConfiguredLambdaInfo.For(customValueLambda))
{
}
public static ConfiguredObjectFactory For(
MappingConfigInfo configInfo,
Type objectType,
ConfiguredLambdaInfo factoryInfo)
=> new ConfiguredObjectFactory(configInfo, objectType, factoryInfo);
public static ConfiguredObjectFactory For(MappingConfigInfo configInfo, Type objectType, LambdaExpression factory) => For(configInfo, objectType, ConfiguredLambdaInfo.For(factory));
