private static void MapItems(IEnumerable sources, IList results, Type resultType, IObjectMappingResolver customMappings, ObjectMappingConflictResolution conflictResolution)
{
if (resultType.IsGenericType)
{
Type itemType = resultType.GetGenericArguments().First();
foreach (object item in sources)
{
object result = MapClass(item, item.GetType(), itemType, customMappings, conflictResolution);
_ = results.Add(result);
}
}
else
{
foreach (object item in sources)
{
object result = MapClass(item, item.GetType(), item.GetType(), customMappings, conflictResolution);
_ = results.Add(result);
}
}
}
private static void MapProperty(object value, object result, PropertyInfo sourceProperty, PropertyInfo resultProperty, IObjectMappingResolver customMappings, ObjectMappingConflictResolution conflictResolution)
{
Type type = resultProperty.PropertyType;
if (value != null)
{
if (type.IsInterface || (type.IsClass && !type.IsAbstract))
{
object convertedVallue = ToClass(value, type, customMappings, conflictResolution);
resultProperty.SetValue(result, convertedVallue, null);
}
else if (conflictResolution == ObjectMappingConflictResolution.Exception)
{
throw new PropertyMappingException(sourceProperty, resultProperty);
}
}
}
private static object MapClass(IEnumerable sources, Type sourceType, Type resultType, IObjectMappingResolver customMappings, ObjectMappingConflictResolution conflictResolution)
{
if (!sourceType.IsCollection())
{
if (conflictResolution == ObjectMappingConflictResolution.Exception)
{
throw new ClassMappingException(sourceType, resultType);
}
return(null);
}
int count = sources.Size();
if (resultType.IsArray)
{
Type itemType = resultType.GetElementType();
Array results = Array.CreateInstance(itemType, count);
MapItems(sources, results, resultType, customMappings, conflictResolution);
return(results);
}
else if (resultType == typeof(IEnumerable) || resultType == typeof(ICollection) || resultType == typeof(IList) ||
(resultType.IsGenericType && (resultType.GetGenericTypeDefinition() == typeof(IEnumerable <>) ||
resultType.GetGenericTypeDefinition() == typeof(ICollection <>) ||
resultType.GetGenericTypeDefinition() == typeof(IList <>))
)
)
{
if (resultType.IsGenericType)
{
Type itemType = resultType.GetGenericArguments().First();
Type listType = typeof(List <>);
listType = listType.MakeGenericType(itemType);
IList results = Activator.CreateInstance(listType) as IList;
MapItems(sources, results, resultType, customMappings, conflictResolution);
return(results);
}
else
{
Type listType = typeof(ArrayList);
IList results = Activator.CreateInstance(listType) as IList;
MapItems(sources, results, resultType, customMappings, conflictResolution);
return(results);
}
}
else if (typeof(IList).IsAssignableFrom(resultType) && resultType.IsClass && !resultType.IsAbstract)
{
IList results = Activator.CreateInstance(resultType) as IList;
MapItems(sources, results, resultType, customMappings, conflictResolution);
return(results);
}
else if (conflictResolution == ObjectMappingConflictResolution.Exception)
{
throw new InvalidOperationException();
}
return(null);
}
private static void MapItems(IEnumerable sources, Array results, Type resultType, IObjectMappingResolver customMappings, ObjectMappingConflictResolution conflictResolution)
{
Type itemType = resultType.GetElementType();
int counter = 0;
foreach (object item in sources)
{
object result = MapClass(item, item.GetType(), itemType, customMappings, conflictResolution);
results.SetValue(result, counter);
counter++;
}
}
private static object ToClass(this object @object, Type resultType, IObjectMappingResolver customMappings, ObjectMappingConflictResolution conflictResolution = ObjectMappingConflictResolution.Exception)
{
if (@object == null)
{
return(null);
}
Type sourceType = @object.GetType();
if (!resultType.IsInterface && !resultType.IsClass)
{
if (conflictResolution == ObjectMappingConflictResolution.Exception)
{
throw new ClassMappingException(sourceType, resultType);
}
}
object result;
#pragma warning disable IDE0045 // Convert to conditional expression
if (sourceType.IsCollection())
#pragma warning restore IDE0045 // Convert to conditional expression
{
result = MapClass((IEnumerable)@object, sourceType, resultType, customMappings, conflictResolution);
}
else
{
result = MapClass(@object, sourceType, resultType, customMappings, conflictResolution);
}
return(result);
}
private static object MapClass(object source, Type sourceType, Type resultType, IObjectMappingResolver customMappings, ObjectMappingConflictResolution conflictResolution)
{
if (sourceType.IsCollection())
{
if (conflictResolution == ObjectMappingConflictResolution.Exception)
{
throw new ClassMappingException(sourceType, resultType);
}
return(null);
}
object result = Activator.CreateInstance(resultType);
PropertyInfo[] sourceProperties = sourceType.GetProperties();
PropertyInfo[] resultProperties = resultType.GetProperties();
IClassMappingResolver mappingConfig = customMappings.GetConfiuration(sourceType, resultType);
foreach (PropertyInfo sourceProperty in sourceProperties)
{
string targetName = sourceProperty.Name;
if (mappingConfig != null)
{
string remappedName = mappingConfig.GetTargetName(sourceProperty.Name);
if (remappedName != null)
{
targetName = remappedName;
}
}
PropertyInfo resultProperty = resultProperties.FirstOrDefault(x => { return(x.Name == targetName); });
if (resultProperty == null)
{
continue;
}
if (!sourceProperty.CanRead)
{
continue;
}
if (!resultProperty.CanWrite)
{
continue;
}
object value = sourceProperty.GetValue(source, null);
if (MappingExpress.CanSetValue(sourceProperty, resultProperty))
{
MappingExpress.SetValue(result, resultProperty, value);
}
else
{
Type type = sourceProperty.PropertyType;
if (type.IsInterface || type.IsClass)
{
MapProperty(value, result, sourceProperty, resultProperty, customMappings, conflictResolution);
}
else if (conflictResolution == ObjectMappingConflictResolution.Exception)
{
throw new PropertyMappingException(sourceProperty, resultProperty);
}
}
}
return(result);
}
/// <summary>
/// Perform deep copy of current object to desired type. Standard version.
/// </summary>
/// <param name="object"></param>
/// <param name="resultType">Type of the class you want to copy to</param>
/// <param name="customMappingAction">Callback to create custom mapping for specified type</param>
/// <param name="conflictResolution">What should be done if a conflict between source type and target type cannot be resolved</param>
/// <returns></returns>
public static object ToClass(this object @object, Type resultType, Action <IObjectMappingRegister> customMappingAction = null, ObjectMappingConflictResolution conflictResolution = ObjectMappingConflictResolution.Exception)
{
if (@object == null)
{
return(null);
}
Type sourceType = @object.GetType();
if (!resultType.IsInterface && !resultType.IsClass)
{
if (conflictResolution == ObjectMappingConflictResolution.Exception)
{
throw new ClassMappingException(sourceType, resultType);
}
}
ObjectMappingConfiguration customMappingContainer = new ObjectMappingConfiguration();
if (customMappingAction != null)
{
customMappingAction.Invoke(customMappingContainer);
}
object result;
#pragma warning disable IDE0045 // Convert to conditional expression
if (sourceType.IsCollection())
#pragma warning restore IDE0045 // Convert to conditional expression
{
result = MapClass((IEnumerable)@object, sourceType, resultType, customMappingContainer, conflictResolution);
}
else
{
result = MapClass(@object, sourceType, resultType, customMappingContainer, conflictResolution);
}
return(result);
}
/// <summary>
/// Perform deep copy of current object to desired type. Generic version.
/// </summary>
/// <typeparam name="TResult">Type of the class you want to copy to</typeparam>
/// <param name="object"></param>
/// <param name="customMappingAction">Callback to create custom mapping for specified type</param>
/// <param name="conflictResolution">What should be done if a conflict between source type and target type cannot be resolved</param>
/// <returns></returns>
public static TResult ToClass <TResult>(this object @object, Action <IObjectMappingRegister> customMappingAction = null, ObjectMappingConflictResolution conflictResolution = ObjectMappingConflictResolution.Exception)
{
object result = ToClass(@object, typeof(TResult), customMappingAction, conflictResolution);
return((TResult)result);
}
public static TResult ToClass <TSource, TResult>(this TSource @object, Action <TSource, TResult> postAction, Action <IObjectMappingRegister> customMappings = null, ObjectMappingConflictResolution conflictResolution = ObjectMappingConflictResolution.Exception)
{
TResult result = (TResult)ToClass(@object, typeof(TResult), customMappings, conflictResolution);
if (@object != null && result != null)
{
if (postAction != null)
{
postAction.Invoke(@object, result);
}
}
return(result);
}
/// <summary>
/// Perform deep copy of current object to desired type. Generic version.
/// </summary>
/// <typeparam name="TSource">Type of the class you want to copy from</typeparam>
/// <typeparam name="TResult">Type of the class you want to copy to</typeparam>
/// <param name="collection"></param>
/// <param name="postAction"></param>
/// <param name="customMappingAction">Callback to create custom mapping for specified type</param>
/// <param name="resolution">What should be done if a conflict between source type and target type cannot be resolved</param>
/// <returns></returns>
public static List <TResult> ToList <TSource, TResult>(this IEnumerable <TSource> collection, Action <TSource, TResult> postAction = null, Action <IObjectMappingRegister> customMappingAction = null, ObjectMappingConflictResolution resolution = ObjectMappingConflictResolution.Exception)
{
List <TResult> results = new List <TResult>();
if (collection == null)
{
return(results);
}
foreach (TSource item in collection)
{
TResult result = item.ToClass(postAction, customMappingAction, resolution);
results.Add(result);
}
return(results);
}
/// <summary>
/// Perform deep copy of current object to desired type. Generic version.
/// </summary>
/// <typeparam name="TResult">Type of the class you want to copy to</typeparam>
/// <param name="collection"></param>
/// <param name="customMappingAction">Callback to create custom mapping for specified type</param>
/// <param name="resolution">What should be done if a conflict between source type and target type cannot be resolved</param>
/// <returns></returns>
public static TResult[] ToArray <TResult>(this IEnumerable collection, Action <IObjectMappingRegister> customMappingAction = null, ObjectMappingConflictResolution resolution = ObjectMappingConflictResolution.Exception)
{
ICollection <TResult> results = new List <TResult>();
if (collection == null)
{
return(results.ToArray());
}
foreach (object item in collection)
{
TResult result = item.ToClass <TResult>(customMappingAction, resolution);
results.Add(result);
}
return(results.ToArray());
}