Общие функции сопоставления объектов Business to ORM

Question

У меня есть 2 объекта, BusinessCustomer и ORMCustomer

Я хочу иметь возможность сопоставлять одно с другим в моих действиях бизнес-уровня, таких как

• Скажите, если я загружаю ORMCustomer из базы данных, я хочу заполнить BusinessCustomer
• Или, если я работаю с BusinessCustomer и хочу сохранить в БД, я хочу заполнить ORMCustomer

В моем бизнес-слое я хочу иметь возможность что-то вроде:

Mapper.MapCustomer ( src , target )

Метод MapCustomer сможет определить направление отображения BusinessCustomer-> ORMCustomer или ORMCustomer-> BusinessCustomer

Я возился с Generics, но я не могу найти подходящее решение, как реализовать это в классе Mapper .

internal void MapCustomer<T, K>(T src, K target)
{
  if (src.GetType() == typeof(BusinessCustomer)) 
  { 
    MapBusinessCustomerToORMCustomer(src, target);
  }
  else if (src.GetType() == typeof(ORMCustomer)) 
  {
    MapORMCustomerToBusinessCustomer(src, target);
  }
}

Есть мысли, как лучше всего это реализовать?

Answer 1

Вам не нужно изобретать велосипед. AutoMapper делает это.

Answer 2

Вот кое-что простое, что я написал для такой задачи.Имена свойств должны быть одинаковыми.

public static class TypeConverter
{
    /// <summary>
    /// Instantiates a new DestinationType copying all public properties with the same type and name from the SourceType.
    /// The destination object must have a parameter less constructor.
    /// </summary>
    /// <param name="sourceObject">The source object.</param>
    /// <param name="destinationType">Type of the destination object.</param>
    public static DestinationType Convert<SourceType, DestinationType>(SourceType sourceObject, Type destinationType)
    {
        if (destinationType.GetConstructors().Where(x => x.GetParameters().Count() == 0).Count() == 0)
            throw new Exception("A parameter less constructor is required for the destination type.");

        // instantiate the destination object

        DestinationType destinationObject = Activator.CreateInstance<DestinationType>();

        // get all public properties from the source and destination object

        IEnumerable<PropertyInfo> sourceProps = sourceObject.GetType().GetProperties().Where(x => x.PropertyType.IsPublic);

        IEnumerable<PropertyInfo> destinationProps = destinationType.GetProperties().Where(x => x.PropertyType.IsPublic || x.PropertyType.IsEnum);

        // copy the public properties that exist in both the source type and destination type

        foreach (PropertyInfo prop in destinationProps)
        {
            PropertyInfo sourceProp = sourceProps.SingleOrDefault(x => x.Name == prop.Name);

            if (sourceProp != null)
            {
                try
                {
                    object propValue = new object();
                    if (prop.PropertyType.IsEnum)
                    {
                        propValue = Enum.Parse(prop.PropertyType, sourceProp.GetValue(sourceObject, null).ToString());

                    }
                    else
                    {
                        propValue = System.Convert.ChangeType(sourceProp.GetValue(sourceObject, null), prop.PropertyType);
                    }


                    prop.SetValue(destinationObject, propValue, null);
                }
                catch { }
            }
        }

        return destinationObject;
    }

    /// <summary>
    /// Instantiates a new DestinationType copying all public properties with the same type and name from the SourceType.
    /// The destination object must have a parameter less constructor.
    /// </summary>
    /// <param name="sourceObject">The collection of source objects.</param>
    /// <param name="destinationType">Type of the destination object.</param>
    public static IEnumerable<DestinationType> Convert<SourceType, DestinationType>(IEnumerable<SourceType> sourceObjects, Type destinationType)
    {
        List<DestinationType> convertedObjecs = new List<DestinationType>();

        List<SourceType> sourceObjectList = sourceObjects.ToList();

        foreach (SourceType item in sourceObjectList)
            convertedObjecs.Add(Convert<SourceType, DestinationType>(item, destinationType));

        return convertedObjecs;
    }
}

Answer 3

Я использовал это в прошлом.Это просто, к тому же, и довольно быстро, поскольку он только один раз отражает тип, а затем генерирует код get / set, который используется с этого момента.