Les arguments on beau être semblables aux arguments d’une méthodes, leur emploi via le contexte n’est pas sans conséquence. En effet l’appel du contexte pour une lecture ou une écriture vas être consommateur de ressources. Je ne dis pas là que votre application vas s’écrouler dès que vous allez utiliser le contexte, mais que dans un souci d’optimisation il est préférable de minimiser et de regrouper ces appels.

Un peu comme si vous manipuliez un fichier Xml en lecture puis écriture. Pour un fichier Xml, vous allez rechercher et lire les variables qui vous sont utiles et ce n’est qu’après traitement que vous allez mettre à jour le fichier. Si cela vous semble logique, alors il suffit de faire de même avec WF4 ;)

Pour illustrer mes propos, j’ai codé une petite activité sans logique mais avec quelques arguments In et Out.

public sealed class MyCodeActivity : CodeActivity
{
    public InArgument<String> InArgument1 { get; set; }
    public InArgument<String> InArgument2 { get; set; }
    public InArgument<String> InArgument3 { get; set; }
    public OutArgument<String> OutArgument1 { get; set; }
    public OutArgument<String> OutArgument2 { get; set; }
    public OutArgument<String> OutArgument3 { get; set; }

    protected override void Execute(CodeActivityContext context)
    {
        //--------------------------------------------------------------
        // Entrées
        String arg1 = this.InArgument1.Get(context);

        // Argument dépendant du premier argument
        String arg2 = String.IsNullorEmpty(arg1)
	        ? String.Empty
	        : this.InArgument2.Get(context);

        // Argument optionnel
        String arg3 = this.InArgument3 == null
	        ? String.Empty 
	        : this.InArgument3.Get(context);
            
        //--------------------------------------------------------------
        // Variable internes pour les arguments de sortie
        String out1, out2, out3;

        // Manipulation des variables
        // + Logique 
        // + code déterminant les valeurs de sortie ...

        //--------------------------------------------------------------
        // Sorties
        this.OutArgument1.Set(context, out1);
        this.OutArgument2.Set(context, out2);

        // Argument non défini
        if (this.OutArgument3 != null) OutArgument3.Set(context, out3);
    }
}

Afin que mon exemple soit évidant, j’ai clairement délimité les trois zones de code et donc les quelques règles qui s’y appliquent :

  1. Récupération des arguments d’entrée :
    • on ne récupère que les arguments définis et utiles.
  2. Logique de l’activité (code fonctionnel de l’activité)
    • on ne manipule que des variable internes à la méthode Execute.
    • on ne manipule pas les arguments de sortie à plusieurs reprises, on utilise des variables internes à Execute pour cela.
  3. Ecriture des arguments de sortie de l‘activité :
    • on n’affecte que les arguments définis.

Voila une petite liste simple mais qu’il faut garder à l’esprit pour avoir des activités performantes ;)