To pick an anonymous type, establish a LINQ Expression Tree.

c# entity-framework expression-trees linq linq-to-entities

Question

I would like to generate the following select statement dynamically using expression trees:

var v = from c in Countries
        where c.City == "London"
        select new {c.Name, c.Population};

I have worked out how to generate

var v = from c in Countries
        where c.City == "London"
        select new {c.Name};

but I cannot seem to find a constructor/overload that will let me specify multiple properties in my select lambda.

1
45
3/5/2015 8:59:08 PM

Fastest Entity Framework Extensions

Bulk Insert
Bulk Delete
Bulk Update
Bulk Merge

Accepted Answer

This can be done, as mentioned, with the help of Reflection Emit and a helper class I've included below. The code below is a work in progress, so take it for what it's worth... 'it works on my box'. The SelectDynamic method class should be tossed in a static extension method class.

As expected, you won't get any Intellisense since the type isn't created until runtime. Works good on late-bound data controls.

public static IQueryable SelectDynamic(this IQueryable source, IEnumerable<string> fieldNames)
{
    Dictionary<string, PropertyInfo> sourceProperties = fieldNames.ToDictionary(name => name, name => source.ElementType.GetProperty(name));
    Type dynamicType = LinqRuntimeTypeBuilder.GetDynamicType(sourceProperties.Values);

    ParameterExpression sourceItem = Expression.Parameter(source.ElementType, "t");
    IEnumerable<MemberBinding> bindings = dynamicType.GetFields().Select(p => Expression.Bind(p, Expression.Property(sourceItem, sourceProperties[p.Name]))).OfType<MemberBinding>();

    Expression selector = Expression.Lambda(Expression.MemberInit(
        Expression.New(dynamicType.GetConstructor(Type.EmptyTypes)), bindings), sourceItem);

    return source.Provider.CreateQuery(Expression.Call(typeof(Queryable), "Select", new Type[] { source.ElementType, dynamicType },
                 Expression.Constant(source), selector));
}



public static class LinqRuntimeTypeBuilder
{
    private static readonly ILog log = LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);
    private static AssemblyName assemblyName = new AssemblyName() { Name = "DynamicLinqTypes" };
    private static ModuleBuilder moduleBuilder = null;
    private static Dictionary<string, Type> builtTypes = new Dictionary<string, Type>();

    static LinqRuntimeTypeBuilder()
    {
        moduleBuilder = Thread.GetDomain().DefineDynamicAssembly(assemblyName, AssemblyBuilderAccess.Run).DefineDynamicModule(assemblyName.Name);
    }

    private static string GetTypeKey(Dictionary<string, Type> fields)
    {
        //TODO: optimize the type caching -- if fields are simply reordered, that doesn't mean that they're actually different types, so this needs to be smarter
        string key = string.Empty;
        foreach (var field in fields)
            key += field.Key + ";" + field.Value.Name + ";";

        return key;
    }

    public static Type GetDynamicType(Dictionary<string, Type> fields)
    {
        if (null == fields)
            throw new ArgumentNullException("fields");
        if (0 == fields.Count)
            throw new ArgumentOutOfRangeException("fields", "fields must have at least 1 field definition");

        try
        {
            Monitor.Enter(builtTypes);
            string className = GetTypeKey(fields);

            if (builtTypes.ContainsKey(className))
                return builtTypes[className];

            TypeBuilder typeBuilder = moduleBuilder.DefineType(className, TypeAttributes.Public | TypeAttributes.Class | TypeAttributes.Serializable);

            foreach (var field in fields)                    
                typeBuilder.DefineField(field.Key, field.Value, FieldAttributes.Public);

            builtTypes[className] = typeBuilder.CreateType();

            return builtTypes[className];
        }
        catch (Exception ex)
        {
            log.Error(ex);
        }
        finally
        {
            Monitor.Exit(builtTypes);
        }

        return null;
    }


    private static string GetTypeKey(IEnumerable<PropertyInfo> fields)
    {
        return GetTypeKey(fields.ToDictionary(f => f.Name, f => f.PropertyType));
    }

    public static Type GetDynamicType(IEnumerable<PropertyInfo> fields)
    {
        return GetDynamicType(fields.ToDictionary(f => f.Name, f => f.PropertyType));
    }
}
70
10/31/2016 12:33:14 PM

Popular Answer

The accepted answer is very useful, but I needed something a little closer to a real anonymous type.

