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)); }
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; }