Cacher is the code snippet organizer for pro developers

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;
using System.Linq.Expressions;

namespace TechTalk.SpecFlow.ObjectConversion
{
    public static class ObjectConverterExtensions
    {
        /// <summary>
        /// Creates a conversion object for the given set of properties
        /// </summary>
        /// <typeparam name="TEntity">the type of the object to create</typeparam>
        public static IObjectConverter<TEntity> AsObjectConverter<TEntity>(this IDictionary<string, string> objectData)
        {
            return new ObjectConverter<TEntity>(new[] { objectData });
        }

        /// <summary>
        /// Creates a conversion object for the given set of properties
        /// </summary>
        /// <typeparam name="TEntity">the type of the object to create</typeparam>
        public static IObjectConverter<TEntity> AsObjectConverter<TEntity>(this IEnumerable<IDictionary<string, string>> objectDataCollection)
        {
            return new ObjectConverter<TEntity>(objectDataCollection);
        }

        /// <summary>
        /// Creates the objects from the given <paramref name="objectDataCollection"/> argument
        /// </summary>
        public static IEnumerable<TEntity> CreateObjects<TEntity>(this IObjectConverter<TEntity> objectConverter, IEnumerable<IDictionary<string, string>> objectDataCollection)
        {
            return objectDataCollection.Select(objectConverter.CreateObject);
        }

        /// <summary>
        /// Specifies the aliases in the import data for the given property of the entity. There can be more than one alias for any property, but not vice versa.
        /// </summary>
        public static IConfiguredObjectConverter<TEntity> WithPropertyAlias<TEntity, TProperty>(this IConfiguredObjectConverter<TEntity> objectConverter, Expression<Func<TEntity, TProperty>> selector, params string[] aliases)
        {
            foreach (var alias in aliases)
                objectConverter.WithPropertyAlias(selector, alias);
            return objectConverter;
        }

        /// <summary>
        /// Shorthand to specify required fields that the import data is verified to contain in a type safe way
        /// </summary>
        public static IConfiguredObjectConverter<TEntity> WithRequiredField<TEntity, TProperty>(this IConfiguredObjectConverter<TEntity> objectConverter, params Expression<Func<TEntity, TProperty>>[] propertySelectors)
        {
            return objectConverter.WithRequiredField(propertySelectors.Select(ps => ps.GetPropertyName()).ToArray());
        }

        /// <summary>
        /// Specifies the default value to use for a property if the import data wouldn't specify otherwise
        /// </summary>
        public static IConfiguredObjectConverter<TEntity> WithDefaultValue<TEntity, TProperty>(this IConfiguredObjectConverter<TEntity> objectConverter, Expression<Func<TEntity, TProperty>> selector, TProperty defaultValue)
        {
            return objectConverter.WithDefaultValue(selector, () => defaultValue);
        }

        /// <summary>
        /// Returns a converter function for the given type. This method is the default converter provider.
        /// </summary>
        public static Func<string, object> GetDefaultConverter(Type type)
        {
            if (type == typeof(string))
                return s => s;

            if (type.IsGenericType && type.Name == "Nullable`1")
                return val =>
                {
                    if (string.IsNullOrEmpty(val)) return null;
                    else return GetDefaultConverter(type.GetGenericArguments()[0])(val);
                };

            if (type.IsEnum)
                return value => Enum.Parse(type, value);

            return value => TypeDescriptor.GetConverter(type).ConvertFromString(value);
        }
    }

    public static class ExpressionExtensions
    {
        /// <summary>
        /// Returns the property name from a property selector expression
        /// </summary>
        public static string GetPropertyName<TEntity, TValue>(this Expression<Func<TEntity, TValue>> property)
        {
            var exp = (LambdaExpression)property;

            if (exp.Body.NodeType == ExpressionType.Parameter)
                return "item";

            var mExp = (exp.Body.NodeType == ExpressionType.MemberAccess) ?
                (MemberExpression)exp.Body :
                (MemberExpression)((UnaryExpression)exp.Body).Operand;
            return mExp.Member.Name;
        }
    }

