locked
[WF4] Passage d’arguments Literal, VisualBasicValue ou LambdaValue? RRS feed

  • Discussion générale

  • Avec la sortie de la RC de Visual Studio 2010,  Microsoft a mis un peu les points sur leS i en ce qui concernait le passage d’arguments. Mais nous somme un certain nombre à avoir pris ce changement comme un coup dur.

    Pour résumer la situation : à la sortie de la RC il n’est plus devenu possible de passer à un Workflow des objets en référence…. Enfin c’est le message compris par une partie de la communauté. En fait ce message est biaisé : Il n’est plus possible d’utiliser le type Literal pour passer des types références hors mis la String.

    On peut toujours passer des types références, mais il faut passer par un autre Type que Literal. Le Literal reprend donc son sens “littéral”… (oui j’aime les phrases à 2 centimes!). Utiliser un Literal pour passer une valeur non immuable, c’était un peut comme stocker une valeur non constante dans une constante. La terminologie reprend donc un peu plus de son sens.

    Mais alors maintenant comment passer des argument à un Workflow?

    Trois cas se présentent :

    1. Passer une variable qui ne soit pas de type référence ou une String.
    2. Passer un type référence sans avoir besoin de garder un référence sur ce qui a été fait dans le Workflow.
    3. Passer un type référence et l’utiliser encore après qu’il soit passer par le Workflow.

    Pour répondre à ces trois situations, nous disposons de trois classes. Seule souci, ces classe se marchent un peu les une sur les autres :

    • Literal ne peut servir que dans le cas 1 (Avant Literal pouvait servir à tout).
    • VisualBasicValue peut servir dans les cas 1 et 2.
    • LambdaValue peut servir pour les cas 1, 2 et 3.

    Pour bien assimiler le pourquoi du comment, voici un petit exemple de chaque classes :

    - Literal<T> :

    Ex : un Workflow qui prend en entrée un argument Argument1 de type Int32 :

    1.Int32 i = 6;
    2.Workflow1 workflow = new Workflow1() { Argument1 = i };
    3.WorkflowInvoker.Invoke(workflow);

    Oui ce code utilise un littéral mais ça ne se voit pas ;)

    En fait, le code suivant est équivalant :

    1.Int32 i = 6;
    2.Workflow1 workflow = new Workflow1() { Argument1 = new Literal<Int32>(i) };
    3.WorkflowInvoker.Invoke(workflow);

    Je pense qu’après cet exemple simple vous venez de comprendre le souci représenté par les changement de la RC : Le Literal<T> s’utilise par défaut des les écritures implicites :(.

     

    - VisualBasicValue<T> :

    Personnellement il s’agit de l’approche que j’apprécie le moins. L’idée de passer une String lors de l’exécution du programme alors qu’elle a échappée à tout control lors de la compilation, ça ne m’emballe pas.

    Par exemple on peut reproduite l’exemple précédent avec une VisualBasicValue :

    1.String expression = "6";
    2.Workflow1 workflow = new Workflow1() { Argument1 = new VisualBasicValue<Int32>(expression) };
    3.WorkflowInvoker.Invoke(workflow);

    Tout type d’expression peut être passé par ce biais, il y est aussi possible d’y passer l’instanciation d’un type référence. Pour un exemple simple comme celui présenté par la Team WCF/WF sur son blog tout vas bien. Par contre dès qu’il s’agit d’utiliser des types références un peu plus évolués, les choses se corsent. Il faut alors utiliser des VisualBasicSettings pour s’en sortir (… peut être un article à venir sur ce sujet. Mais je doute que cela intéresse grand  monde).

     

    - LambdaValue<T> :

    Le type LambdaValue, comme on s’en  doute s’appui sur une lambda. Son utilisation nécessite donc très peu de code. Il suffit de créer une instance de notre type référence et de la passer au constructeur de la LambdaValue via une expression lambda comme ceci :

    1.Personne p = new Personne() { Nom = "Jeanson", Prenom = "Jérémy" };
    2.Workflow1 workflow = new Workflow1() { Argument1 = new LambdaValue<Personne>(c => p) };
    3.WorkflowInvoker.Invoke(workflow);

    Après le code d’invocation du Workflow, le type référence peut être utilisé et on peut constater les éventuelles modifications effectués lors du passage dans le Workflow.

    Si vous n’avez pas besoin d’utiliser votre type référence en sortie de Workflow, vous prouver utiliser la LambdaValue comme ceci :

    1.Workflow1 workflow = new Workflow1() { Argument1 = new LambdaValue<Personne>(c =>
    2.    new Personne() { Nom = "Jeanson", Prenom = "Jérémy" })
    3.};
    4.WorkflowInvoker.Invoke(workflow);
     
     
     
     

    par Jérémy Jeanson.

     

    Article original : [WF4] Passage d’arguments Literal, VisualBasicValue ou LambdaValue?

     

     

    Pour plusieurs informations, visitez la page WF – Articles et Didacticiels

    vendredi 28 mai 2010 12:24