Welcome to the Lounge

var product = CSScript.CreateFunc<int>(@"int Product(int a, int b)
                                         {
                                             return a * b;
                                         }");
int result = product(3, 4);

static void Main()
{
    Expression<Func<int, int>> exp = x => 1 + x;
}

honey the codewitch wrote:

Cool, maybe I'll write it then.

string theCodez = "1 + x;";
var exp = (Expression)theCodez;

Sander Rossel wrote:

My coworker was like, "I could write a parser and spend a few days, or I can do it like this and be done with it

Sander Rossel wrote:

I did find some smart guy who just compiled a string using reflection (using ICodeCompiler.CompileAssemblyFromSource) and then simply invokes it

honey the codewitch wrote:

but it would take forever to test

Sander Rossel wrote:

So to hell with unit tests and back to some good old manual testing and praying for the best

honey the codewitch wrote:

What's a good program without a few bugs anyway?

CS0030 Cannot convert type 'string' to 'System.Linq.Expressions.Expression'

propertyToUse = workingProperty.Substring(0, workingProperty.IndexOf('.'));
                Type propertyToUseType = GetEntityType(propertyToUse, incomingParentType);

                ParameterExpression propertyToUseParameterExpression = Expression.Parameter(propertyToUseType, propertyToUse.Substring(0,1));
                Expression parentExpression = Expression.Property(workingExpression, propertyToUse);

                if (parentExpression.Type.IsGenericType &&
                    typeof(IEnumerable<>)
                        .MakeGenericType(parentExpression.Type.GetGenericArguments())
                        .IsAssignableFrom(parentExpression.Type))
                {
                    Expression childExpression = BuildPropertyExpression(propertyToUseParameterExpression,
                        workingProperty, comparisonOperation, compareValue);
                    Type func = typeof(Func<,>);
                    Type genericFunc = func.MakeGenericType(propertyToUseType, typeof(bool));
                    LambdaExpression predicate =
                        Expression.Lambda(genericFunc, childExpression, propertyToUseParameterExpression);

                    //we have call the AsQueryable on the collection since we don't have the compiler working for us and we need to use the any method
                    MethodInfo asQueryableMethod = typeof(Queryable).GetMethods()
                        .Where(m => m.Name == "AsQueryable")
                        .Single(m => m.IsGenericMethod)
                        .MakeGenericMethod(propertyToUseType);
                    Expression asQueryableExpression = Expression.Call(null, asQueryableMethod, parentExpression);

                    //call the any method with the lambda expression we set up
                    MethodInfo anyMethod = typeof(Queryable).GetMethods()
                        .Where(m => m.Name == "Any")
                        .Single(m => m.GetParameters().Length == 2)
                        .MakeGenericMethod(propertyToUseType);
                    returnValue = Expression.Call(
                        null,
                        anyMethod,
                        asQueryableExpression, //the source
                        predicate); // the lambda expression
                }

valueExpression = Expression.Constant(compareValue)

returnValue = Expression.Equal(workingExpression, valueExpression);

class JsMath
{
    static function Eval(expression: String): double
    {
        return eval(expression);
    };
}

C:\WINDOWS\Microsoft.NET\Framework\v4.0.30319\jsc.exe /t:library jsMath.js

private static double ExpressionValue(string expr)
{
    return JsMath.Eval(expr);
}