    public interface IObjectConverter<TEntity>
    {
        /// <summary>
        /// Allows customizing the object conversion
        /// </summary>
        IConfiguredObjectConverter<TEntity> WithConfiguration();
        /// <summary>
        /// Creates the objects from the argument provided at initialization
        /// </summary>
        IEnumerable<TEntity> CreateObjects();
        /// <summary>
        /// Creates the objects from the given <param name="collectionData"/> argument
        /// </summary>
        IEnumerable<TEntity> CreateObjects(IEnumerable<IDictionary<string, string>> collectionData);
        /// <summary>
        /// Creates the object from the given <paramref name="objectData"/> argument
        /// </summary>
        TEntity CreateObject(IDictionary<string, string> objectData);
    }

    public interface IConfiguredObjectConverter<TEntity> : IObjectConverter<TEntity>
    {
        /// <summary>
        /// Defines the object factory to use when creating a new entity
        /// </summary>
        IConfiguredObjectConverter<TEntity> WithObjectFactory(Func<TEntity> factory);
        /// <summary>
        /// Specifies that the import data should contain the specified fields
        /// </summary>
        IConfiguredObjectConverter<TEntity> WithRequiredField(params string[] fieldNames);
        /// <summary>
        /// Specifies the fields of the import data the algorithm should skip
        /// </summary>
        IConfiguredObjectConverter<TEntity> WithSkippedField(params string[] fieldNames);
        /// <summary>
        /// Specifies an alias in the import data for the given property of the entity. There can be more than one alias for any property, but not vice versa.
        /// </summary>
        IConfiguredObjectConverter<TEntity> WithPropertyAlias<TProperty>(Expression<Func<TEntity, TProperty>> selector, string alias);
        /// <summary>
        /// Specifies the converter to use for the given import data field (converter priority: table field, object property, target value, default)
        /// </summary>
        IConfiguredObjectConverter<TEntity> WithFieldValueConverter<TProperty>(string name, Func<string, TProperty> converter);
        /// <summary>
        /// Specifies the converter to use for the given property of the entity (converter priority: table field, object property, target value, default)
        /// </summary>
        IConfiguredObjectConverter<TEntity> WithPropertyValueConverter<TProperty>(Expression<Func<TEntity, TProperty>> selector, Func<string, TProperty> converter);
        /// <summary>
        /// Specifies a conversion method to use when converting to the given value (converter priority: table field, object property, target value, default)
        /// </summary>
        IConfiguredObjectConverter<TEntity> WithValueConverter<TValue>(Func<string, TValue> converter);
        /// <summary>
        /// Specifies the provider method to use to obtain the default value converter for any given type (converter priority: table field, object property, target value, default)
        /// </summary>
        IConfiguredObjectConverter<TEntity> WithDefaultConverter(Func<Type, Func<string, object>> converterProvider);
        /// <summary>
        /// Specifies the default value to use for a property if the import data wouldn't specify otherwise
        /// </summary>
        IConfiguredObjectConverter<TEntity> WithDefaultValue<TProperty>(Expression<Func<TEntity, TProperty>> selector, Func<TProperty> valueProvider);
    }

    public static class ObjectConverter
    {
        /// <summary>
        /// Creates an object converter for the given type
        /// </summary>
        public static IObjectConverter<TEntity> For<TEntity>()
        {
            return new ObjectConverter<TEntity>(null);
        }
    }

    internal sealed class ObjectConverter<TEntity> : IConfiguredObjectConverter<TEntity>
    {
        private readonly IEnumerable<IDictionary<string, string>> objectDataCollection;
        public ObjectConverter(IEnumerable<IDictionary<string, string>> objectDataCollection)
        {
            this.objectDataCollection = objectDataCollection;
        }

        public IConfiguredObjectConverter<TEntity> WithConfiguration()
        {
            return this;
        }

        public IEnumerable<TEntity> CreateObjects()
        {
            return CreateObjects(objectDataCollection);
        }

        public IEnumerable<TEntity> CreateObjects(IEnumerable<IDictionary<string, string>> collectionData)
        {
            if (collectionData == null) return Enumerable.Empty<TEntity>();
            return collectionData.Select(CreateObject).ToArray();
        }

