Écriture du code de l'activité

Pour illustrer comment écrire le code d'activité, nous allons recréer une activité Calculatrice (Calculator) simple qui est incluse dans l'exemple de solution UiPath.Examples.Activities que vous pouvez télécharger à partir de GitHub. Cette activité prend deux nombres et une opération (ajouter, soustraire, multiplier ou diviser) en entrée et renvoie le résultat de l'opération sélectionnée.

Le code d'activité est composé de deux parties : la logique d'activité et la conception d'activité.

Logique d’activité

À partir de UiPath.Activities.Template, nous allons renommer la solution et tous les fichiers et références associés à UiPath.Examples.Activities.

1. Renommez le fichier qui contient la logique d'activité de ActivityTemplate.cs à Calculator.cs.

2. Mettez à jour les références et l'espace de noms comme suit :

   using System.Activities;
   using System.Diagnostics;
   using UiPath.Examples.Activities.Helpers;
   
   namespace UiPath.Examples.Activities
   {
   }

3. Déclarez les arguments d'entrée : deux nombres (FirstNumber et SecondNumber comme int) et l'opération à effectuer (SelectedOperation comme enum, avec une valeur par défaut facultative définie sur Multiply). Marquez les trois arguments comme requis à l'aide de l'attribut [RequiredArgument] . La valeur renvoyée sera utilisée pour définir la valeur de l'argument Result.

   public class Calculator : CodeActivity<int> // This base class exposes an OutArgument named Result
       {
           [RequiredArgument]
           public InArgument<int> FirstNumber { get; set; } //InArgument allows a varriable to be set from the workflow
   
           [RequiredArgument]
           public InArgument<int> SecondNumber { get; set; }
   
           [RequiredArgument]
           public Operation SelectedOperation { get; set; } = Operation.Multiply; // default value is optional
   
           /*
            * The returned value will be used to set the value of the Result argument
            */
       }

4. À partir de la partie exécution, nous allons ajouter de la journalisation, obtenir les valeurs des nombres à partir du contexte du workflow et ajouter une logique pour gérer le scénario d’une division par zéro.

   protected override int Execute(CodeActivityContext context)
           {
               // This is how you can log messages from your activity. logs are sent to the Robot which will forward them to Orchestrator
               context.GetExecutorRuntime().LogMessage(new Robot.Activities.Api.LogMessage()
               {
                   EventType = TraceEventType.Information,
                   Message = "Executing Calculator activity"
               });
   
               var firstNumber = FirstNumber.Get(context); //get the value from the workflow context (remember, this can be a variable)
               var secondNumber = SecondNumber.Get(context);
   
               if (secondNumber == 0 && SelectedOperation == Operation.Divide)
               {
                   throw new DivideByZeroException("Second number should not be zero when the selected operation is divide");
               }
   
               return ExecuteInternal(firstNumber, secondNumber);
           }

5. Ajoutez les calculs à exécuter pour chaque opération sélectionnée.

   public int ExecuteInternal(int firstNumber, int secondNumber)
           {
               return SelectedOperation switch
               {
                   Operation.Add => firstNumber + secondNumber,
                   Operation.Subtract => firstNumber - secondNumber,
                   Operation.Multiply => firstNumber * secondNumber,
                   Operation.Divide => firstNumber / secondNumber,
                   _ => throw new NotSupportedException("Operation not supported"),
               };
           }

6. Définissez les opérations.

   public enum Operation
       {
           Add,
           Subtract,
           Multiply,
           Divide
       }

Conception d’activité

Les entrées disponibles dans une activité sont déterminées par les types de données des propriétés. Dans l'exemple d'activité Calculatrice, le type de données int des propriétés FirstNumber et SecondNumber entraîne la création d'un éditeur de nombres comme champ d'entrée des propriétés, tandis que pour Operation, qui a le type de données enum , un menu déroulant sera disponible dans l'activité.

Les libellés et les info-bulles des propriétés peuvent être définis dans le fichier Resources.resx.

Le tableau suivant décrit les propriétés les plus courantes disponibles pour chaque propriété d'activité.

Propriété	Description
DisplayName	Libellé de la propriété.
Info-bulle	Le texte à afficher lors du survol de la propriété
IsRequired1	Indique si la propriété est requise. Les propriétés requises doivent également être marquées dans l'activité à l'aide de l'attribut [RequiredArgument] .
Est Principal2	Indique si la propriété doit toujours être visible dans la catégorie principale de l'activité. Si définie sur false, la propriété apparaît sous un menu Afficher les options avancées ( Show advanced options ) qui est réduit par défaut.
IndexOrder	Ordre dans lequel afficher la propriété.

