Pulling Apart Expression <Func <T, object >>

Estoy ocupado creando métodos de extensión de envoltorio encima deApuesto yDapperExtensions. En este momento estoy tratando de agregar filtrado a laGetList<T> Método de extensión, similar al de LINQ.Where<T> método de extensión he vistoesta pregunta pero parece que no puedo implementar loMarc Gravell sugirió porque no hay un tipoEqualsExpression en .NET 4.5. Aquí hay un código de demostración para ayudar con la explicación de mi problema:

using System;
using System.Collections.Generic;
using System.Configuration;
using System.Data;
using System.Data.SqlClient;
using System.Diagnostics;
using System.Linq.Expressions;
using DapperExtensions;

namespace Dapper.Extensions.Demo
{
    public class Program
    {
        private static readonly string ConnectionString = ConfigurationManager.ConnectionStrings["DapperDbContext"].ConnectionString;
        public static IDbConnection Connection { get { return new SqlConnection(ConnectionString); } }

        public static void Main(string[] args)
        {
            const int marketId = 2;
            var matchingPeople = Connection.Get<Person>(p => p.MarketId, marketId); // This works

            // Below is a LambdaExpression. expression.Body is, bizarrely, a UnaryExpression with a Convert
            //var matchingPeople = Connection.Get<Person>(p => p.MarketId == marketId); // Does not work

            foreach (var person in matchingPeople)
            {
                Console.WriteLine(person);
            }

            if (Debugger.IsAttached)
                Console.ReadLine();
        }
    }

    public static class SqlConnectionExtensions
    {
        public static IEnumerable<T> Get<T>(this IDbConnection connection, Expression<Func<T, object>> expression, object value = null) where T : class
        {
            using (connection)
            {
                connection.Open();

                // I want to be able to pass in: t => t.Id == id then:
                // Expression<Func<T, object>> expressionOnLeftOfFilterClause = t => t.Id;
                // string operator = "==";
                // object valueFromLambda = id;
                // and call Predicates.Field(expressionOnLeftOfFilterClause, Operator.Eq, valueFromLambda)

                var predicate = Predicates.Field(expression, Operator.Eq, value);
                var entities = connection.GetList<T>(predicate, commandTimeout: 30);
                connection.Close();
                return entities;
            }
        }
    }

    public class Person
    {
        public int Id { get; set; }

        public string FirstName { get; set; }

        public string Surname { get; set; }

        public int MarketId { get; set; }

        public override string ToString()
        {
            return string.Format("{0}: {1}, {2} - MarketId: {3}", Id, Surname, FirstName, MarketId);
        }
    }
}

Prestando especial atencion a miGet<T> método de extensión: cuando paso cualquiera de los dosp => p.MarketId op => p.MarketId == marketId, expression.Body es de tipoUnaryExpression. Para despues,expression.Body en realidad contiene{Convert((p.MarketId == 2))}.

Intentando

var binaryExpression = expression as BinaryExpression;

devolucionesnull, lo cual es desafortunado porque hayLeft yRight Propiedades que podría haber encontrado útiles.

Entonces, ¿alguien sabe cómo lograr lo que quiero? Más abajo en la línea me gustaría poder elegir elOperator enumeración basada en la expresión lambda pasada. Cualquier ayuda sería muy apreciada.