        public TEntity CreateObject(IDictionary<string, string> objectData)
        {
            var missingFields = requiredFields.Except(objectData.Keys).ToArray();
            if (missingFields.Length > 0)
                new InvalidOperationException("Required field(s) missing: " + string.Join(", ", missingFields));

            var entity = objectFactory();
            foreach (var name in objectData.Keys.Except(skippedFields))
            {
                string propertyName;
                if (!propertyAliases.TryGetValue(name, out propertyName))
                    propertyName = name;

                var property = typeof(TEntity).GetProperty(propertyName);
                if (property == null)
                    throw new InvalidOperationException(string.Format("Invalid property name '{0}'", propertyName));

                Func<string, object> converter = null;
                if (converter == null) fieldValueConverters.TryGetValue(name, out converter);
                if (converter == null) propertyValueConverters.TryGetValue(propertyName, out converter);
                if (converter == null) valueConverters.TryGetValue(property.PropertyType, out converter);
                if (converter == null) converter = defaultConverterProvider(property.PropertyType);

                property.SetValue(entity, converter(objectData[name]), null);
            }

            foreach (var entry in defaultValueProviders)
            {
                var fieldNames = propertyAliases.Where(pa => pa.Value == entry.Key).Select(pa => pa.Key).Concat(new[] { entry.Key });
                if (!objectData.Keys.Any(k => fieldNames.Contains(k)))
                {
                    var property = typeof(TEntity).GetProperty(entry.Key);
                    property.SetValue(entity, entry.Value(), null);
                }
            }

            return entity;
        }

        private readonly List<string> requiredFields = new List<string>();
        public IConfiguredObjectConverter<TEntity> WithRequiredField(params string[] fieldNames)
        {
            requiredFields.AddRange(fieldNames);
            return this;
        }

        private Func<TEntity> objectFactory = () => Activator.CreateInstance<TEntity>();
        public IConfiguredObjectConverter<TEntity> WithObjectFactory(Func<TEntity> factory)
        {
            objectFactory = factory;
            return this;
        }

        private readonly List<string> skippedFields = new List<string>();
        public IConfiguredObjectConverter<TEntity> WithSkippedField(params string[] fieldNames)
        {
            skippedFields.AddRange(fieldNames);
            return this;
        }

        private readonly Dictionary<string, string> propertyAliases = new Dictionary<string, string>();
        public IConfiguredObjectConverter<TEntity> WithPropertyAlias<TProperty>(Expression<Func<TEntity, TProperty>> selector, string alias)
        {
            propertyAliases.Add(alias, selector.GetPropertyName());
            return this;
        }

        private readonly Dictionary<string, Func<string, object>> propertyValueConverters = new Dictionary<string, Func<string, object>>();
        public IConfiguredObjectConverter<TEntity> WithPropertyValueConverter<TProperty>(Expression<Func<TEntity, TProperty>> selector, Func<string, TProperty> converter)
        {
            propertyValueConverters.Add(selector.GetPropertyName(), v => converter(v));
            return this;
        }

        private readonly Dictionary<string, Func<string, object>> fieldValueConverters = new Dictionary<string, Func<string, object>>();
        public IConfiguredObjectConverter<TEntity> WithFieldValueConverter<TProperty>(string name, Func<string, TProperty> converter)
        {
            fieldValueConverters.Add(name, v => converter(v));
            return this;
        }

        private readonly Dictionary<Type, Func<string, object>> valueConverters = new Dictionary<Type, Func<string, object>>();
        public IConfiguredObjectConverter<TEntity> WithValueConverter<TValue>(Func<string, TValue> converter)
        {
            valueConverters.Add(typeof(TValue), v => converter(v));
            return this;
        }

        private Func<Type, Func<string, object>> defaultConverterProvider = ObjectConverterExtensions.GetDefaultConverter;
        public IConfiguredObjectConverter<TEntity> WithDefaultConverter(Func<Type, Func<string, object>> converterProvider)
        {
            defaultConverterProvider = converterProvider;
            return this;
        }

        private readonly Dictionary<string, Func<object>> defaultValueProviders = new Dictionary<string, Func<object>>();
        public IConfiguredObjectConverter<TEntity> WithDefaultValue<TProperty>(Expression<Func<TEntity, TProperty>> selector, Func<TProperty> valueProvider)
        {
            defaultValueProviders.Add(selector.GetPropertyName(), () => valueProvider());
            return this;
        }
    }
}