Créer une expression lambda avec un nouveau type anonyme au moment de l'exécution

Je veux appeler une méthode qui attend un paramètre comme ceci:

Expression<Func<sometype, 'a>> expr

J'ai besoin pour la construction de ce paramètre lors de l'exécution, parce que je ne sais pas quel est le type anonyme va ressembler avant; il pourrait avoir n'importe quel nombre de champs:

x => new { a=x.a, b=x.b, c=x.c, etc... }

Je peux créer un type à l'exécution qui a la même "signature" (Est-ce le bon mot?) que l'anonyme de type, mais la question est: Comment dois-je construire cette expression lambda au moment de l'exécution? Plus Particulièrement L'Expression.La nouvelle est m'énerve, parce que j'ai besoin de passer un constructorInfo à ce que je l'obtenir à partir d'un type (qui peut en effet être un type anonyme, mais je ne peux pas créer un type anonyme au moment de l'exécution. Ou est-il un moyen de le faire?).

Mise à jour (contexte, comme demandé dans les commentaires)

La méthode que je veux invoquer est:

DependentNavigationPropertyConfiguration.HasForeignKey<TKey>(Expression<Func<TDependentEntityType, TKey>> foreignKeyExpression)

La raison pour laquelle je veux faire, c'est de faire automatiquement une propriété de navigation à une entité qui hérite d'une certaine classe de base comprennent la clé de cette classe de base dans la clé étrangère. Parce qu'une entité peut avoir plusieurs champs de clé de tout type, le type TKey n'est connu que de moi au moment de l'exécution.

Qu'est-ce que l'entrée de scénario vous? Avez-vous le construire au moment de l'exécution de la chaîne-de la base de données?
Lors de l'exécution d'un certain nombre de champs sont sélectionnés à partir de 'sometype'. J'ai besoin de construire l'expression. Les noms des champs de la anonyme de type sont les mêmes que les champs qui ont été sélectionnés à partir de 'sometype'.
Pourquoi le downvote? Veuillez expliquer afin que je puisse apprendre un jour.

OriginalL'auteur EPLKleijntjens | 2013-05-30

  1. 10

    Utiliser une autre méthode:

    public static void Main()
{
    var myExpression = Express(str => new { 
        String = str, 
        Length = str.Length 
    });

    //We can compile/use it as well...
    var compiledExpression = myExpression.Compile();
    var anonymousOutput = compiledExpression("Input String");

    Console.WriteLine(anonymousOutput.String); //Output: Input String
    Console.WriteLine(anonymousOutput.Length); //Output: 12

    Debug.WriteLine(myExpression); //Output: "str => new <>f__AnonymousType0`2(String = str, Length = str.Length)"
    Console.ReadLine();
}


static Expression<Func<String, T>> Express<T>(Expression<Func<String, T>> expression)
{
    return expression;
}

    Noter, cependant, que le point de départ de type (dans mon exemple String) doit être connu avant.

    Mise à jour:

    Depuis qu'il semble que vous essayez de faire est de créer dynamiquement un type, je vais vous donner un exemple simple de la façon de le faire.

    public static void Main()
{
        //Create an anonymous type with two fields
    Type myAnonymousType = CreateNewType<String, Int32>();
    dynamic myAnon = Activator.CreateInstance(myAnonymousType);

    myAnon.FieldA = "A String";
    myAnon.FieldB = 1234;


    Console.WriteLine(myAnon.FieldA); //Output : "AString"
    Console.WriteLine(myAnon.FieldB); //Output : 1234
    Console.ReadLine();
}

public static Type CreateNewType<TFieldTypeA, TFieldTypeB>()
{
    //Let's start by creating a new assembly
    AssemblyName dynamicAssemblyName = new AssemblyName("MyAsm");
    AssemblyBuilder dynamicAssembly = AssemblyBuilder.DefineDynamicAssembly(dynamicAssemblyName, AssemblyBuilderAccess.Run);
    ModuleBuilder dynamicModule = dynamicAssembly.DefineDynamicModule("MyAsm");

    //Now let's build a new type
    TypeBuilder dynamicAnonymousType = dynamicModule.DefineType("MyAnon", TypeAttributes.Public);

    //Let's add some fields to the type.
    FieldInfo dynamicFieldA = dynamicAnonymousType.DefineField("FieldA", typeof(TFieldTypeA), FieldAttributes.Public);
    FieldInfo dynamicFieldB = dynamicAnonymousType.DefineField("FieldB", typeof(TFieldTypeB), FieldAttributes.Public);

    //Return the type to the caller
    return dynamicAnonymousType.CreateType();
}

    Comme vous pouvez le voir, c'est un peu plus compliqué. Si vous voulez étudier le sujet plus loin cependant, certainement référence Reflectoin.Emit.

    Merci, c'est un bon truc, mais malheureusement, ça ne résout pas mon problème principal, à savoir que je ne sais pas quel est le type anonyme va ressembler avant le moment d'exécution (nombre de champs est variable). Donc je ne peux pas réellement faire de l'expression de n'importe où.
    Oh, je vois. Donc, la chose est, un type anonyme est une fonctionnalité de compilateur, qui est, lorsque vous écrivez un anonyme, le compilateur construit en fait à une classe spécifique avec un nom aléatoire (dans mon exemple <>f__AnonymousType0'2). Donc vous ne pouvez pas vraiment facilement créer un type anonyme au moment de l'exécution. Vous pourriez vous en sortir avec l'aide de Expression.New, mais qui nécessite un constructeur, ce qui implique qu'elle doit être d'un type existant. Vous pouvez définir un type de contourner cela, mais c'est vraiment une toute autre question. Si vous voulez, je peux écrire un exemple.
    Mise à jour de la réponse.
    Merci encore pour votre problème. Je sais comment créer le type j'ai besoin de l'aide de la réflexion, mais le problème est que, en utilisant ce type, je ne peux pas créer une expression qui crée un nouveau type anonyme. J'ai ajouté un peu de contexte à ma question initiale. Si j'invoque la méthode mentionnée avec une expression créée à partir d'un nouveau type, grâce à la réflexion, j'obtiens une exception de me dire le type de l'expression ne convient pas, car il attend une expression de propriété ou un avec un type anonyme...
    Ce que je veux dire c'est que je peux créer cette expression: x=>nouvelle MyAnonymousType() {a=x.a, b=x.b}, mais je ne peux pas créer de x=>new {a=x.a, b=x.b} La méthode que je suis en train d'invoquer attend le deuxième type de l'expression (sans type explicite).

    OriginalL'auteur sircodesalot

  2. 3

    Les types anonymes sont une fonctionnalité de compilateur. Si vous n'obtenez pas le compilateur pour créer au moment de la compilation, alors vous aurez à utiliser les méta-programmation - soit TypeBuilder ou peut-être CSharpCodeProvider. Vous pourriez être mieux à l'aide de n-uplets - au moins, ils sont faciles à créer (vous pouvez utiliser Tuple.Create assez facilement).

    Comme pour l'expression, je suggère de le taper comme Expression<Func<sometype, object>> - qui va travailler pour toute formulation. Le code l'inspection la Expression peut bien sûr voir ce que le type réel est.

    OriginalL'auteur Marc Gravell

  3. -7

    vous pouvez le faire tout simplement comme ce

    context.Students.Join(context.Courses, a => a.Course_id, b => b.Course_id, (a, b) => new { Student= a, Course= b }).Where(x => x.Student_id == studentId)
      .Select(y => new
      {
         StudentId = y.Student.StudentId,
         RegistrationNumber = y.Student.RegNo,
         Name = y.Student.Name,
         Coursename = y.Course.Name
      }).ToList();
    Comment est-ce répondre à la question?
    Vous pouvez obtenir un type anonyme au moment de l'exécution, sans avoir à remplir les données dans un type connu. Peut-être pas très pertinent à la question, mais utile
    Il est important de comprendre, que new des déclarations comme dans votre exemple ne sont pas la création de types anonymes à compilation. C'est pourquoi cette réponse n'a rien à voir avec la question et, par conséquent, n'est pas utile à tous.

    OriginalL'auteur Shahid Iqbal