A real anonymous type has read-only properties, a constructor for filling in all of the values, an implementation of Equals/GetHashCode for comparing the values of each property, and an implementation ToString that includes the name/value of each property. (See https://msdn.microsoft.com/en-us/library/bb397696.aspx for a full description of anonymous types.)

Based on that definition of anonymous classes, I put a class that generates dynamic anonymous types on github at https://github.com/dotlattice/LatticeUtils/blob/master/LatticeUtils/AnonymousTypeUtils.cs. The project also contains some unit tests to make sure the fake anonymous types behave like real ones.

Here's a very basic example of how to use it:

AnonymousTypeUtils.CreateObject(new Dictionary<string, object>
{
    { "a", 1 },
    { "b", 2 }
});

Also, another note: I found that when using a dynamic anonymous type with Entity Framework, the constructor must be called with the "members" parameter set. For example:

Expression.New(
    constructor: anonymousType.GetConstructors().Single(), 
    arguments: propertyExpressions,
    members: anonymousType.GetProperties().Cast<MemberInfo>().ToArray()
);

If you used one of the versions of Expression.New that does not include the "members" parameter, Entity Framework would not recognize it as the constructor of an anonymous type. So I assume that means a real anonymous type's constructor expression would include that "members" information.

dotlattice

Related Questions

An expression tree may be sent as a parameter to another expression tree.

I have two expression trees defined like this:...private Expression<Func<TEntity, TPropertyResult>> PropertyAccessor { get; set; } ...and...private Expression<Func<TPropertyResult, bool>> TestExpression { get; set; } ...I need to create a new expression tree that will result in the equivalent of:...var expression = p => this.TestExpression(this.Pro...
c# expression-trees lambda
asked by Pierre-Alain Vigeant

How may value types in LINQ/lambdas/expression trees be checked at compile time?

Change the contract to:...public static void SetPropertyThreadSafe<TPropertyType, TValue>( this Control self, Expression<Func<TPropertyType>> property, TValue value) where TValue : TPropertyType ...Note that with this you no longer need to do the IsAssignableFrom check since the compiler will enforce it....The reason...
.net c# expression-trees lambda linq
asked by tster

Unable to cast object of type 'System.Linq.Expressions.UnaryExpression' to type 'System.Linq.Expressions.MemberExpression'

This is ...apparently... related to boxing/unboxing. Lambda expressions returning value types that require boxing will be represented as UnaryExpressions whereas those that return reference types will be represented as MemberExpressions.
c# exception-handling expression-trees linq
asked by Scott Munro

How can I create a LINQ-friendly 'return false' expression using C# expression trees?

Can you wrap the entire thing in an if-else expression?...Meaning:...if input return <your normal code> else return false ...The return is implicit in expressions; the return value of the expression will simply be the last value. So you could try:... Expression.Condition ( Expression.NotEqual(input, Expression.Constant("")), ...
.net c# expression-trees linq
asked by JulianR

Creating expression tree for accessing a Generic type's property

You can use this:...var p = Expression.Parameter(a.GetType(), "x"); var body = Expression.Property(p, "SomePropertyName"); Expression.Lambda(body, p);
c# expression-trees generics linq
asked by Daniel Hilgarth

Create a lambda expression with a new anonymous type at runtime

Anonymous types are a compiler feature. If you don't get the compiler to create them at compile-time, then you will have to use meta-programming - either ...TypeBuilder... or maybe ...CSharpCodeProvider.... You might be better off using tuples - at least they are easy to create (you can use ...Tuple.Create... easily enough)....As for the expression...
anonymous-types c# entity-framework expression-trees reflection
asked by Marc Gravell

Combine select clauses in linq to entities with anonymous types

How can i combine select clause in linq to entities in order to project into an anonymous type?... Assume that I have these entities:...public class Address { public string City { get; set; } public int ZipCode { get; set; } //other properties } public class Person { public string Name { get; set; } public Address Address { ge...
.net anonymous-types c# expression-trees linq-to-entities
asked by Joachim B

Using expression trees to create a custom order by in linq to entities

I have a table that's mapped, but after compile additional columns can be added or removed from the table. I'm trying to come up with a linq query that will take those new columns into account. In this scenario, I want to order by one of those dynamic columns. This is what I have so far....var queryableData = dc.wf_task_ext_attributes.AsQueryabl...
.net c# entity-framework expression-trees linq
asked by Smeegs

Cannot convert from 'System.Linq.Expressions.LambdaExpression' to 'System.Linq.Expressions.Expression

I'm trying to implement expression tree with linq.I am getting error state as cannot convert lambdaexpression to expression. Please help i checked other solution but couldn't help as much ! Below is my code...ParameterExpression pe = Expression.Parameter(typeof(Person), "p"); var expr = Expression.Lambda(Expression.Property(pe, sortByProp), pe); ...
c# expression-trees linq
asked by Akhilesh

'Argument expression is not valid' when creating anonymous types dynamically

I'm creating an expression tree builder to return custom anonymous types. I tried it first with discrete types and it works ok, but using TypeBuilder to build types at runtime and pass that type to the expression tree fail with this error...'Argument expression is not valid' ...here is the code I use:...this method I use to create the anonymous typ...
expression-trees linq typebuilder
asked by Mustafa Magdy

Fastest Entity Framework Extensions

Bulk Insert
Bulk Delete
Bulk Update
Bulk Merge
View more on Stack Overflow

Prime Library

Performance

Expression Evaluator

More Projects...
Licensed under: CC-BY-SA with attribution
Not affiliated with Stack Overflow
Licensed under: CC-BY-SA with attribution
Not affiliated with Stack Overflow