Creating Expression with out parameter and nullable types

Question

I am trying to build an expression that will call a method with an out parameter. So far I've had success, except when it comes to nullable versions of the parameters.

For this purpose lets suppose the int.TryParse(string, out int) method. I've successfully been able to build an expression (no nullables) by defining a delegate type for this purpose:

internal delegate bool TestDelegate(string input, out int value);

public static MethodInfo GetMethod()
{
    return typeof(int).GetMethod("TryParse", BindingFlags.Public | BindingFlags.Static, null, new[] { typeof(string), typeof(int).MakeByRefType() }, null);
}

public static void NormalTestExpression()
{
    var method = GetMethod();

    var pValue = Expression.Parameter(typeof(string), "str");
    var pOutput = Expression.Parameter(typeof(int).MakeByRefType(), "value");

    var call = Expression.Call(method, pValue, pOutput);
    var lamd = Expression.Lambda<TestDelegate>(call, pValue, pOutput);
    var func = lamd.Compile();

    int output;
    var result = func("3", out output);
    // THIS WORKS!!!
}

I am trying to make this work with nullable types. Take for example:

internal delegate bool TestNullableDelegate(string input, out int? value);

The below will fail with an Argument Exception (GetMethod() is retrieving the correct method based off of the primitive type--same method from above)

public static void WithNullableTypeFails()
{
    var method = GetMethod();

    var pValue = Expression.Parameter(typeof(string), "str");
    var pOutput = Expression.Parameter(typeof(int?).MakeByRefType(), "value");
value
    var call = Expression.Call(method, pValue, pOutput); //Argument Exception int.TryParse() doesn't accept int? argument

    var lamd = Expression.Lambda<TestNullableDelegate>(call, pValue, pOutput);
    var func = lamd.Compile();

}


Expression of type 'System.Nullable`1[System.Int32]' cannot be used for parameter of type 'System.Int32' of method 'Boolean TryParse(System.String, Int32 ByRef)'

Now I am aware that this is because I am still invoking the MethodInfo which is taking the primitive int type and the delegates aren't matching. So I tried the below:

public static void WithNullableTypeAttempt()
{
    var method = GetMethod();

    var pValue = Expression.Parameter(typeof(string), "str"); 
    var pOutput = Expression.Parameter(typeof(int?).MakeByRefType(), "value");

    var vars = Expression.Variable(typeof(int), "tmp");
    var resultvar = Expression.Variable(typeof(bool), "result");

    var call = Expression.Call(method, pValue, vars);
    var block = Expression.Block(
                        Expression.Assign(vars, Expression.Constant(default(int))), 
                        Expression.Assign(resultvar, call), 
                        Expression.Assign(pOutput, Expression.Convert(vars, typeof(int?))),
                        resultvar
                );
    var lamd = Expression.Lambda<TestNullableDelegate>(block, pValue, pOutput);
    var func = lamd.Compile(); // Invalid Operation Exception
}

I get an invalid operation exception when I attempt to compile it:

variable 'tmp' of type 'System.Int32' referenced from scope '', but it is not defined

When I open the expression in one of the expression tree visualizers I have, I see the following:

(valueToParse, value) =>
{
    var tmp = 0;
    var result = int.TryParse(valueToParse, out tmp);
    var value = (int?)tmp;
    return result;
}

So I think I am on the right track.

How can I call this method where the types vary only by the Nullable type, keeping the delegate with the Nullable type?

Answer 1

You are currently using an overload of the method that does not support variables.

Quoting from the reference above:

Creates a BlockExpression that contains four expressions and has no variables.

You need to tell the block expression about the variables by using an overload that supports variables like this:

var block = Expression.Block(
                    new ParameterExpression[] { vars, resultvar }, //variables
                    Expression.Assign(vars, Expression.Constant(default(int))),
                    Expression.Assign(resultvar, call),
                    Expression.Assign(pOutput, Expression.Convert(vars, typeof(int?))),
                    resultvar);