Tutoriel Workflow Foundation 2.3–Création et Réutilisation d’Activités

L’objectif de ce tutoriel est de créer des activités par code. L’objectif est de voir aussi comment réutiliser un workflow. Pour ce, nous allons créer un workflow qui affiche les éléments d’une liste, un workflow de génération d’éléments de liste et nous réutiliserons le workflow de tri créé dans le tutoriel 2.2. Ainsi, le nouveau tutoriel triera une liste générée automatiquement.

Etape 1 : Création d’un workflow d’affichage

L’objectif de cette étape est de créer un workflow affichant les éléments d’une liste. Nous utiliserons l’activité « ForEach » pour ceci.

  • Lancer VS 2012
  • Ouvrez la solution « Tutoriel22 » créée dans le tutoriel précédent
  • Ajoutez un nouvel élément au projet de type « Activity » appelé « AffichageActivite »
  • Définissez un argument en entrée appelé « message » de type « String »
  • Définissez un deuxième argument en entrée appelé « liste » de type « IList<Int32> »
  • Faites glisser une séquence sur le designer
  • Ajoutez une activité « WriteLine » qui affiche l’argument « message »
  • Ajoutez une activité « ForEach » après l’activité « WriteLine »
  • Dans la zone « in » entrez « liste »
  • A l’intérieur de la zone « Body » de l’activité « ForEach », glissez une activité « WriteLine » qui affiche l’élément en cours « item »

image

  • Compilez la solution

Etape 2 : Création d’une activité par code

L’objectif de cette étape est de créer une activité basée sur le code qui permettra de générer aléatoirement une liste. L’activité aura deux propriétés : « Taille » qui définira la taille de la liste et « Max » qui définira le nombre maximum à générer. L’activité aura comme argument de sortie une liste appelée « Liste ».

  • Ajoutez un nouvel élément à la solution de type « Code Activity » et appelez le « GenerateurActivite »

image

  • Cliquez sur « Ajouter »
  • Remarquez le code généré par VS 2012
public sealed class GenerateurActivite : CodeActivity
    {
        // Define an activity input argument of type string
        public InArgument<string> Text { get; set; }
 
        // If your activity returns a value, derive from CodeActivity<TResult>
        // and return the value from the Execute method.
        protected override void Execute(CodeActivityContext context)
        {
            // Obtain the runtime value of the Text input argument
            string text = context.GetValue(this.Text);
        }
    }
  • Placez le curseur sur « CodeActivity »
  • Appuyez sur F12 pour voir la définition de cette classe
  • Revenez à la classe « GenerateurActivite »
  • Supprimer la propriété « Text » et le code de la méthode « Execute »
  • Ajoutez deux propriétés publiques de type « Int32 » appelées « Taille » et « Max »
public Int32 Taille { get; set; }
 
public Int32 Max { get; set; }
  • Ajoutez une propriété définissant un argument en sortie appelé “Liste”. L’argument est de « IList<Int32> »
public OutArgument<IList<Int32>> Liste { get; set; }
  • Ajoutez un attribut privé appelé _random de type Random et initialisez-le
private Random _random = new Random();
  • Ajoutez la méthode “GetValeur” qui renvoie un nombre aléatoire de maximum “Max”
private int GetValeur()
        {
            return _random.Next(Max);
        }
  • Créez une méthode GetListe qui renvoie une liste de « Int32 » et renvoie une liste de taille « Taille » contenant des éléments générés aléatoirement
private IList<Int32> GetListe()
        {
            var resultat = new List<Int32>();
            for (int i = 0; i < Taille; i++)
                resultat.Add(GetValeur());
            return resultat;
        }
  • Dans l’exécution de l’activité, affecter la liste générée aléatoirement à l’argument en sortie.
protected override void Execute(CodeActivityContext context)
        {
            Liste.Set(context, GetListe());
        }
  • Le listing complet de l’activité « GenerateurActivite » est comme suit :
