using System;

using System.Collections.Generic;

using AutoMapper;

using System.Linq.Expressions;

using System.Reflection;

​

public class Person

{

    public string FirstName

    {

        get;

        set;

    }

​

    public string LastName

    {

        get;

        set;

    }

​

    public DateTime DateOfBirth

    {

        get;

        set;

    }

}

​

public static class LambdaExpressionExtensions

{

    public static string GetPropertyName<T, TProp>(this Expression<Func<T, TProp>> property)

    {

        System.Linq.Expressions.LambdaExpression lambda = (System.Linq.Expressions.LambdaExpression)property;

        System.Linq.Expressions.MemberExpression memberExpression;

​

        if (lambda.Body is System.Linq.Expressions.UnaryExpression)

        {

           System.Linq.Expressions.UnaryExpression unaryExpression = (System.Linq.Expressions.UnaryExpression)(lambda.Body);

           memberExpression = (System.Linq.Expressions.MemberExpression)(unaryExpression.Operand);

        }

        else

        {

           memberExpression = (System.Linq.Expressions.MemberExpression)(lambda.Body);

        }

        string name = ((PropertyInfo)memberExpression.Member).Name;

        return name;

    }

    public static IDictionary<string, object> FilterOutKeys<T>(this IDictionary<string, object> dictionary, params Expression<Func<T, object>>[] keyByPropertyNameExpressions)

    {

        var result = new Dictionary<string, object>(dictionary);

        foreach (var exp in keyByPropertyNameExpressions ?? new Expression<Func<T, object>>[0])

        {

            var propToExclude = exp.GetPropertyName();

            result.Remove(propToExclude);

        }

        return result;

    }

    public static IDictionary<string, object> KeepOnlyKeys<T>(this IDictionary<string, object> dictionary, params Expression<Func<T, object>>[] keyByPropertyNameExpressions)

    {

        var result = new Dictionary<string, object>();

        foreach (var exp in keyByPropertyNameExpressions ?? new Expression<Func<T, object>>[0])

        {

            var propToInclude = exp.GetPropertyName();

            object value;

            if (dictionary.TryGetValue(propToInclude, out value))

            {

                result[propToInclude] = value;

            }

        }

        return result;

    }

}

​

public class Program

{

    public static void Main()

    {

        var config = new MapperConfiguration(cfg => {});

        var mapper = config.CreateMapper();

        var person = new Person 

        {

            FirstName = "John",

            LastName = "Doe",

            DateOfBirth = new DateTime(1980, 10, 13)

        };

        /*

        var fieldsAndValues = mapper.Map<Dictionary<string, object>>(person)

                                    .FilterOutKeys<Person>(x => x.DateOfBirth, x => x.LastName);

        */

        var fieldsAndValues = mapper.Map<Dictionary<string, object>>(person)

                                    .KeepOnlyKeys<Person>(x => x.FirstName, x => x.LastName);

        if (object.ReferenceEquals(fieldsAndValues, null))

        {

            Console.WriteLine("fieldsAndValues IS null");

        }

        else    

        {

            foreach (var kvp in fieldsAndValues)

            {

                Console.WriteLine("Key={0}, Value={1}", kvp.Key, kvp.Value);

            }

        }

    }

}