Apply a dynamically created lambda to an object instance

Yours is a fascinating question, and I'd like to understand the requirements. I created a demo, and I'm wondering, how does the demo differ from what you're trying to accomplish? There is a working version here https://dotnetfiddle.net/AEBZ1w too.

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

public class Program
{
    public static void Main()
    {
        Criteria c = new Criteria() { 
            Property = "Name", 
            Operator = "==", 
            Value = "Foo" };

        var queryable = (new List<Receipt>() { 
            new Receipt { Name = "Foo", Amount = 1 },
            new Receipt { Name = "Foo", Amount = 2 }, 
            new Receipt { Name = "Bar" }  
        }).AsQueryable();

        var parameter = Expression.Parameter(typeof(Receipt), "x");
        var property = Expression.Property(parameter, typeof(Receipt).GetProperty(c.Property));
        var constant = Expression.Constant(c.Value);
        var operation = Expression.Equal(property, constant);
        var expression = Expression.Call(
            typeof(Queryable),
            "Where",
            new Type[] { queryable.ElementType },
            queryable.Expression, 
            Expression.Lambda<Func<Receipt, bool>>(operation, new ParameterExpression[] { parameter })
        );

        Console.WriteLine("Linq Expression: {0} \n", expression.ToString());
        Console.WriteLine("Results: \n");

        var results = queryable.Provider.CreateQuery<Receipt>(expression);
        foreach(var r in results)
        {
            Console.WriteLine("{0}:{1}", r.Name, r.Amount);
        }
    }
}

public class Criteria
{
    public string Property, Operator, Value;
}

public class ReceiptDetail
{
    public string ItemName;
}

public class Receipt
{
    public string Name { get; set; }
    public int Amount;
    public ICollection<ReceiptDetail> Details;
}

References

• How to: Execute Expression Trees
• How to: Use Expression Trees to Build Dynamic Queries
• IQueryable Interface
• Expression Methods
• Expression.Property Method

You could use reflection with generics. One way to solve the problem could be an extension

public static class EnumerableExtensions
{
    public static IEnumerable<T> Where<T>(this IEnumerable<T> source, Criteria c)
    {
        var sourceType = typeof(T);
        var propertyMember = sourceType.GetProperty(c.Property);
        Func<string, bool> predicate = null;
        switch (c.Operator)
        {
            case "equal":
                predicate = (v) => v == c.Value;
                break;
            // other operators
            default:
                throw new ArgumentException("Unsupported operator.");
        }
        return source.Where(v => predicate((string)propertyMember.GetMethod.Invoke(v, null)));
    }
}

Which you could make use of in your code:

    void FooBar()
    {
        Criteria c = new Criteria()
        {
            Property = "Name",
            Operator = "equal",
            Value = "foo"
        };

        var source = new Receipt[2];
        source[0] = new Receipt { Name = "foo", Amount = 1 };
        source[1] = new Receipt { Name = "bar", Amount = 2 };

        var result = source.Where(c);
    }

This is just to give you an idea. Improvements would be error handling (property not found, invalid cast, null values, etc.), refactoring to enable unit testing (e.g. inject the select "strategy") and performance (e.g. building, compiling and caching expression trees instead of reflection). This should give you enough keywords to learn about. Hope this helps.