Conseils sur les arbres d'expression C #

c# expression-trees reflection

Question

Je travaille sur une méthode qui accepte un arbre d'expression en tant que paramètre, avec un type (ou une instance) d'une classe.

L'idée de base est que cette méthode ajoute certaines choses à une collection qui sera utilisée pour la validation.

public interface ITestInterface
{
    //Specify stuff here.
}

private static void DoSomething<T>(Expression<Func<T, object>> expression, params IMyInterface[] rule)
{
    // Stuff is done here.
}

La méthode s'appelle comme suit:

public interface ITestInterface
{
    //Specify stuff here.
}

private static void DoSomething<T>(Expression<Func<T, object>> expression, params IMyInterface[] rule)
{
    // Stuff is done here.
}

Je le fais de cette façon parce que j'aimerais que les noms de propriétés qui sont transmis soient en caractères typés forts.

Un couple de choses que je lutte avec ..

  1. Dans DoSomething, j'aimerais obtenir un type PropertyInfo (du corps transmis) de T et l'ajouter à une collection avec la règle []. Actuellement, je songe à utiliser expression.Body et à supprimer [nom de la propriété] de "Convertir ((nom de la propriété])" et à utiliser la réflexion pour obtenir ce dont j'ai besoin. Cela semble lourd et faux. Y a-t-il un meilleur moyen?
  2. Est-ce un motif spécifique que j'utilise?
  3. Enfin, toute suggestion ou clarification concernant mon incompréhension de ce que je fais est appréciée et / ou des ressources ou des informations utiles sur les arbres d'expression C # sont également appréciées.

Merci!

Ian

Modifier:

Un exemple de ce que expression.Body.ToString() renvoie dans la méthode DoSomething est une chaîne contenant "Convert (t.MyProperty)" si elle est appelée à partir de l'exemple ci-dessus.

J'ai besoin qu'il soit fortement typé, donc il ne sera pas compilé si je change le nom de la propriété.

Merci pour les suggestions!

Réponse acceptée

La collecte d'objets PropertyInfo à partir d'Expression.Body semble similaire à ma solution à une autre question.


Réponse populaire

Je compte énormément sur les arbres d'expression pour pousser beaucoup de ce que je veux faire avec mon application actuelle au moment de la compilation, à savoir la vérification de type statique.

Je traverse des arbres d'expression pour les traduire en quelque chose d'autre qui «a du sens».

Une chose que j’ai souvent fait est que, au lieu d’URL, je me fie à une approche de type MVC dans laquelle je déclare des fonctions lambda et traduis ... interprète, l’arbre d’expression généré par le compilateur en une URL. Lorsque cette URL est appelée, je fais le contraire. De cette façon, j'ai ce que j'appelle des contrôles au moment de la compilation pour les liens brisés et cela fonctionne très bien avec le refactoring et les surcharges. Je pense que c'est cool de penser à utiliser des arbres d'expression de cette façon.

Vous voudrez peut-être vérifier le modèle de visiteurs, c'est un peu pénible de commencer car cela n'a pas beaucoup de sens au début, mais cela lie tout ensemble et c'est un moyen très formel de résoudre le contrôle de type dans la construction du compilateur. Vous pouvez faire la même chose, mais au lieu de vérifier le type, émettez ce dont vous avez besoin.

Quelque chose contre lequel je me bats actuellement la tête est la capacité de construire un cadre simple pour traduire (ou en fait, je devrais plutôt dire interpréter) l'expression et émettre du JavaScript. L'idée est que les arborescences d'expression générées par le compilateur se traduisent par un code JavaScript valide qui s'interface avec un modèle d'objet.

Ce qui est excitant à propos de cette situation est la façon dont le compilateur est toujours capable de me dire quand je me trompe et que le résultat final est juste un tas de chaînes, mais la partie importante est la façon dont ces chaînes ont été créées. Ils sont passés par une vérification et cela signifie quelque chose.

Une fois que vous y parvenez, vous n’avez plus grand chose à faire avec les arbres d’expression.

Tout en travaillant avec les éléments System.Reflection.Emit, je me suis retrouvé à utiliser des arbres d'expression pour créer un cadre léger pour la compilation dynamique, qui, au moment de la compilation, pouvait en principe indiquer si mes assemblages créés dynamiquement compileraient également, ce qui fonctionnait parfaitement avec la réflexion et vérification de type statique. Cela a pris de plus en plus loin et a abouti à quelque chose qui a finalement permis de gagner beaucoup de temps et qui s'est révélé très agile et robuste.

Donc j'aime ce genre de choses, et c'est ce qu'est la méta-programmation, écrire des programmes dans vos programmes qui font des programmes. Je dis, continuez!




Sous licence: CC-BY-SA with attribution
Non affilié à Stack Overflow
Est-ce KB légal? Oui, apprenez pourquoi
Sous licence: CC-BY-SA with attribution
Non affilié à Stack Overflow
Est-ce KB légal? Oui, apprenez pourquoi