DataMapper.cs

Go to the documentation of this file.

//-----------------------------------------------------------------------
// <copyright file="DataMapper.cs" company="Marimer LLC">
//     Copyright (c) Marimer LLC. All rights reserved.
//     Website: https://cslanet.com
// </copyright>
// <summary>Map data from a source into a target object</summary>
//-----------------------------------------------------------------------
using System;
using System.Collections.Generic;
using System.ComponentModel;
using Csla.Properties;
using Csla.Reflection;
using System.Linq;
 
namespace Csla.Data
{
  public static class DataMapper
  {
 
    #region Map from IDictionary
 
    public static void Map(System.Collections.IDictionary source, object target)
    {
      Map(source, target, false);
    }
 
    public static void Map(System.Collections.IDictionary source, object target, params string[] ignoreList)
    {
      Map(source, target, false, ignoreList);
    }
 
    public static void Map(
      System.Collections.IDictionary source,
      object target, bool suppressExceptions,
      params string[] ignoreList)
    {
      List<string> ignore = new List<string>(ignoreList);
      foreach (string propertyName in source.Keys)
      {
        if (!ignore.Contains(propertyName))
        {
          try
          {
            SetPropertyValue(target, propertyName, source[propertyName]);
          }
          catch (Exception ex)
          {
            if (!suppressExceptions)
              throw new ArgumentException(
                String.Format("{0} ({1})",
                Resources.PropertyCopyFailed, propertyName), ex);
          }
        }
      }
    }
 
    #endregion
 
    #region Map to Dictionary
 
    public static void Map(object source, Dictionary<string, object> target)
    {
      Map(source, target, false);
    }
 
    public static void Map(object source, Dictionary<string, object> target, params string[] ignoreList)
    {
      Map(source, target, false, ignoreList);
    }
 
    public static void Map(
      object source, Dictionary<string, object> target,
      bool suppressExceptions,
      params string[] ignoreList)
    {
      List<string> ignore = new List<string>(ignoreList);
      foreach (var propertyName in GetPropertyNames(source.GetType()))
      {
        if (!ignore.Contains(propertyName))
        {
          try
          {
            target.Add(propertyName, MethodCaller.CallPropertyGetter(source, propertyName));
          }
          catch (Exception ex)
          {
            if (!suppressExceptions)
              throw new ArgumentException(
                String.Format("{0} ({1})",
                Resources.PropertyCopyFailed, propertyName), ex);
          }
        }
      }
    }
 
    #endregion
 
    #region Map from Object
 
    public static void Map(object source, object target)
    {
      Map(source, target, false);
    }
 
    public static void Map(object source, object target, params string[] ignoreList)
    {
      Map(source, target, false, ignoreList);
    }
 
    public static void Map(
      object source, object target,
      bool suppressExceptions,
      params string[] ignoreList)
    {
      List<string> ignore = new List<string>(ignoreList);
      foreach (var propertyName in GetPropertyNames(source.GetType()))
      {
          if (!ignore.Contains(propertyName))
          {
              try
              {
                  object value = MethodCaller.CallPropertyGetter(source, propertyName);
                  SetPropertyValue(target, propertyName, value);
              }
              catch (Exception ex)
              {
                  if (!suppressExceptions)
                      throw new ArgumentException(
                          String.Format("{0} ({1})",
                                        Resources.PropertyCopyFailed, propertyName), ex);
              }
          }
      }
    }
 
    public static void Map(object source, object target, DataMap map)
    {
      Map(source, target, map, false);
    }
 
    public static void Map(object source, object target, DataMap map, bool suppressExceptions)
    {
      foreach (DataMap.MemberMapping mapping in map.GetMap())
      {
        try
        {
          object value = mapping.FromMemberHandle.DynamicMemberGet(source);
          SetValueWithCoercion(target, mapping.ToMemberHandle, value);
        }
        catch (Exception ex)
        {
          if (!suppressExceptions)
            throw new ArgumentException(
              String.Format("{0} ({1})",
              Resources.PropertyCopyFailed, mapping.FromMemberHandle.MemberName), ex);
        }
      }
    }
 
      private static IList<string> GetPropertyNames(Type sourceType)
      {
        List<string> result = new List<string>();
        PropertyDescriptorCollection props = TypeDescriptor.GetProperties(sourceType);
        foreach (PropertyDescriptor item in props)
            if (item.IsBrowsable)
                result.Add(item.Name);
        return result;
    }
    #endregion
 
    #region  Load from IDictionary
 
    public static void Load(System.Collections.IDictionary source, object target, Func<string, object> nameMapper)
    {
      var validTarget = target as Core.IManageProperties;
      if (validTarget == null)
        throw new NotSupportedException();
      var propertyList = validTarget.GetManagedProperties();
      foreach (var p in propertyList)
        validTarget.LoadProperty(p, source[nameMapper(p.Name)]);
    }
 
#endregion
 
#region  Load to IDictionary
 
    public static void Load(object source, System.Collections.IDictionary target, Func<string, object> nameMapper)
    {
      var validSource = source as Core.IManageProperties;
      if (validSource == null)
        throw new NotSupportedException();
      var propertyList = validSource.GetManagedProperties();
      foreach (var p in propertyList)
        target[nameMapper(p.Name)] = validSource.ReadProperty(p);
    }
 
#endregion
 
#region SetValue
 
    public static void SetPropertyValue(
      object target, string propertyName, object value)
    {
        DynamicMemberHandle handle = MethodCaller.GetCachedProperty(target.GetType(), propertyName);
        SetValueWithCoercion(target, handle, value);   
    }
 
    private static void SetValueWithCoercion(object target, DynamicMemberHandle handle, object value)
    {
      var oldValue = handle.DynamicMemberGet(target);
 
      Type pType = handle.MemberType;
 
      var isGeneric = pType.IsGenericType;
      var isPrimitive = pType.IsPrimitive;
      var isValueType = pType.IsValueType;
      if (!isGeneric
          || (isGeneric && pType.GetGenericTypeDefinition() != typeof(Nullable<>)))
      {
        if (isValueType && (isPrimitive || pType == typeof(decimal)) && value == null)
        {
          value = 0;
        }
      }
 
      if (value != null)
      {
        Type vType = Utilities.GetPropertyType(value.GetType());
        value = Utilities.CoerceValue(pType, vType, oldValue, value);
      }
      handle.DynamicMemberSet(target, value);
    }
 
    public static void SetFieldValue(
      object target, string fieldName, object value)
    {
        DynamicMemberHandle handle = MethodCaller.GetCachedField(target.GetType(), fieldName);
        SetValueWithCoercion(target, handle, value);
    }
 
    public static object GetFieldValue(
      object target, string fieldName)
    {
      DynamicMemberHandle handle = MethodCaller.GetCachedField(target.GetType(), fieldName);
      return handle.DynamicMemberGet.Invoke(target);
    }
 
#endregion
  }
}