Comment créer Expression LINQ Arborescence pour sélectionner un type anonyme

Cela peut être fait, comme mentionné, avec l'aide de la Réflexion Émettent et une classe d'aide, j'ai inclus ci-dessous. Le code ci-dessous est un travail en cours, donc le prendre pour ce qu'il vaut... 'il fonctionne sur ma boîte". Le SelectDynamic méthode de la classe doit être jeté dans une statique de la classe de méthode d'extension.

Comme prévu, vous n'aurez pas de Intellisense car le type n'est pas créé jusqu'à ce que l'exécution. Les bonnes œuvres de retard lié à des contrôles de données.

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));
}
}

Vous pouvez utiliser le IQueryable-Extensions ici, qui est une mise à la solution décrite par la "Ethan J. Brown":

https://github.com/thiscode/DynamicSelectExtensions

L'Extension construit dynamiquement un type anonyme.

Ensuite, vous pouvez faire ceci:

var YourDynamicListOfFields = new List<string>(
"field1",
"field2",
[...]
)
var query = query.SelectPartially(YourDynamicListOfFields);

Je ne crois pas que vous serez en mesure d'atteindre cet objectif. Bien que quand vous ne select new { c.Name, c.Population } il semble que vous n'êtes pas la création d'une classe vous êtes réellement. Si vous avez un coup d'oeil à la sortie compilée dans le Réflecteur ou cru, IL vous serez en mesure de voir ça.

Vous aurez une classe qui ressemblerait à quelque chose comme ceci:

[CompilerGenerated]
private class <>c__Class {
public string Name { get; set; }
public int Population { get; set; }
}

(Ok, j'ai nettoyé une touche, depuis un bien est vraiment juste une get_Name() et set_Name(name) méthode de jeu de toute façon)

Ce que vous essayez de faire est la bonne dynamique de la création de classes, quelque chose qui ne sera pas disponible jusqu'à ce que .NET 4.0 vient de sortir (et même alors, je ne suis pas vraiment sûr si ça va être en mesure de réaliser ce que vous voulez).

Vous êtes la meilleure solution serait de définir les différents anonyme classes et ensuite avoir une sorte de logique de contrôle afin de déterminer celui qui à créer, et à le créer, vous pouvez utiliser l'objet System.Linq.Expressions.NewExpression.

Mais, il se peut (en théorie au moins) possible de le faire, si vous vous sentez vraiment hard-core sur le sous-jacent LINQ fournisseur. Si vous sont de la rédaction de votre propre fournisseur LINQ vous pouvez détecter si actuellement analysé l'expression est de Sélectionner, puis de déterminer le CompilerGenerated classe, réfléchir pour son constructeur et de créer.

Défi n'est pas une tâche simple, mais il serait comment LINQ to SQL, LINQ to XML, etc tous le faire.

Cette compile, je sais pas si il fonctionne cependant...

myEnumerable.Select((p) => { return new { Name = p.Name, Description = p.Description }; });

En supposant que p est ce que votre transformation, et l'instruction select retourne un anon type, à l'aide de la déclaration de la fonction de lambda.

Edit: aussi, je ne sais pas comment vous permettrait de générer dynamiquement. Mais au moins, il vous montre comment utiliser la sélection lambda de retour d'un anon type avec plusieurs valeurs

Edit2:

Vous devriez également garder à l'esprit, que le compilateur c# génère les classes statiques de la anon type. Si l'anon type n'ont en fait un type après le moment de la compilation. Donc, si votre production de ces requêtes au moment de l'exécution (qui je suppose que vous êtes), vous pourriez être la construction d'un type à l'aide de diverses méthodes de réflexion (je crois que vous pouvez les utiliser pour faire des types à la volée) charge de la création de types dans le contexte d'exécution et les utiliser dans la sortie générée.

Vous pouvez utiliser l'Expression Dynamique de l'API qui permet de créer dynamiquement des select, comme ceci:

 Select("new(<property1>,<property2>,...)");

Vous avez besoin de la Dynamique.cs fichier à partir du LINQ et de la langue des échantillons pour Visual Studio pour que cela fonctionne, les deux sont liées au bas de cette page. Vous pouvez également voir un exemple montrant en action, à la même URL.