public static List <MappingMember> GetMemberBinding(Type source, Type target) { TypePair typePair = TypePair.Create(source, target); var result = targetMapperBuilder.MemberBuilder.Build(typePair); return(result); }
/// <summary> /// Maps the source to Target type. /// The method can be called in parallel to Map methods, but cannot be called in parallel to Bind method. /// </summary> /// <param name="sourceType">Source type.</param> /// <param name="targetType">Target type.</param> /// <param name="source">Source object.</param> /// <param name="target">Target object.</param> /// <returns>Mapped object.</returns> public static object Map(Type sourceType, Type targetType, object source, object target = null) { var typePair = TypePair.Create(sourceType, targetType); var mapper = GetMapper(typePair); var result = mapper.Map(source, target); return(result); }
/// <summary> /// Find out if a binding exists from Source to Target. /// </summary> /// <param name="sourceType">Source type.</param> /// <param name="targetType">Target type.</param> /// <returns>True if exists, otherwise - False.</returns> /// <remarks>The method is thread safe.</remarks> public static bool BindingExists(Type sourceType, Type targetType) { var typePair = TypePair.Create(sourceType, targetType); lock (_mappersLock) { return(_mappers.ContainsKey(typePair)); } }
/// <summary> /// Find out if a binding exists from Source to Target. /// </summary> /// <typeparam name="TSource">Source type.</typeparam> /// <typeparam name="TTarget">Target type.</typeparam> /// <returns>True if exists, otherwise - False.</returns> /// <remarks>The method is thread safe.</remarks> public static bool BindingExists <TSource, TTarget>() { var typePair = TypePair.Create <TSource, TTarget>(); lock (_mappersLock) { return(_mappers.ContainsKey(typePair)); } }
public static TTarget Map <TSource, TTarget>(TSource source, TTarget target = default(TTarget)) { TypePair typePair = TypePair.Create <TSource, TTarget>(); Mapper mapper = GetMapper(typePair); var result = (TTarget)mapper.Map(source, target); return(result); }
/// <summary> /// Create a one-way mapping between Source and Target types. /// </summary> /// <typeparam name="TSource">Source type.</typeparam> /// <typeparam name="TTarget">Target type.</typeparam> /// <remarks>The method is thread safe.</remarks> public static void Bind <TSource, TTarget>() { var typePair = TypePair.Create <TSource, TTarget>(); lock (_mappersLock) { _mappers[typePair] = _targetMapperBuilder.Build(typePair); } }
public static void Bind <TSource, TTarget>(Action <IBindingConfig <TSource, TTarget> > config) { TypePair typePair = TypePair.Create <TSource, TTarget>(); var bindingConfig = new BindingConfigOf <TSource, TTarget>(); config(bindingConfig); _mappers[typePair] = _targetMapperBuilder.Build(typePair, bindingConfig); }
internal static TTarget MapCore <TSource, TTarget>(TSource source, TTarget target, int depth) { if (source == null || depth > mapperConfig.MaxDepth) { return(target); } TypePair pair = TypePair.Create <TSource, TTarget>(); IMapper mapper = MapperUtil.GetMapper(pair); return((TTarget)mapper.Map(source, target, mapperConfig.ReferencePropertyHandle, depth + 1)); }
public static void BindCustom <TSource, TTarget>(Func <TSource, TTarget> mapper) { TypePair typePair = TypePair.Create <TSource, TTarget>(); if (mapper == null) { throw new ArgumentNullException(nameof(mapper)); } Func <object, object> innerMapper = x => mapper((TSource)x); CustomMapper.Add(typePair, innerMapper); }
/// <summary> /// Create a one-way mapping between Source and Target types. /// </summary> /// <typeparam name="TSource">Source type.</typeparam> /// <typeparam name="TTarget">Target type.</typeparam> /// <param name="config">BindingConfig for custom binding.</param> /// <remarks>The method is thread safe.</remarks> public IObjectMapper Bind <TSource, TTarget>(Action <IBindingConfig <TSource, TTarget> > config) { TypePair typePair = TypePair.Create <TSource, TTarget>(); var bindingConfig = new BindingConfigOf <TSource, TTarget>(); config(bindingConfig); var mapper = _targetMapperBuilder.Build(typePair, bindingConfig); Bind(typePair, mapper); return(this); }
/// <summary> /// Find out if a binding exists for Source to Target /// </summary> /// <typeparam name="TSource">Source type</typeparam> /// <typeparam name="TTarget">Target type</typeparam> /// <returns></returns> public static bool BindingExists <TSource, TTarget>() { TypePair typePair = TypePair.Create <TSource, TTarget>(); Mapper mapper; _mappersLock.EnterReadLock(); var result = _mappers.TryGetValue(typePair, out mapper); _mappersLock.ExitReadLock(); return(result); }
internal static IEnumerable <TTarget> MapCores <TSource, TTarget>(IEnumerable <TSource> source, int depth) { if (source == null || depth > mapperConfig.MaxDepth) { return(null); } TypePair pair = TypePair.Create <TSource, TTarget>(); IMapper mapper = MapperUtil.GetMapper(pair); var list = new List <TTarget>(); foreach (TSource item in source) { TTarget rst = (TTarget)mapper.Map(item, default, mapperConfig.ReferencePropertyHandle, depth + 1);
/// <summary> /// Create a one-way mapping between Source and Target types. /// </summary> /// <typeparam name="TSource">Source type.</typeparam> /// <typeparam name="TTarget">Target type.</typeparam> /// <param name="config">BindingConfig for custom binding.</param> /// <remarks>The method is thread safe.</remarks> public static void Bind <TSource, TTarget>(Action <IDefaultBindingConfig <TSource, TTarget> > config) { var typePair = TypePair.Create <TSource, TTarget>(); var bindingConfig = new DefaultBindingConfigOf <TSource, TTarget>(); config(bindingConfig); lock (_mappersLock) { _mappers[typePair] = _targetMapperBuilder.Build(typePair, bindingConfig); } }
/// <summary> /// Maps the source to Target type. /// The method can be called in parallel to Map methods, but cannot be called in parallel to Bind method. /// </summary> /// <typeparam name="TTarget">Target type.</typeparam> /// <param name="source">Source object [Not null].</param> /// <returns>Mapped object. The method can be called in parallel to Map methods, but cannot be called in parallel to Bind method.</returns> public static TTarget Map <TTarget>(object source) { if (source.IsNull()) { throw Error.ArgumentNull("Source cannot be null. Use TinyMapper.Map<TSource, TTarget> method instead."); } var typePair = TypePair.Create(source.GetType(), typeof(TTarget)); var mapper = GetMapper(typePair); var result = (TTarget)mapper.Map(source); return(result); }
protected override void BuildCore(TypePair typePair, BindingConfig bindingConfig) { var members = MemberBuilder.Build(typePair).Where(x => !x.Ignored).ToList(); var equalMembers = new List <MappingMember>(); var mappingMembers = new List <MappingMember>(); var refMembers = new List <MappingMember>(); var collectionMembers = new List <MappingMember>(); var expressionMembers = new List <MappingMember>(); foreach (var item in members) { if (item.IsExpressionMapping) { expressionMembers.Add(item); } else { var memberTypePair = TypePair.Create(item.Source.GetMemberType(), item.Target.GetMemberType()); if (memberTypePair.IsEqualTypes) { equalMembers.Add(item); } else if (memberTypePair.IsBaseTypes) { mappingMembers.Add(item); } else if (config.ReferencePropertyHandle != ReferencePropertyHandle.Ignore) { if (memberTypePair.IsEnumerableTypes) { collectionMembers.Add(item); } else { refMembers.Add(item); } } } } var func = CreateMapper(typePair, equalMembers, mappingMembers); MapperCache.Add(typePair, func); var action = CreateMapperRef(typePair, refMembers, collectionMembers, expressionMembers); if (action != null) { MapperRefCache.Add(typePair, action); } }
/// <summary> /// Create a one-way mapping between one type and another /// </summary> /// <typeparam name="TSource">Source type</typeparam> /// <typeparam name="TTarget">Target type</typeparam> public static void Bind <TSource, TTarget>() { TypePair typePair = TypePair.Create <TSource, TTarget>(); _mappersLock.EnterWriteLock(); try { _mappers[typePair] = _targetMapperBuilder.Build(typePair); } finally { _mappersLock.ExitWriteLock(); } }
/// <summary> /// Maps the specified source to <see cref="TTarget" /> type. /// </summary> /// <typeparam name="TTarget">The type of the target.</typeparam> /// <param name="source">The source value.</param> /// <returns>Value</returns> /// <remarks>For mapping nullable type use <see cref="Map{TTarget}" />method.</remarks> public static TTarget Map <TTarget>(object source) { if (source.IsNull()) { throw Error.ArgumentNull("source, for mapping nullable type use Map<TSource, TTarget> method"); } TypePair typePair = TypePair.Create(source.GetType(), typeof(TTarget)); Mapper mapper = GetMapper(typePair); var result = (TTarget)mapper.Map(source); return(result); }
/// <summary> /// Create a one-way mapping between Source and Target types. /// </summary> /// <typeparam name="TSource">Source type.</typeparam> /// <typeparam name="TTarget">Target type.</typeparam> /// <param name="config">BindingConfig for custom binding.</param> /// <remarks>The method is thread safe.</remarks> public static IReverseBinding <TTarget, TSource> Bind <TSource, TTarget>(Action <IBindingConfig <TSource, TTarget> > config) { TypePair typePair = TypePair.Create <TSource, TTarget>(); var bindingConfig = new BindingConfigOf <TSource, TTarget>(); config(bindingConfig); lock (_mappersLock) { _mappers[typePair] = _targetMapperBuilder.Build(typePair, bindingConfig); } return(new ReverseBinding <TTarget, TSource>(bindingConfig.BindExpression)); }
/// <summary> /// Create a one-way mapping between Source and Target types. /// </summary> /// <param name="sourceType">Source type.</param> /// <param name="targetType">Target type.</param> /// <remarks>The method is thread safe.</remarks> public IObjectMapper Bind(Type sourceType, Type targetType) { if (sourceType == null) { throw new ArgumentNullException(nameof(sourceType)); } if (targetType == null) { throw new ArgumentNullException(nameof(targetType)); } TypePair typePair = TypePair.Create(sourceType, targetType); var mapper = _targetMapperBuilder.Build(typePair); Bind(typePair, mapper); return(this); }
public static void Bind <TSource, TTarget>(Action <IBindingConfig <TSource, TTarget> > config = null) { TypePair typePair = TypePair.Create <TSource, TTarget>(); if (config == null) { Bind(typePair); } else { var bindingConfig = new BindingConfig <TSource, TTarget>(); config(bindingConfig); BindingConfig.Add(typePair, bindingConfig); CustomMapper.Remove(typePair); targetMapperBuilder.Build(typePair); } }
public PropertyMap Build() { if (_receiverProperty == null) { throw new InvalidOperationException("You must configure receiver member before build"); } if (_mappingActions == null) { throw new InvalidOperationException("You must configure mapping actions before build"); } return(new PropertyMap( TypePair.Create <TSource, TReceiver>(), _receiverProperty, _mappingActions)); }
/// <summary> /// Create a one-way mapping between Source and Target types. /// </summary> /// <param name="sourceType">Source type.</param> /// <param name="targetType">Target type.</param> /// <remarks>The method is thread safe.</remarks> public static void Bind(Type sourceType, Type targetType) { if (sourceType is null) { throw new ArgumentNullException(nameof(sourceType)); } if (targetType is null) { throw new ArgumentNullException(nameof(targetType)); } var typePair = TypePair.Create(sourceType, targetType); lock (_mappersLock) { _mappers[typePair] = _targetMapperBuilder.Build(typePair); } }
/// <summary> /// Find out if a binding exists from Source to Target. /// </summary> /// <param name="sourceType">Source type.</param> /// <param name="targetType">Target type.</param> /// <returns>True if exists, otherwise - False.</returns> /// <remarks>The method is thread safe.</remarks> public static bool BindingExists(Type sourceType, Type targetType) { if (sourceType == null) { throw new ArgumentNullException(nameof(sourceType)); } if (targetType == null) { throw new ArgumentNullException(nameof(targetType)); } TypePair typePair = TypePair.Create(sourceType, targetType); lock (_mappersLock) { return(_mappers.ContainsKey(typePair)); } }
/// <summary> /// Create a one-way mapping between one type and another /// </summary> /// <typeparam name="TSource">Source type</typeparam> /// <typeparam name="TTarget">Target type</typeparam> /// <param name="config">BindingConfig for Custom Binding</param> public static void Bind <TSource, TTarget>(Action <IBindingConfig <TSource, TTarget> > config) { TypePair typePair = TypePair.Create <TSource, TTarget>(); var bindingConfig = new BindingConfigOf <TSource, TTarget>(); config(bindingConfig); _mappersLock.EnterWriteLock(); try { _mappers[typePair] = _targetMapperBuilder.Build(typePair, bindingConfig); } finally { _mappersLock.ExitWriteLock(); } }
public ProfileMap Build() { if (_executionClause == null) { throw new InvalidOperationException("Execution clause must be set for non default profile"); } if (!_propertyMaps.Any()) { throw new InvalidOperationException("No property maps configured"); } var typePair = TypePair.Create <TSource, TReceiver>(); return(new ProfileMap( typePair, GetReceiverConstructorInfo(typePair.ReceiverType), _executionClause, _isDefault, _propertyMaps)); }
public IProfileMapBuilder <TSource, TReceiver> UsePropertyMaps(IEnumerable <PropertyMap> propertyMaps) { if (propertyMaps == null) { throw new ArgumentNullException(nameof(propertyMaps)); } var typePair = TypePair.Create <TSource, TReceiver>(); var propertyMapsList = propertyMaps.ToList(); if (!propertyMapsList.Any(c => c.TypePair.Equals(typePair))) { throw new ArgumentException("Property map for different type pair received"); } foreach (var propertyMap in propertyMapsList) { AddOrReplacePropertyMap(propertyMap); } return(this); }
//Note: Lock should already be acquired for the mapper private static Mapper GetPolymorphicMapping(TypePair types) { // Walk the polymorphic heirarchy until we find a mapping match Type source = types.Source; do { Mapper result; foreach (var iface in source.GetInterfaces()) { if (_mappers.TryGetValue(TypePair.Create(iface, types.Target), out result)) { return(result); } } if (_mappers.TryGetValue(TypePair.Create(source, types.Target), out result)) { return(result); } }while ((source = source.BaseType) != null); return(null); }
public static void Bind <TSource, TTarget>() { TypePair typePair = TypePair.Create <TSource, TTarget>(); _mappers[typePair] = _targetMapperBuilder.Build(typePair); }
public static void Bind(Type source, Type target) { TypePair typePair = TypePair.Create(source, target); Bind(typePair); }
public static bool BindingExists(Type source, Type target) { TypePair typePair = TypePair.Create(source, target); return(BindingConfig.Has(typePair)); }