private static MemberInfo FindTypeMember(IEnumerable<MemberInfo> modelProperties, IEnumerable<MethodInfo> getMethods, string nameToSearch, IMappingOptions mappingOptions)
{
MemberInfo pi = modelProperties.FirstOrDefault(prop => NameMatches(prop.Name, nameToSearch));
if (pi != null)
return pi;
MethodInfo mi = getMethods.FirstOrDefault(m => NameMatches(m.Name, nameToSearch));
if (mi != null)
return mi;
pi = modelProperties.FirstOrDefault(prop => NameMatches(mappingOptions.SourceMemberNameTransformer(prop.Name), nameToSearch));
if (pi != null)
return pi;
mi = getMethods.FirstOrDefault(m => NameMatches(mappingOptions.SourceMemberNameTransformer(m.Name), nameToSearch));
if (mi != null)
return mi;
pi = modelProperties.FirstOrDefault(prop => NameMatches(prop.Name, mappingOptions.DestinationMemberNameTransformer(nameToSearch)));
if (pi != null)
return pi;
pi = getMethods.FirstOrDefault(m => NameMatches(m.Name, mappingOptions.DestinationMemberNameTransformer(nameToSearch)));
if (pi != null)
return pi;
return null;
}
public MapperContext(Type source, Type target, IMappingOptions options)
{
SourceInstance = Expression.Parameter(source, "sourceInstance");
TargetInstance = Expression.Parameter(target, "targetInstance");
Options = options;
}
private bool MapDestinationCtorToSource(TypeMap typeMap, ConstructorInfo destCtor, TypeInfo sourceTypeInfo,
IMappingOptions options)
{
var parameters = new List<ConstructorParameterMap>();
var ctorParameters = destCtor.GetParameters();
if (ctorParameters.Length == 0 || !options.ConstructorMappingEnabled)
return false;
foreach (var parameter in ctorParameters)
{
var members = new LinkedList<MemberInfo>();
if (!MapDestinationPropertyToSource(members, sourceTypeInfo, parameter.Name, options))
return false;
var resolvers = members.Select(mi => mi.ToMemberGetter());
var param = new ConstructorParameterMap(parameter, resolvers.ToArray());
parameters.Add(param);
}
typeMap.AddConstructorMap(destCtor, parameters);
return true;
}
public LambdaExpression Get(Type source, Type target, IMappingOptions options)
{
var key = new TypePairWithOptions(source, target, options);
_cache.TryGetValue(key, out var value);
return(value);
}
public TypeMap CreateTypeMap(Type sourceType, Type destinationType, IMappingOptions options)
{
var sourceTypeInfo = GetTypeInfo(sourceType);
var destTypeInfo = GetTypeInfo(destinationType);
var typeMap = new TypeMap(sourceTypeInfo, destTypeInfo);
foreach (var destProperty in destTypeInfo.GetPublicWriteAccessors())
{
var members = new LinkedList<MemberInfo>();
if (MapDestinationPropertyToSource(members, sourceTypeInfo, destProperty.Name, options))
{
var resolvers = members.Select(mi => mi.ToMemberGetter());
var destPropertyAccessor = destProperty.ToMemberAccessor();
#if !SILVERLIGHT
typeMap.AddPropertyMap(destPropertyAccessor, resolvers);
#else
typeMap.AddPropertyMap(destPropertyAccessor, resolvers.Cast<IValueResolver>());
#endif
}
}
if (!destinationType.IsAbstract && destinationType.IsClass)
{
foreach (var destCtor in destTypeInfo.GetConstructors().OrderByDescending(ci => ci.GetParameters().Length))
{
if (MapDestinationCtorToSource(typeMap, destCtor, sourceTypeInfo, options))
{
break;
}
}
}
return typeMap;
}
private static MemberInfo FindTypeMember(IEnumerable <MemberInfo> modelProperties,
IEnumerable <MethodInfo> getMethods,
IEnumerable <MethodInfo> getExtensionMethods,
string nameToSearch,
IMappingOptions mappingOptions)
{
MemberInfo pi = modelProperties.FirstOrDefault(prop => NameMatches(prop.Name, nameToSearch, mappingOptions));
if (pi != null)
{
return(pi);
}
MethodInfo mi = getMethods.FirstOrDefault(m => NameMatches(m.Name, nameToSearch, mappingOptions));
if (mi != null)
{
return(mi);
}
mi = getExtensionMethods.FirstOrDefault(m => NameMatches(m.Name, nameToSearch, mappingOptions));
if (mi != null)
{
return(mi);
}
return(null);
}
public TypeMap CreateTypeMap(Type sourceType, Type destinationType, IMappingOptions options, MemberList memberList)
{
var sourceTypeInfo = GetTypeInfo(sourceType);
var destTypeInfo = GetTypeInfo(destinationType);
var typeMap = new TypeMap(sourceTypeInfo, destTypeInfo, memberList);
foreach (var destProperty in destTypeInfo.GetPublicWriteAccessors())
{
var members = new LinkedList <MemberInfo>();
if (MapDestinationPropertyToSource(members, sourceTypeInfo, destProperty.Name, options))
{
var resolvers = members.Select(mi => mi.ToMemberGetter());
var destPropertyAccessor = destProperty.ToMemberAccessor();
#if !SILVERLIGHT
typeMap.AddPropertyMap(destPropertyAccessor, resolvers);
#else
typeMap.AddPropertyMap(destPropertyAccessor, resolvers.Cast <IValueResolver>());
#endif
}
}
if (!destinationType.IsAbstract && destinationType.IsClass)
{
foreach (var destCtor in destTypeInfo.GetConstructors().OrderByDescending(ci => ci.GetParameters().Length))
{
if (MapDestinationCtorToSource(typeMap, destCtor, sourceTypeInfo, options))
{
break;
}
}
}
return(typeMap);
}
private bool MapDestinationCtorToSource(TypeMap typeMap, ConstructorInfo destCtor, TypeInfo sourceTypeInfo,
IMappingOptions options)
{
var parameters = new List <ConstructorParameterMap>();
var ctorParameters = destCtor.GetParameters();
if (ctorParameters.Length > 0 && !options.ConstructorMappingEnabled)
{
return(false);
}
foreach (var parameter in ctorParameters)
{
var members = new LinkedList <MemberInfo>();
if (!MapDestinationPropertyToSource(members, sourceTypeInfo, parameter.Name, options))
{
return(false);
}
var resolvers = members.Select(mi => mi.ToMemberGetter());
var param = new ConstructorParameterMap(parameter, resolvers.ToArray());
parameters.Add(param);
}
typeMap.AddConstructorMap(destCtor, parameters);
return(true);
}
public CollectionMapperContext(Type source, Type target, IMappingOptions options)
: base(source, target, options)
{
SourceCollectionElementType = SourceInstance.Type.GetCollectionGenericType();
TargetCollectionElementType = TargetInstance.Type.GetCollectionGenericType();
IsSourceElementTypeBuiltIn = SourceCollectionElementType.IsBuiltInType(true);
IsTargetElementTypeBuiltIn = TargetCollectionElementType.IsBuiltInType(true);
IsSourceElementTypeStruct = !SourceCollectionElementType.IsClass;
IsTargetElementTypeStruct = !TargetCollectionElementType.IsClass;
SourceCollectionLoopingVar = Expression.Parameter(SourceCollectionElementType, "loopVar");
if (options.CollectionItemEqualityComparer != null)
{
var updateCollectionMethodInfo = typeof(LinqExtensions).GetMethod(
nameof(LinqExtensions.Update), BindingFlags.Static | BindingFlags.NonPublic)
.MakeGenericMethod(SourceCollectionElementType, TargetCollectionElementType);
UpdateCollection = Expression.Call(null, updateCollectionMethodInfo, Mapper, ReferenceTracker, SourceInstance,
Expression.Convert(TargetInstance, typeof(ICollection <>).MakeGenericType(TargetCollectionElementType)),
Expression.Convert(Expression.Constant(options.CollectionItemEqualityComparer.Compile()),
typeof(Func <, ,>).MakeGenericType(SourceCollectionElementType, TargetCollectionElementType, typeof(bool))));
}
}
public TypeMap CreateTypeMap(Type sourceType, Type destinationType, IMappingOptions options,
MemberList memberList)
{
var sourceTypeInfo = GetTypeInfo(sourceType, options);
var destTypeInfo = GetTypeInfo(destinationType, options.ShouldMapProperty, options.ShouldMapField, new MethodInfo[0]);
var typeMap = new TypeMap(sourceTypeInfo, destTypeInfo, memberList);
foreach (var destProperty in destTypeInfo.PublicWriteAccessors)
{
var members = new LinkedList<MemberInfo>();
if (MapDestinationPropertyToSource(members, sourceTypeInfo, destProperty.Name, options))
{
var resolvers = members.Select(mi => mi.ToMemberGetter());
var destPropertyAccessor = destProperty.ToMemberAccessor();
typeMap.AddPropertyMap(destPropertyAccessor, resolvers.Cast<IValueResolver>());
}
}
if (!destinationType.IsAbstract() && destinationType.IsClass())
{
foreach (var destCtor in destTypeInfo.Constructors.OrderByDescending(ci => ci.GetParameters().Length))
{
if (MapDestinationCtorToSource(typeMap, destCtor, sourceTypeInfo, options))
{
break;
}
}
}
return typeMap;
}
private NameSnippet CreateNameSnippet(IEnumerable <string> matches, int i, IMappingOptions mappingOptions)
{
return(new NameSnippet
{
First = String.Join(mappingOptions.SourceMemberNamingConvention.SeparatorCharacter, matches.Take(i).ToArray()),
Second = String.Join(mappingOptions.SourceMemberNamingConvention.SeparatorCharacter, matches.Skip(i).ToArray())
});
}
private NameSnippet CreateNameSnippet(IEnumerable<string> matches, int i, IMappingOptions mappingOptions)
{
return new NameSnippet
{
First = String.Join(mappingOptions.SourceMemberNamingConvention.SeparatorCharacter, matches.Take(i).ToArray()),
Second = String.Join(mappingOptions.SourceMemberNamingConvention.SeparatorCharacter, matches.Skip(i).ToArray())
};
}
public TypePairWithOptions(Type source, Type target, IMappingOptions mappingOptions = null)
{
this.SourceType = source;
this.TargetType = target;
this.MappingOptions = mappingOptions;
_toString = null;
_hashcode = null;
}
private NameSnippet CreateNameSnippet(IEnumerable <string> matches, int i, IMappingOptions mappingOptions)
{
return(new NameSnippet
{
First =
string.Join("", matches.Take(i).ToArray()),
Second =
string.Join("", matches.Skip(i).ToArray())
});
}
private bool MapDestinationPropertyToSource(LinkedList <MemberInfo> resolvers, TypeInfo sourceType,
string nameToSearch, IMappingOptions mappingOptions)
{
if (string.IsNullOrEmpty(nameToSearch))
{
return(true);
}
var sourceProperties = sourceType.PublicReadAccessors;
var sourceNoArgMethods = sourceType.PublicNoArgMethods;
var sourceNoArgExtensionMethods = sourceType.PublicNoArgExtensionMethods;
MemberInfo resolver = FindTypeMember(sourceProperties, sourceNoArgMethods, sourceNoArgExtensionMethods,
nameToSearch, mappingOptions);
bool foundMatch = resolver != null;
if (foundMatch)
{
resolvers.AddLast(resolver);
}
else
{
string[] matches = mappingOptions.DestinationMemberNamingConvention.SplittingExpression
.Matches(nameToSearch)
.Cast <Match>()
.Select(m => m.Value)
.ToArray();
for (int i = 1; (i <= matches.Length) && (!foundMatch); i++)
{
NameSnippet snippet = CreateNameSnippet(matches, i, mappingOptions);
var valueResolver = FindTypeMember(sourceProperties, sourceNoArgMethods, sourceNoArgExtensionMethods,
snippet.First,
mappingOptions);
if (valueResolver != null)
{
resolvers.AddLast(valueResolver);
foundMatch = MapDestinationPropertyToSource(resolvers,
GetTypeInfo(valueResolver.GetMemberType(), mappingOptions),
snippet.Second, mappingOptions);
if (!foundMatch)
{
resolvers.RemoveLast();
}
}
}
}
return(foundMatch);
}
public CollectionMapperContext(Type source, Type target, IMappingOptions options)
: base(source, target, options)
{
SourceCollectionElementType = SourceInstance.Type.GetCollectionGenericType();
TargetCollectionElementType = TargetInstance.Type.GetCollectionGenericType();
IsSourceElementTypeBuiltIn = SourceCollectionElementType.IsBuiltInType(true);
IsTargetElementTypeBuiltIn = TargetCollectionElementType.IsBuiltInType(true);
SourceCollectionLoopingVar = Expression.Parameter(SourceCollectionElementType, "loopVar");
}
protected override void Establish_context()
{
var namingConvention = new StubNamingConvention();
namingConvention.SplittingExpression = new Regex(@"[\p{Ll}0-9]*(?=_?)");
_mappingOptions = new StubMappingOptions();
_mappingOptions.SourceMemberNamingConvention = new PascalCaseNamingConvention();
_mappingOptions.DestinationMemberNamingConvention = namingConvention;
_factory = new TypeMapFactory();
}
protected override void Establish_context()
{
var namingConvention = new StubNamingConvention();
namingConvention.SeparatorCharacter = "__";
_mappingOptions = new StubMappingOptions();
_mappingOptions.SourceMemberNamingConvention = namingConvention;
_mappingOptions.DestinationMemberNamingConvention = new PascalCaseNamingConvention();
_factory = new TypeMapFactory();
}
public TTo Map <TFrom>(TFrom item, IMappingOptions options = null, TTo defaultValue = default(TTo))
{
if (item == null)
{
return(defaultValue);
}
// todo: заюзать вызов экстеншена
var mapper = (IMapper <TFrom, TTo>)_serviceProvider.GetService(typeof(IMapper <TFrom, TTo>));
return(mapper == null ? defaultValue : mapper.Map(item, options ?? new MappingOptions()));
}
protected override void Establish_context()
{
INamingConvention namingConvention = CreateStub <INamingConvention>();
namingConvention.Stub(nc => nc.SeparatorCharacter).Return("__");
_mappingOptions = new StubMappingOptions();
_mappingOptions.SourceMemberNamingConvention = namingConvention;
_mappingOptions.DestinationMemberNamingConvention = new PascalCaseNamingConvention();
_factory = new TypeMapFactory();
}
protected override void Establish_context()
{
INamingConvention namingConvention = CreateStub <INamingConvention>();
namingConvention.Stub(nc => nc.SplittingExpression).Return(new Regex(@"[\p{Ll}0-9]*(?=_?)"));
_mappingOptions = new StubMappingOptions();
_mappingOptions.SourceMemberNamingConvention = new PascalCaseNamingConvention();
_mappingOptions.DestinationMemberNamingConvention = namingConvention;
_factory = new TypeMapFactory();
}
private bool MapDestinationPropertyToSource(LinkedList<MemberInfo> resolvers, TypeInfo sourceType,
string nameToSearch, IMappingOptions mappingOptions)
{
if (string.IsNullOrEmpty(nameToSearch))
return true;
var sourceProperties = sourceType.GetPublicReadAccessors();
var sourceNoArgMethods = sourceType.GetPublicNoArgMethods();
var sourceNoArgExtensionMethods = sourceType.GetPublicNoArgExtensionMethods();
MemberInfo resolver = FindTypeMember(sourceProperties, sourceNoArgMethods, sourceNoArgExtensionMethods, nameToSearch, mappingOptions);
bool foundMatch = resolver != null;
if (foundMatch)
{
resolvers.AddLast(resolver);
}
else
{
string[] matches = mappingOptions.DestinationMemberNamingConvention.SplittingExpression
.Matches(nameToSearch)
.Cast<Match>()
.Select(m => m.Value)
.ToArray();
for (int i = 1; (i <= matches.Length) && (!foundMatch); i++)
{
NameSnippet snippet = CreateNameSnippet(matches, i, mappingOptions);
var valueResolver = FindTypeMember(sourceProperties, sourceNoArgMethods, sourceNoArgExtensionMethods, snippet.First,
mappingOptions);
if (valueResolver != null)
{
resolvers.AddLast(valueResolver);
foundMatch = MapDestinationPropertyToSource(resolvers,
GetTypeInfo(valueResolver.GetMemberType(), mappingOptions.SourceExtensionMethods),
snippet.Second, mappingOptions);
if (!foundMatch)
{
resolvers.RemoveLast();
}
}
}
}
return foundMatch;
}
private static bool NameMatches(string memberName, string nameToMatch, IMappingOptions mappingOptions)
{
var possibleSourceNames = PossibleNames(memberName, mappingOptions.Aliases, mappingOptions.Prefixes,
mappingOptions.Postfixes);
var possibleDestNames = PossibleNames(nameToMatch, mappingOptions.Aliases, mappingOptions.DestinationPrefixes,
mappingOptions.DestinationPostfixes);
var all =
from sourceName in possibleSourceNames
from destName in possibleDestNames
select new { sourceName, destName };
return(all.Any(pair => String.Compare(pair.sourceName, pair.destName, StringComparison.OrdinalIgnoreCase) == 0));
}
private static bool NameMatches(string memberName, string nameToMatch, IMappingOptions mappingOptions)
{
var possibleSourceNames = PossibleNames(memberName, mappingOptions.Aliases, mappingOptions.Prefixes,
mappingOptions.Postfixes);
var possibleDestNames = PossibleNames(nameToMatch, mappingOptions.Aliases, mappingOptions.DestinationPrefixes,
mappingOptions.DestinationPostfixes);
var all =
from sourceName in possibleSourceNames
from destName in possibleDestNames
select new {sourceName, destName};
return all.Any(pair => String.Compare(pair.sourceName, pair.destName, StringComparison.OrdinalIgnoreCase) == 0);
}
public DictionaryMapperContext(Type source, Type target, IMappingOptions options)
: base(source, target, options)
{
var sourceCollectionElementKeyType = SourceCollectionElementType.GetGenericArguments()[0];
var sourceCollectionElementValueType = SourceCollectionElementType.GetGenericArguments()[1];
var targetCollectionElementKeyType = TargetCollectionElementType.GetGenericArguments()[0];
var targetCollectionElementValueType = TargetCollectionElementType.GetGenericArguments()[1];
SourceCollectionElementKey = Expression.Variable(sourceCollectionElementKeyType, "sourceKey");
SourceCollectionElementValue = Expression.Variable(sourceCollectionElementValueType, "sourceValue");
TargetCollectionElementKey = Expression.Variable(targetCollectionElementKeyType, "targetKey");
TargetCollectionElementValue = Expression.Variable(targetCollectionElementValueType, "targetValue");
}
public MapperContext(Type source, Type target, IMappingOptions options)
{
SourceInstance = Expression.Parameter(source, "sourceInstance");
TargetInstance = Expression.Parameter(target, "targetInstance");
switch (options)
{
case MemberMappingOptionsInheritanceTraversal mmc: this.Options = mmc; break;
case TypeMappingOptionsInheritanceTraversal tmc: this.Options = tmc; break;
case IMemberOptions imo: this.Options = new MemberMappingOptionsInheritanceTraversal((MemberMapping)options); break;
case ITypeOptions imo: this.Options = new TypeMappingOptionsInheritanceTraversal((TypeMapping)options); break;
}
}
protected override void Establish_context()
{
_mappingOptions = CreateStub <IMappingOptions>();
Func <string, string> transformer = s =>
{
s = Regex.Replace(s, "(?:^Foo)?(.*)", "$1");
return(Regex.Replace(s, "(.*)(?:Bar|Blah)$", "$1"));
};
_mappingOptions.SourceMemberNameTransformer = s => s;
_mappingOptions.DestinationMemberNameTransformer = transformer;
_mappingOptions.SourceMemberNamingConvention = new PascalCaseNamingConvention();
_mappingOptions.DestinationMemberNamingConvention = new PascalCaseNamingConvention();
_factory = new TypeMapFactory();
}
public ReferenceMapperContext(Type source, Type target, IMappingOptions options)
: base(source, target, options)
{
ReferenceTracker = Expression.Parameter(typeof(ReferenceTracking), "referenceTracker");
if (!SourceInstance.Type.IsValueType)
{
SourceNullValue = Expression.Constant(null, SourceInstance.Type);
}
if (!TargetInstance.Type.IsValueType)
{
TargetNullValue = Expression.Constant(null, TargetInstance.Type);
}
Mapper = Expression.Variable(typeof(Mapper), "mapper");
}
public CollectionMapperContext(Type source, Type target, IMappingOptions options)
: base(source, target, options)
{
SourceCollectionElementType = SourceInstance.Type.GetCollectionGenericType();
TargetCollectionElementType = TargetInstance.Type.GetCollectionGenericType();
if (SourceCollectionElementType != null)
{
IsSourceElementTypeBuiltIn = SourceCollectionElementType.IsBuiltIn(true);
SourceCollectionLoopingVar = Expression.Parameter(SourceCollectionElementType, "loopVar");
}
if (TargetCollectionElementType != null)
{
IsTargetElementTypeBuiltIn = TargetCollectionElementType.IsBuiltIn(true);
}
Continue = Expression.Label("LoopContinue");
Break = Expression.Label("LoopBreak");
}
public TypeMap CreateTypeMap(Type sourceType, Type destinationType, IMappingOptions options)
{
var sourceTypeInfo = GetTypeInfo(sourceType);
var destTypeInfo = GetTypeInfo(destinationType);
var typeMap = new TypeMap(sourceTypeInfo, destTypeInfo);
foreach (var destProperty in destTypeInfo.GetPublicWriteAccessors())
{
var members = new LinkedList <MemberInfo>();
if (MapDestinationPropertyToSource(members, sourceTypeInfo, destProperty.Name, options))
{
var resolvers = members.Select(mi => mi.ToMemberGetter());
var destPropertyAccessor = destProperty.ToMemberAccessor();
typeMap.AddPropertyMap(destPropertyAccessor, resolvers);
}
}
return(typeMap);
}
private static MemberInfo FindTypeMember(IEnumerable<MemberInfo> modelProperties,
IEnumerable<MethodInfo> getMethods,
IEnumerable<MethodInfo> getExtensionMethods,
string nameToSearch,
IMappingOptions mappingOptions)
{
var pi = modelProperties.FirstOrDefault(prop => NameMatches(prop.Name, nameToSearch, mappingOptions));
if (pi != null)
return pi;
var mi = getMethods.FirstOrDefault(m => NameMatches(m.Name, nameToSearch, mappingOptions));
if (mi != null)
return mi;
mi = getExtensionMethods.FirstOrDefault(m => NameMatches(m.Name, nameToSearch, mappingOptions));
if (mi != null)
return mi;
return null;
}
public TypeMap CreateTypeMap(Type sourceType, Type destinationType, IMappingOptions options)
{
var sourceTypeInfo = GetTypeInfo(sourceType);
var destTypeInfo = GetTypeInfo(destinationType);
var typeMap = new TypeMap(sourceTypeInfo, destTypeInfo);
foreach (var destProperty in destTypeInfo.GetPublicWriteAccessors())
{
var members = new LinkedList<MemberInfo>();
if (MapDestinationPropertyToSource(members, sourceTypeInfo, destProperty.Name, options))
{
var resolvers = members.Select(mi => mi.ToMemberGetter()).Cast<IValueResolver>();
var destPropertyAccessor = destProperty.ToMemberAccessor();
typeMap.AddPropertyMap(destPropertyAccessor, resolvers);
}
}
return typeMap;
}
public IEnumerable <TTo> Map <TFrom>(IEnumerable <TFrom> items, IMappingOptions options = null, IEnumerable <TTo> defaultValue = null)
{
options = options ?? new MappingOptions();
defaultValue = defaultValue ?? Enumerable.Empty <TTo>();
if (items == null)
{
return(defaultValue);
}
// todo: заюзать вызов экстеншена
var collectionMapper = (ICollectionMapper <TFrom, TTo>)_serviceProvider.GetService(typeof(ICollectionMapper <TFrom, TTo>));
if (collectionMapper != null)
{
return(collectionMapper.Map(items, options));
}
// todo: заюзать вызов экстеншена
var itemMapper = (IMapper <TFrom, TTo>)_serviceProvider.GetService(typeof(IMapper <TFrom, TTo>));
return(itemMapper == null ? defaultValue : items.Where(x => x != null).Select(x => itemMapper.Map(x, options)));
}
protected override ReferenceMapperContext GetMapperContext(Type source, Type target, IMappingOptions options)
{
return(new CollectionMapperContext(source, target, options));
}
protected override void Establish_context()
{
var namingConvention = new StubNamingConvention();
namingConvention.SplittingExpression = new Regex(@"[\p{Ll}0-9]*(?=_?)");
_mappingOptions = new StubMappingOptions();
_mappingOptions.SourceMemberNamingConvention = new PascalCaseNamingConvention();
_mappingOptions.DestinationMemberNamingConvention = namingConvention;
_factory = new TypeMapFactory();
}
protected override void Establish_context()
{
var namingConvention = new StubNamingConvention();
namingConvention.SeparatorCharacter = "__";
_mappingOptions = new StubMappingOptions();
_mappingOptions.SourceMemberNamingConvention = namingConvention;
_mappingOptions.DestinationMemberNamingConvention = new PascalCaseNamingConvention();
_factory = new TypeMapFactory();
}
private NameSnippet CreateNameSnippet(IEnumerable<string> matches, int i, IMappingOptions mappingOptions)
{
return new NameSnippet
{
First =
string.Join("", matches.Take(i).ToArray()),
Second =
string.Join("", matches.Skip(i).ToArray())
};
}
protected virtual ReferenceMapperContext GetMapperContext(Type source, Type target, IMappingOptions options)
{
return(new ReferenceMapperContext(source, target, options));
}
public static T Get <T>(this IMappingOptions options, T defaultValue = default(T))
{
return((T)options.Get(typeof(T), defaultValue));
}
private TypeInfo GetTypeInfo(Type type, IMappingOptions mappingOptions)
{
return GetTypeInfo(type, mappingOptions.ShouldMapProperty, mappingOptions.ShouldMapField, mappingOptions.SourceExtensionMethods);
}
public override LambdaExpression GetMappingExpression(Type source, Type target, IMappingOptions options)
{
var context = (CollectionMapperContext)this.GetMapperContext(source, target, options);
var mappingExpression = MapperConfiguration[typeof(ParsedCommand), target].MappingExpression;
var body = ExpressionLoops.ForEach(context.SourceInstance, context.SourceCollectionLoopingVar,
Expression.Invoke(mappingExpression, context.ReferenceTracker,
context.SourceCollectionLoopingVar, context.TargetInstance));
var delegateType = typeof(Action <, ,>).MakeGenericType(
context.ReferenceTracker.Type, context.SourceInstance.Type,
context.TargetInstance.Type);
return(Expression.Lambda(delegateType, body,
context.ReferenceTracker, context.SourceInstance, context.TargetInstance));
}
public static IMappingOptions Extend(this IMappingOptions parent, params object[] options)
{
return(parent.Extend(new MappingOptions(options)));
}
protected override void Establish_context()
{
INamingConvention namingConvention = CreateStub<INamingConvention>();
namingConvention.Stub(nc => nc.SplittingExpression).Return(new Regex(@"[\p{Ll}0-9]*(?=_?)"));
_mappingOptions = CreateStub<IMappingOptions>();
_mappingOptions.SourceMemberNamingConvention = new PascalCaseNamingConvention();
_mappingOptions.DestinationMemberNamingConvention = namingConvention;
_mappingOptions.SourceMemberNameTransformer = s => s;
_mappingOptions.DestinationMemberNameTransformer = s => s;
_factory = new TypeMapFactory();
}
protected override void Establish_context()
{
INamingConvention namingConvention = CreateStub<INamingConvention>();
namingConvention.Stub(nc => nc.SeparatorCharacter).Return("__");
_mappingOptions = CreateStub<IMappingOptions>();
_mappingOptions.SourceMemberNamingConvention = namingConvention;
_mappingOptions.DestinationMemberNamingConvention = new PascalCaseNamingConvention();
_mappingOptions.SourceMemberNameTransformer = s => s;
_mappingOptions.DestinationMemberNameTransformer = s => s;
_factory = new TypeMapFactory();
}
public virtual LambdaExpression GetMappingExpression(Type source, Type target, IMappingOptions options)
{
var context = this.GetMapperContext(source, target, options);
var typeMapping = MapperConfiguration[context.SourceInstance.Type, context.TargetInstance.Type];
var memberMappings = this.GetMemberMappings(typeMapping)
.ReplaceParameter(context.Mapper, context.Mapper.Name)
.ReplaceParameter(context.ReferenceTracker, context.ReferenceTracker.Name)
.ReplaceParameter(context.TargetInstance, context.TargetInstance.Name)
.ReplaceParameter(context.SourceInstance, context.SourceInstance.Name);
var expression = Expression.Block
(
new[] { context.Mapper },
Expression.Assign(context.Mapper, Expression.Constant(_mapper)),
memberMappings,
this.GetExpressionBody(context)
);
var delegateType = typeof(Action <, ,>).MakeGenericType(
context.ReferenceTracker.Type, context.SourceInstance.Type,
context.TargetInstance.Type);
return(Expression.Lambda(delegateType, expression,
context.ReferenceTracker, context.SourceInstance, context.TargetInstance));
}
protected override void Establish_context()
{
_mappingOptions = CreateStub<IMappingOptions>();
Func<string, string> transformer = s =>
{
s = Regex.Replace(s, "(?:^Foo)?(.*)", "$1");
return Regex.Replace(s, "(.*)(?:Bar|Blah)$", "$1");
};
_mappingOptions.SourceMemberNameTransformer = transformer;
_mappingOptions.DestinationMemberNameTransformer = s => s;
_mappingOptions.SourceMemberNamingConvention = new PascalCaseNamingConvention();
_mappingOptions.DestinationMemberNamingConvention = new PascalCaseNamingConvention();
_factory = new TypeMapFactory();
}
private TypeInfo GetTypeInfo(Type type, IEnumerable<MethodInfo> extensionMethodsToSearch, IMappingOptions mappingOptions)
{
TypeInfo typeInfo = _typeInfos.GetOrAdd(type, t => new TypeInfo(type, mappingOptions.BindingFlags, extensionMethodsToSearch));
return typeInfo;
}
