private void AddMappingActions(IExtensibleMapper <TSource, TTarget> mapper)
{
var doc = XDocument.Load("MappingExpectations.xml");
var srcType = typeof(TSource);
var trgType = typeof(TTarget);
var props = from m in doc.Descendants("Mapper")
where m.Attribute("Type").Value == "ManualMapper"
from p in m.Descendants("Pair")
where srcType.Name.Equals(p.Attribute("SourceType").Value)
where trgType.Name.Equals(p.Attribute("TargetType").Value)
from mp in p.Descendants("Property")
select new
{
srcProp = mp.Attribute("SourceProp").Value,
trgProp = mp.Attribute("TargetProp").Value,
};
foreach (var p in props)
{
mapper.AddMappingAction(
p.srcProp,
p.trgProp,
(source, target) =>
{
var srcVal = typeof(TSource).GetProperty(p.srcProp).GetValue(source, null);
typeof(TTarget).GetProperty(p.trgProp).SetValue(target, srcVal, null);
});
}
}
/// <summary>
/// Adds a mapping rule for the specified members.
/// </summary>
/// <typeparam name="TSource">Type of the source.</typeparam>
/// <typeparam name="TTarget">Type of the target.</typeparam>
/// <param name="sourceMemberName">
/// Source member.
/// </param>
/// <param name="targetMemberName">
/// Destination member.
/// </param>
/// <param name="mappingAction">
/// The delegate that will perform the conversion.
/// </param>
public void AddMappingAction <TSource, TTarget>(string sourceMemberName, string targetMemberName,
MappingAction <TSource, TTarget> mappingAction)
{
IExtensibleMapper <TSource, TTarget> mapper = ResolveMapper <TSource, TTarget>();
mapper.AddMappingAction(sourceMemberName, targetMemberName, mappingAction);
}
/// <summary>
/// Performs basic validation and fires off mapping generation.
/// </summary>
/// <param name="innerMappers">
/// List of internal mappers to use.
/// </param>
private void Initialize(IMapper <TSource, TTarget>[] innerMappers)
{
Guard.CheckEnumerableNotNullOrEmpty(innerMappers, "innerMappers");
Guard.TrueForAll(innerMappers, "innerMappers", m => m != null, "Mappers list cannot contain null elements.");
InnerMappers = innerMappers.Reverse();
ExtensibleMapper = innerMappers.OfType <IExtensibleMapper <TSource, TTarget> >().FirstOrDefault();
}
public static IEnumerable <TTarget> MapAll <TSource, TTarget>(this IEnumerable <TSource> source,
IMappingRepository repo)
{
Guard.CheckArgumentNotNull(repo, "repo");
IExtensibleMapper <TSource, TTarget> mapper = repo.ResolveMapper <TSource, TTarget>();
return(MapAll(source, mapper));
}
internal TargetSpec(
IExtensibleMapper <TSource, TTarget> mapper,
Expression <Func <TSource, TInnerSource> > sourceArgument,
bool useInnerMapper)
{
Guard.CheckArgumentNotNull(mapper, "mapper");
Guard.CheckArgumentNotNull(sourceArgument, "sourceArgument");
Mapper = mapper;
SourceArgument = sourceArgument;
UseInnerMapper = useInnerMapper;
}
public IExtensibleMapper <TSource, TTarget> ResolveMapper <TSource, TTarget>()
{
IExtensibleMapper <TSource, TTarget> res = TryGetMapper <TSource, TTarget>();
if (res == null)
{
lock (_options)
{
var innerMappers = new List <IMapper <TSource, TTarget> >();
IEnumerable <Type> mapperTypes = _options.MapperOrder;
foreach (Type t in mapperTypes)
{
Type targetType = t;
if (targetType.IsGenericType)
{
targetType = targetType.GetGenericTypeDefinition();
targetType = targetType.MakeGenericType(new[] { typeof(TSource), typeof(TTarget) });
}
IMapper <TSource, TTarget> m = CreateMapper <TSource, TTarget>(targetType);
innerMappers.Add(m);
}
res = new CompositeMapper <TSource, TTarget>(
new MapperConstructionInfo(this),
innerMappers.ToArray());
AddMapper(res);
}
}
return(res);
}
/// <summary>
/// Initializes a new instance of the <see cref="SourceSpec{TSource,TTarget}"/> class.
/// </summary>
/// <param name="mapper">Mapper to extend</param>
public SourceSpec(IExtensibleMapper <TSource, TTarget> mapper)
{
Guard.CheckArgumentNotNull(mapper, "mapper");
this.Mapper = mapper;
}
/// <summary>
/// Adds the specified mapper to the repository.
/// </summary>
/// <typeparam name="TSource">The type of the source.</typeparam>
/// <typeparam name="TTarget">The type of the target.</typeparam>
/// <param name="mapper">The mapper to be added.</param>
public void AddMapper <TSource, TTarget>(IExtensibleMapper <TSource, TTarget> mapper)
{
this.mappers[GetKey <TSource, TTarget>()] = mapper;
}
public TargetSpec(IExtensibleMapper <TSource, TTarget> mapper,
Expression <Func <TSource, TInnerSource> > sourceArgument)
: this(mapper, sourceArgument, false)
{
}
/// <summary>
/// Allows adding mapping actions through the fluent API.
/// </summary>
/// <typeparam name="TSource">Type of the source object.</typeparam>
/// <typeparam name="TTarget">Type of the target object.</typeparam>
/// <returns>
/// A SourceSpec object, for property mapping.
/// </returns>
public ISourceSpec <TSource, TTarget> AddMapping <TSource, TTarget>()
{
IExtensibleMapper <TSource, TTarget> mapper = ResolveMapper <TSource, TTarget>();
return(new SourceSpec <TSource, TTarget>(mapper));
}