¹ Non disponible pour les propriétés de sortie, qui ne sont jamais obligatoires.

² Par convention, les propriétés de sortie sont placées à la fin de l'activité dans les options avancées.

Création de la conception de l’activité Calculatrice (Calculator)

1. Renommez le fichier ActivityTemplateViewModel.cs en CalculatorViewModel.cs et ajoutez-y le code de l'interface utilisateur de l'activité.

2. Mettez à jour les références et l'espace de noms comme suit :

   using System.Activities.DesignViewModels;
   using System.Diagnostics;
   
   namespace UiPath.Examples.Activities.ViewModels
   {
   }

3. Déclarez les propriétés d'entrée. La propriété result provient de la classe de base de l'activité. Les noms et les arguments de type doivent correspondre à ceux de l'activité.

   public class CalculatorViewModel : DesignPropertiesViewModel
       {
           /*
            * Properties names must match the names and generic type arguments of the properties in the activity
            * Use DesignInArgument for properties that accept a variable
            */
           public DesignInArgument<int> FirstNumber { get; set; }
           public DesignInArgument<int> SecondNumber { get; set; }
           /*
            * Use DesignProperty for properties that accept a constant value                
            */
           public DesignProperty<Operation> SelectedOperation { get; set; }
            /*
            * The result property comes from the activity's base class
            */
           public DesignOutArgument<int> Result { get; set; }
           
           public CalculatorViewModel(IDesignServices services) : base(services)
           {
           }
       }

4. Ajoutez le code de la conception de l’activité. En option, nous pouvons ajouter un point d'arrêt pour déboguer l'initialisation du ViewModel en supprimant les marques de commentaire de la ligne contenant Debugger.Break();. Nous allons initialiser les propriétés du ViewModel, ajouter un appel PersistValuesChangedDuringInit() qui est obligatoire lorsque vous modifiez les valeurs de propriété lors de l'initialisation, et définir les propriétés d'entrée et de sortie de l'activité.

   Le code doit ressembler à ceci :

   protected override void InitializeModel()
           {
              //Debugger.Break(); 
               /*
                * The base call will initialize the properties of the view model with the values from the xaml or with the default values from the activity
                */
               base.InitializeModel();
   
               PersistValuesChangedDuringInit(); // just for heads-up here; it's a mandatory call only when you change the values of properties during initialization
   
               var orderIndex = 0;
   
               FirstNumber.DisplayName = Resources.Calculator_FirstNumber_DisplayName;
               FirstNumber.Tooltip = Resources.Calculator_FirstNumber_Tooltip;
               /*
                * Required fields will automatically raise validation errors when empty.
                * Unless you do custom validation, required activity properties should be marked as such both in the view model and in the activity:
                *   -> in the view model use the IsRequired property
                *   -> in the activity use the [RequiredArgument] attribute.
                */
               FirstNumber.IsRequired = true;
   
               FirstNumber.IsPrincipal = true; // specifies if it belongs to the main category (which cannot be collapsed)
               FirstNumber.OrderIndex = orderIndex++; // indicates the order in which the fields appear in the designer (i.e. the line number);
   
               SecondNumber.DisplayName = Resources.Calculator_SecondNumber_DisplayName;
               SecondNumber.Tooltip = Resources.Calculator_SecondNumber_Tooltip;
               SecondNumber.IsRequired = true;
               SecondNumber.IsPrincipal = true;
               SecondNumber.OrderIndex = orderIndex++;
   
               SelectedOperation.DisplayName = Resources.Calculator_SelectedOperation_DisplayName;
               SelectedOperation.Tooltip = Resources.Calculator_SelectedOperation_Tooltip;
               SelectedOperation.IsRequired = true;
               SelectedOperation.IsPrincipal = true;
               SelectedOperation.OrderIndex = orderIndex++;
   
               /*
                * Output properties are never mandatory.
                * By convention, they are not principal and they are placed at the end of the activity.
                */
               Result.DisplayName = Resources.Calculator_Result_DisplayName;
               Result.Tooltip = Resources.Calculator_Result_Tooltip;
               Result.OrderIndex = orderIndex;
           }

5. Ajoutez les valeurs de chaîne pour les libellés et les info-bulles dans le fichier Resources.resx comme dans l'image suivante. À des fins de localisation, vous devez utiliser des commentaires spécifiques pour le nom de l'activité (Activity name) et la description de l'activité (Activity description). Pour les autres chaînes, l'ajout de commentaires est recommandé, mais non obligatoire.
   
   

   

   
   

Dans Studio, la configuration entraîne ce qui suit :

1 - Libellés (noms complets) des trois propriétés d'entrée.

2 : info-bulle pour la propriété FirstNumber .