Скопируйте объект Entity в объект POCO, где Entity ints являются перечислениями в POCO.

Я пытаюсь создать копир, используя копию свойств Джона Скитса. Он отлично работает для всех свойств, но не для перечислений. Я пробовал несколько попыток изменить метод для работы с перечислениями без особого успеха. Мне было интересно, может ли кто-нибудь еще подумать о том, как это сделать.

Оригинальный Джон Скитс, мои изменения отделены комментариями в методе BUILDCOPIER.

призывы к этому

        var result = Common.PropertyCopy<POCO>.CopyFrom(Entity);

Оригинальный код Джона Скита

/// <summary>
/// Generic class which copies to its target type from a source
/// type specified in the Copy method. The types are specified
/// separately to take advantage of type inference on generic
/// method arguments.
/// http://www.yoda.arachsys.com/csharp/miscutil/
/// </summary>
public static class PropertyCopy<TTarget> where TTarget : class, new()
{
    /// <summary>
    /// Copies all readable properties from the source to a new instance
    /// of TTarget.
    /// </summary>
    public static TTarget CopyFrom<TSource>(TSource source) where TSource : class
    {
        return PropertyCopier<TSource>.Copy(source);
    }

    /// <summary>
    /// Static class to efficiently store the compiled delegate which can
    /// do the copying. We need a bit of work to ensure that exceptions are
    /// appropriately propagated, as the exception is generated at type initialization
    /// time, but we wish it to be thrown as an ArgumentException.
    /// </summary>
    private static class PropertyCopier<TSource> where TSource : class
    {
        private static readonly Func<TSource, TTarget> copier;
        private static readonly Exception initializationException;

        internal static TTarget Copy(TSource source)
        {
            if (initializationException != null)
            {
                throw initializationException;
            }
            if (source == null)
            {
                throw new ArgumentNullException("source");
            }
            return copier(source);
        }

        static PropertyCopier()
        {
            try
            {
                copier = BuildCopier();
                initializationException = null;
            }
            catch (Exception e)
            {
                copier = null;
                initializationException = e;
            }
        }

        private static Func<TSource, TTarget> BuildCopier()
        {
            ParameterExpression sourceParameter = Expression.Parameter(typeof(TSource), "source");
            var bindings = new List<MemberBinding>();
            foreach (PropertyInfo sourceProperty in typeof(TSource).GetProperties())
            {
                if (!sourceProperty.CanRead)
                {
                    continue;
                }
                PropertyInfo targetProperty = typeof(TTarget).GetProperty(sourceProperty.Name);
                if (targetProperty == null)
                {
                    throw new ArgumentException("Property " + sourceProperty.Name + " is not present and accessible in " + typeof(TTarget).FullName);
                }
                if (!targetProperty.CanWrite)
                {
                    throw new ArgumentException("Property " + sourceProperty.Name + " is not writable in " + typeof(TTarget).FullName);
                }

                // THIS IS FALSE FOR SOURCE(INT) TARGET ENUMS
                if (!targetProperty.PropertyType.IsAssignableFrom(sourceProperty.PropertyType))
                {
                    //ADDED FOLLOWING TO HANDLE COPY FROM INT TO ENUM
                    /////////////////////////////////////////////////////////////////////////////////////////////////////
                    // Special Case because Entities are created with property as ints, not enum types
                    if (targetProperty.PropertyType.IsEnum && (sourceProperty.PropertyType == typeof(int)))
                    {
                        var expressionparam = Expression.Parameter(sourceProperty.PropertyType);
                        // cast the entity source as the enum target
                        var cast = Expression.Convert(expressionparam, targetProperty.PropertyType);
                        // add to the binding tree
                        bindings.Add(Expression.Bind(targetProperty, Expression.Property(cast, sourceProperty)));
                        continue;
                    }
                    /////////////////////////////////////////////////////////////////////////////////////////////////////

                    throw new ArgumentException("Property " + sourceProperty.Name + " has an incompatible type in " + typeof(TTarget).FullName);
                }
            Expression initializer = Expression.MemberInit(Expression.New(typeof(TTarget)), bindings);
            return Expression.Lambda<Func<TSource, TTarget>>(initializer, sourceParameter).Compile();
        }
    }
}

перечисление

public enum NotificationType
{
    InAppNotificiation = 0,
    EmailNotification,
    SMS
}

Класс сущности, созданный EF

public class Entity
{
    public int ProcessedStatus { get; set; }
    public int Priority { get; set; }
    public System.Guid NotifyToUserId { get; set; }
    public string NotifyFrom { get; set; }
    public string NotifySubject { get; set; }
    public string NotifyMessageBody { get; set; }
    public int NotificationType { get; set; }  <-- Stored as int in DB

     public virtual MercuryUser MercuryUser { get; set; } <--complex type
}

ПОКО Класс

public class POCO
{
    public int ProcessedStatus { get; set; }
    public int Priority { get; set; }
    public System.Guid NotifyToUserId { get; set; }
    public string NotifyFrom { get; set; }
    public string NotifySubject { get; set; }
    public string NotifyMessageBody { get; set; }
    public NotificationType NotificationType { get; set; }  <-- ENUM TYPE

    public MyUser MyUser { get; set; } <-- complex type
}

Исключение в строке

bindings.Add(Expression.Bind(targetProperty, Expression.Property(cast, sourceProperty)));

Свойство «Int32 NotificationType» не определено для типа «Models.Enums.NotificationType».