//[Test]
public void TestReflection()
{
TransformerObserver a = new TransformerObserver();
ITransformerResolver aa = a;
ISourceMapper <Person, PersonaGiuridica> mapper0 = FactoryMapper.DynamicResolutionMapper <Person, PersonaGiuridica>();
SourceMapper <Person, PersonaGiuridica> mapper = new SourceMapper <Person, PersonaGiuridica>(new List <IPropertyMapper <Person, PersonaGiuridica> >(), null, null);
//aa.Register<ISourceMapper<Person, PersonaGiuridica>>(mapper);
//aa.Register(mapper0);
object obj1 = new Person();
object obj2 = new Person();
Type t1 = typeof(IPersonHeader);
Type t2 = typeof(Person);
try
{
object instance = 5.5;
//int i = (int) instance;
byte bb = Convert.ToByte(instance);
byte b = (byte)instance;
double d = (double)instance;
}
catch (Exception)
{
Assert.IsFalse(true, "Cast invalid");
}
Compare <IPersonHeader>(obj1, obj2);
//Compare<long>(1, 10);
}
/// <summary>
/// Makes a dynamic action in order to associate property source with property destination using a dynamic resolver.
/// </summary>
/// <typeparam name="TSource">The type of the source.</typeparam>
/// <typeparam name="TDestination">The type of the destination.</typeparam>
/// <param name="srcProperty">The source property.</param>
/// <param name="destProperty">The dest property.</param>
/// <param name="resolver">The resolver.</param>
/// <returns></returns>
/// <exception cref="MissingAccessorException">
/// No getter method available for retrieving value for setting property destination.
/// or
/// No setter method available for setting property destination.
/// </exception>
public static Action <TSource, TDestination> DynamicPropertyMap <TSource, TDestination>
(PropertyInfo srcProperty, PropertyInfo destProperty, ITransformerResolver resolver)
{
Type srcPropType = srcProperty.PropertyType;
Type dstPropType = destProperty.PropertyType;
Type funcType = FunctionGetter.MakeGenericType(srcProperty.DeclaringType, srcPropType);
Type actType = ActionSetter.MakeGenericType(destProperty.DeclaringType, dstPropType);
MethodInfo getterMethod = srcProperty.GetGetMethod() ?? srcProperty.GetGetMethod(true);
MethodInfo setterMethod = destProperty.GetSetMethod() ?? destProperty.GetSetMethod(true);
if (getterMethod == null)
{
throw new MissingAccessorException("No getter method available for retrieving value for setting property destination.");
}
if (setterMethod == null)
{
throw new MissingAccessorException("No setter method available for setting property destination.");
}
Delegate getter = Delegate.CreateDelegate(funcType, null, getterMethod);
Delegate setter = Delegate.CreateDelegate(actType, null, setterMethod);
Action <TSource, TDestination> action
= (source, destination) => setter.DynamicInvoke(destination, resolver.TryToMap(getter.DynamicInvoke(source), destProperty.PropertyType));
return(action);
}
/// <summary>
/// Initializes a new instance of the <see cref="PropertyMapper{TSource, TDestination}"/> class.
/// </summary>
/// <param name="srcProperty">The source property.</param>
/// <param name="destProperty">The dest property.</param>
/// <param name="resolver">The resolver.</param>
/// <exception cref="LambdaSetterException">The setter action for property mapper cannot be null.</exception>
public PropertyMapper(PropertyInfo srcProperty, PropertyInfo destProperty, ITransformerResolver resolver)
: base("[resolver]", destProperty.Name)
{
Action <TSource, TDestination> action = FactoryMapper.DynamicPropertyMap <TSource, TDestination>(srcProperty, destProperty, resolver);
if (action == null)
{
throw new LambdaSetterException("The setter action for property mapper cannot be null.");
}
this.setter = action;
}
/// <summary>
/// Get all default property mappers for the given types.
/// </summary>
/// <typeparam name="TSource"></typeparam>
/// <typeparam name="TDestination"></typeparam>
/// <returns></returns>
public static IEnumerable <IPropertyMapper <TSource, TDestination> > GetDefaultPropertyMappers
<TSource, TDestination>(ITransformerResolver resolver)
where TSource : class
where TDestination : class
{
IEnumerable <KeyValuePair <PropertyInfo, PropertyInfo> > matchedProperties = FactoryMapper.GetSuitedPropertiesOf(typeof(TSource), typeof(TDestination));
HashSet <IPropertyMapper <TSource, TDestination> > mappers = new HashSet <IPropertyMapper <TSource, TDestination> >();
foreach (var current in matchedProperties)
{
try
{
Action <TSource, TDestination> action = DynamicPropertyMap <TSource, TDestination>(current.Key,
current.Value);
mappers.Add(new PropertyMapper <TSource, TDestination>(action, current.Key.Name, current.Value.Name));
}
catch (InconsistentMappingException)
{
// exceptions must be managed..
// so in this means that properties are not compatibles..
try
{
if (resolver != null)
{
Action <TSource, TDestination> action = DynamicPropertyMap <TSource, TDestination>(current.Key, current.Value, resolver);
mappers.Add(new PropertyMapper <TSource, TDestination>(action));
}
}
catch
{
}
}
catch
{
}
}
return(mappers);
}
/// <summary>
/// Gets the default property mappers.
/// </summary>
/// <param name="sourceType">Type of the source.</param>
/// <param name="destinationType">Type of the destination.</param>
/// <param name="resolver">The resolver.</param>
/// <returns></returns>
public static IEnumerable <IPropertyMapper> GetDefaultPropertyMappers(Type sourceType, Type destinationType, ITransformerResolver resolver)
{
IEnumerable <KeyValuePair <PropertyInfo, PropertyInfo> > matchedProperties = FactoryMapper.GetSuitedPropertiesOf(sourceType, destinationType);
HashSet <IPropertyMapper> mappers = new HashSet <IPropertyMapper>();
foreach (var current in matchedProperties)
{
try
{
mappers.Add(new PropertyMapper(current.Key, current.Value));
}
catch (InconsistentMappingException)
{
// exceptions must be managed..
// so in this means that properties are not compatibles..
try
{
if (resolver != null)
{
mappers.Add(new PropertyMapper(current.Key, current.Value, resolver));
}
}
catch
{
}
}
catch
{
}
}
return(mappers);
}
