.NET Fiddle

CSharp · Console

/Program.cs

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

class Program
{
	static void Main()
	{
		//Arrange
		var filters = new List<ExpressionFilter>{new ExpressionFilter{PropertyName = "CountryOfOrigin", Comparison = Comparison.Contains, Value = "Fr"}, };
		var car = new Car{CountryOfOrigin = "France", };
		//Act
		var expressionTree = Test<Car>(filters[0]);
		Func<Car, bool> anonymousFunc = expressionTree.Compile();
		//Assert
		anonymousFunc(car).Should().BeTrue();
		
		Console.WriteLine("Passed");
	}

	static Expression<Func<T, bool>> Test<T>(ExpressionFilter filter)
	{
		ParameterExpression param = Expression.Parameter(typeof (T), "t");
		var exp = ExpressionRetriever.GetExpression<T>(param, filter);
		return Expression.Lambda<Func<T, bool>>(exp, param);
	}
}

public class Car
{
	public string Model
	{
		get;
		set;
	}

	public string Make
	{
		get;
		set;
	}

	public string CountryOfOrigin
	{
		get;
		set;
	}

	public string CountryOfProduction
	{
		get;
		set;
	}

	public int MaxMilesPerHour
	{
		get;
		set;
	}

	public int NumberOfSeats
	{
		get;
		set;
	}

	public int MilesPerGallon
	{
		get;
		set;
	}

	public double WeightInKg
	{
		get;
		set;
	}

	public decimal BasePrice
	{
		get;
		set;
	}

	public decimal FullPrice
	{
		get;
		set;
	}
}

public static class ExpressionRetriever
{
	private static MethodInfo containsMethod = typeof (string).GetMethod("Contains", new Type[]{typeof (string)});
	private static MethodInfo startsWithMethod = typeof (string).GetMethod("StartsWith", new Type[]{typeof (string), typeof (StringComparison)});
	private static MethodInfo endsWithMethod = typeof (string).GetMethod("EndsWith", new Type[]{typeof (string)});
	public static Expression GetExpression<T>(this ParameterExpression param, ExpressionFilter filter)
	{
		MemberExpression member = Expression.Property(param, filter.PropertyName);
		ConstantExpression constant = Expression.Constant(filter.Value);
		switch (filter.Comparison)
		{
			case Comparison.Equal:
				return Expression.Equal(member, constant);
			case Comparison.GreaterThan:
				return Expression.GreaterThan(member, constant);
			case Comparison.GreaterThanOrEqual:
				return Expression.GreaterThanOrEqual(member, constant);
			case Comparison.LessThan:
				return Expression.LessThan(member, constant);
			case Comparison.LessThanOrEqual:
				return Expression.LessThanOrEqual(member, constant);
			case Comparison.NotEqual:
				return Expression.NotEqual(member, constant);
			case Comparison.Contains:
				return Expression.Call(member, containsMethod, constant);
			case Comparison.StartsWith:
				return Expression.Call(member, startsWithMethod, constant, Expression.Constant(StringComparison.InvariantCultureIgnoreCase));
			case Comparison.EndsWith:
				return Expression.Call(member, endsWithMethod, constant);
			default:
				return null;
		}
	}
}

public class ExpressionFilter
{
	public string PropertyName
	{
		get;
		set;
	}

	public object Value
	{
		get;
		set;
	}

	public Comparison Comparison
	{
		get;
		set;
	}
}

public enum Comparison
{
	Equal,
	LessThan,
	LessThanOrEqual,
	GreaterThan,
	GreaterThanOrEqual,
	NotEqual,
	Contains, //for strings  
	StartsWith, //for strings  
	EndsWith //for strings  
}