public sealed class GenerateurActivite : CodeActivity
    {
 
        private Random _random = new Random();
 
        private int GetValeur()
        {
            return _random.Next(Max);
        }
 
        private IList<Int32> GetListe()
        {
            var resultat = new List<Int32>();
            for (int i = 0; i < Taille; i++)
                resultat.Add(GetValeur());
            return resultat;
        }
 
        // If your activity returns a value, derive from CodeActivity<TResult>
        // and return the value from the Execute method.
        protected override void Execute(CodeActivityContext context)
        {
            Liste.Set(context, GetListe());
        }
 
        public Int32 Taille { get; set; }
 
        public Int32 Max { get; set; }
 
        public OutArgument<IList<Int32>> Liste { get; set; }
    }
  • Compilez la solution pour vérifier qu’il n’y a pas d’erreur.

Etape 3 : Réutilisation du workflow

L’objectif de cette étape est de réutiliser les deux workflow créés précédemment dans un autre workflow qui génèrera aléatoirement les éléments d’une liste puis les affichera.

  • Ajoutez une activité (workflow) appelée « TriAleatoire.xaml »
  • Remarquez la présence de trois activités nouvelles dans la barre à outils : « TriActivite », « GenerateurActivite » et « AffichageActivite »

image

  • Ajoutez une séquence au nouveau workflow
  • Créez une variable sur la séquence appelée « liste » dont le type est « Ilist<Int32> »
  • Ajoutez une activité de type « GenerateurActivite » à la séquence
  • Entrez « 20 » dans la propriété « Max »
  • Entrez « 3 » dans la propriété « Taille »
  • Affectez « liste » à la propriété « Liste »

image

  • Ajoutez une activité de type « AffichageActivite » en dessous de l’activité de génération
  • Dans la propriété « liste » entrez « liste »
  • Dans la propriété « Message » entrez « Après génération »

image

  • Modifiez « Program.cs » de façon à ce qu’il exécute le workflow « TriAleatoireWorkflow »
Activity w1 = new TriAleatoire();
            WorkflowInvoker.Invoke(w1);
            Console.ReadKey();
  • Exécutez le workflow en appuyant sur « F5 »

Débogage du workflow

L’objectif de cette étape est de voir les capacités de VS en terme de débogage de workflows.

  • Ouvrez « TriAleatoire » en mode designer
  • Cliquez sur le bouton « droit » de l’activité « GenerateurActivite » puis sur « Points d’arrêts à définir un point d’arrêt »
  • Remarquez que l’activité présente graphiquement un point d’arrêt

image

  • Exécutez en appuyant sur « F5 »
  • Remarquez que l’exécution pause sur l’activité

image

  • Affichez la fenêtre de débogage « locals »
  • Remarquez que la variable « liste » est à null
  • Appuyez sur « F10 » pour aller à la prochaine activité
  • Remarquez que la liste a changé de valeur

image

  • Continuez l’exécution en appuyant sur « F5 »
  • Enlevez le point d’arrêt en cliquant sur le bouton droit, puis « points d’arrêt à supprimer »

Etape 5 : Terminer le workflow

L’objectif de cette étape est de terminer le workflow en ajoutant l’activité de tri puis de rajouter une autre instance de l’activité d’affichage qui affichera les résultats après le tri.

  • Ouvrir « TriAleatoire » en mode design
  • Faites glisser l’activité « TriActivite » après l’activité d’affichage
  • Affectez « liste » à l’argument « liste »
  • Ajoutez une autre activité d’affichage derrière l’activité de tri
  • Affectez « après le tri » à la propriété « message »
  • Affectez « liste » à la propriété « liste »
image
  • Exécutez le workflow

image

Et c’est fini pour cette deuxième série de tutoriaux, pour télécharger le code cliquez sur le lien suivant ; http://1drv.ms/ZJHWhz.

Enoy !

Add comment

Loading