LINQ Expressions Creating an Array with different object types

Question

I am doing some parsing from user input, and here I need to parse array of arguments that should be of certain Type.

At the moment of parsing I do not know of which Type each argument shoud be, but it could be evaluated to any Type. So, i decided to temporarily store them in an array of objects. But when i try to do something like this:

NewArrayExpression returnValue = Expression.NewArrayInit(typeof(object), expressionList);

I get following exception: An expression of type 'System.Int32' cannot be used to initialize an array of type 'System.Object'.

That is, I suppose, because no implicit boxing is happening. So i box it myself:

expressionList.Add(Expression.TypeAs(expression, typeof(object))); or
expressionList.Add(Expression.Convert(expression, typeof(object)));

So far so good: I got list of objects of various types in an array.

But, when i finally get the desired Type, I try converting all of the values from upper array to that Type (lets say that type being usualy an int) I convert it:

Expression.Convert(expr, typeof(int)); or
Expression.Unbox(expr, typeof(int));

This is debug view of both commands when expr is actualy an string "aaaaa":

(System.Int32)((System.Object)"aaaaa")

Now, here lies my problem: This WILL NOT throw an exception. But it will when expression is finally compiled. I mean, string is not an int.

Maybe this really shouldn't throw an exception, I don't know. But this doesn't work for me.

Is there a cure for this?

EDIT: The code looks like this:

static Expression InArguments(ParameterExpression pe, string[] arguments)
{
    List<Expression> listaExpr = new List<Expression>();
    foreach (string s in arguments)
    {
        Expression expression = Complete(pe, s); // evaluate argument
        // listaExpr.Add(Expression.Convert(expression, typeof(object)));
    }
    return Expression.NewArrayInit(typeof(object), listaExpr);
}

Why do you think you need to store the objects in an array? Could you show a sample of the whole expression, especially how do you use the array? — svick
– svick, Commented Mar 11, 2012 at 19:15
Well, i am trying to mimick SQL IN operator. Users should enter something like: Item.Code IN [1,2,3] or Partner.Name IN ["aa","bb"] where Code will be dynamically evaluated to int and Name will be evaluated to string. But also, this is allowed: Item.Code IN [1, 2, Partner.GetTopItem()] — Milos Mijatovic
– Milos Mijatovic, Commented Mar 11, 2012 at 19:27
So, i need to evaluate all arguments of IN operator which can result in simple types (int, string, decimal) but could also result in any type from my model, or collection of them for that matter. After that I cast them to the type of the left operand. I dont know, maybe I am overcomplicating things — Milos Mijatovic
– Milos Mijatovic, Commented Mar 11, 2012 at 19:36

svick · Accepted Answer · 2012-03-11 21:12:49Z

2

It seems to me that you know the type, it's just that you compute it too late. If you could change that, it would solve your problem. The method would then look like this:

static Expression InArguments(
    ParameterExpression pe, string[] arguments, Type itemType)
{
    List<Expression> listaExpr = new List<Expression>();
    foreach (string s in arguments)
    {
        Expression expression = Complete(pe, s, itemType); // evaluate argument
        listaExpr.Add(expression, typeof(object));
    }
    return Expression.NewArrayInit(itemType, listaExpr);
}

And the code that calls it could look something like this:

Expression inProperty = InProperty(…);
Expression inArguments = InArguments(pe, arguments, inProperty.Type);

Expression result = Expression.Call(containsMethod, inArguments, inProperty);

answered Mar 11, 2012 at 21:12

svick

247k54 gold badges405 silver badges535 bronze badges

Sign up to request clarification or add additional context in comments.

Comments

Milos Mijatovic · Accepted Answer · 2012-03-12 10:47:34Z

@svick

Yeah, that was my problem. My whole system was setup to resolve left and right operands independently and then check for convertability between them. So, i wanted my right operand of IN operator to return an expression of object array so i could test each of the objects for convertability, but that is seems to me that once i convert them to object, they are convertable to anything???.

So, i decided to to return following expression from my right operand:

    static Expression InArguments(ParameterExpression pe, string arguments)
    {
        string substr = arguments.Substring(1, arguments.Length - 2);
        string[] arr = substr.Split(',');
        return Expression.Constant(arr, typeof(string[]));
    }

And then later:

    static Expression InOperator(Expression left, Expression right, ParameterExpression pe)
    {
        Expression finalexpr = null;

        // this solved my problem.
        string[] args = Expression.Lambda<Func<string[]>>(right).Compile()();

        foreach (string s in args)
        {
            Expression converted = null;                

            try
            {
                Expression expr = Complete(pe, s);
                converted = Expression.Convert(expr, (left as Expression).Type);
            }
            catch
            {
                throw;
            }

            if (finalexpr == null) finalexpr = Expression.Constant(false);
            finalexpr = Expression.OrElse(finalexpr, Expression.Equal(left, converted));
        }

        return finalexpr;
    }

I forwared my arguments to the point where i can actually refer to the left operand type, inside a constant expression of string[] and then compile it to get my string arguments back.

But still, i would have liked if i could forward it in an object array...

Collectives™ on Stack Overflow

LINQ Expressions Creating an Array with different object types

2 Answers 2

Comments

Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Related