Fichier d'activité

Attention : ce document fait référence à une version obsolète du Créateur d'activités UiPath pour Visual Studio. Veuillez consulter la nouvelle documentation ici.

Introduction

Chaque activité commence par un fichier de classe Activity qui définit ses entrées, ses sorties et sa logique d'exécution. Pour mieux comprendre comment procéder, ouvrez le fichier ActivitéEnfants.cs dans votre projet d’activité et parcourez-le section par section. Il s’agit d’une activité simple qui additionne deux nombres et génère leur somme.

using System;
using System.Activities;
using System.Threading;
using System.Threading.Tasks;
using MyCompany.MyProduct.Activities.Properties;
using UiPath.Shared.Activities;
namespace MyCompany.MyProduct.Activities
{
    [LocalizedDisplayName(nameof(Resources.ChildActivityDisplayName))]
    [LocalizedDescription(nameof(Resources.ChildActivityDescription))]
    public class ChildActivity : AsyncTaskCodeActivity
    {
        #region Properties
        [LocalizedDisplayName(nameof(Resources.ChildActivityFirstNumberDisplayName))]
        [LocalizedDescription(nameof(Resources.ChildActivityFirstNumberDescription))]
        [LocalizedCategory(nameof(Resources.Input))]
        public InArgument<int> FirstNumber { get; set; }
        [LocalizedDisplayName(nameof(Resources.ChildActivitySecondNumberDisplayName))]
        [LocalizedDescription(nameof(Resources.ChildActivitySecondNumberDescription))]
        [LocalizedCategory(nameof(Resources.Input))]
        public InArgument<int> SecondNumber { get; set; }
        [LocalizedDisplayName(nameof(Resources.ChildActivitySumDisplayName))]
        [LocalizedDescription(nameof(Resources.ChildActivitySumDescription))]
        [LocalizedCategory(nameof(Resources.Output))]
        public OutArgument<string> Sum { get; set; }
        #endregion
          
        #region Constructors
          
        public ChildActivity()
        {
              Constraints.Add(ActivityConstraints.HasParentType<ChildActivity, ParentScope>(Resources.ValidationMessage));
        }
      
        #endregion
          
        #region Protected Methods
        protected override void CacheMetadata(CodeActivityMetadata metadata)
        {
              if (FirstNumber == null) metadata.AddValidationError(string.Format(Resources.MetadataValidationError, nameof(FirstNumber)));
              if (SecondNumber == null) metadata.AddValidationError(string.Format(Resources.MetadataValidationError, nameof(SecondNumber)));
              base.CacheMetadata(metadata);
        }
        protected override async Task<Action<AsyncCodeActivityContext>> ExecuteAsync(AsyncCodeActivityContext context, CancellationToken cancellationToken)
        {
              var property = context.DataContext.GetProperties()[ParentScope.ApplicationTag];
              var app = property.GetValue(context.DataContext) as Application;
           
              var firstValue = FirstNumber.Get(context);
              var secondValue = SecondNumber.Get(context);
        
              var sum = app.Sum(firstValue, secondValue);
              return ctx =>
              {
                  Sum.Set(ctx, sum);
              };
       }
        #endregion
    }
}

Importations et espace de noms

Le fichier commence par un texte passe-partout standard. Il importe des espaces de noms, puis déclare que cette activité restera elle-même dans l'espace de noms MyCompany.MyProduct.Activities .

using System;
using System.Activities;
using System.Threading;
using System.Threading.Tasks;
using MyCompany.MyProduct.Activities.Properties;
using UiPath.Shared.Activities;
namespace MyCompany.MyProduct.Activities
{

Définition de classe

Toutes les classes d'activité standard (telles que l'exemple ActivitéEnfants) étendent AsyncTaskCodeActivity, qui fournit des méthodes pour la validation des propriétés au moment de la conception et la logique d'exécution au moment du runtime. Elles sont disponibles dans le dossier Partagé inclus dans votre solution. De plus, toutes les activités qui étendent AsyncTaskCodeActivity peuvent s'exécuter de manière asynchrone, ce qui permet de les utiliser avec les activités Parallèle ( Parallel ) et Parallèle ( Parallel For Each ) dans UiPath Studio.

[LocalizedDisplayName(nameof(Resources.ChildActivityDisplayName))]
[LocalizedDescription(nameof(Resources.ChildActivityDescription))]
public class ChildActivity : AsyncTaskCodeActivity
{

Au-dessus de la définition de classe ActivitéEnfants (ChildActivity), vous remarquerez deux attributsLocalizedDisplayName et LocalizedDescription. Ceux-ci vous permettent de définir le nom et la description de l'info-bulle de l'activité qui apparaît dans le volet des activités de UiPath Studio. Dans cet exemple, les attributs font référence à des versions localisées de chacun (par ex. Resources.ChildActivityDisplayName), mais des chaînes simples peuvent également être utilisées. Pour plus d'informations sur la localisation, voir ici.

Propriétés

Vient ensuite les propriétés de l'activité, qui apparaissent dans le volet Propriétés (Properties Pane) d'UiPath Studio. Chaque propriété possède un nom d'affichage et une description comme l'avait l'activité de niveau supérieur, mais un attribut Catégorie (Category) permet de regrouper les activités associées. Notez que FirstNumber et SecondNumber apparaissent dans la catégorie Entrée (Input), mais que Sum apparaît sous Sortie (Output).

[LocalizedDisplayName(nameof(Resources.ChildActivityFirstNumberDisplayName))]
[LocalizedDescription(nameof(Resources.ChildActivityFirstNumberDescription))]
[LocalizedCategory(nameof(Resources.Input))]
public InArgument<int> FirstNumber { get; set; }
[LocalizedDisplayName(nameof(Resources.ChildActivitySecondNumberDisplayName))]
[LocalizedDescription(nameof(Resources.ChildActivitySecondNumberDescription))]
[LocalizedCategory(nameof(Resources.Input))]
public InArgument<int> SecondNumber { get; set; }
[LocalizedDisplayName(nameof(Resources.ChildActivitySumDisplayName))]
[LocalizedDescription(nameof(Resources.ChildActivitySumDescription))]
[LocalizedCategory(nameof(Resources.Output))]
public OutArgument<int> Sum { get; set; }

Les propriétés peuvent être déclarées comme de type InArgument, InOutArgument ou OutArgument et doivent indiquer le type attendu (par ex. string, int, ...).

Constructeur

public ChildActivity()
{
     FirstNumber = 10;
     Constraints.Add(ActivityConstraints.HasParentType<ChildActivity, ParentScope>(Resources.ValidationMessage));
}

Le constructeur est utilisé pour définir des valeurs par défaut et des contraintes sur les propriétés.

• Dans l'exemple ci-dessus, la propriété FirstNumber reçoit une valeur par défaut de 10, qui apparaît dans le volet Propriétés.
  
  

  

  
  

• De plus, une contrainte est placée sur l’activité elle-même, exigeant qu’elle soit entourée d’un objet ParentScope. Si ce n'est pas le cas, une erreur de validation s'affiche.

  
  

  

  
  

CacheMetadata

MétadonnéesCache permet de valider les propriétés, les délégués et/ou les activités enfants d'une activité. Dans cet exemple, nous vérifions que des valeurs ont été fournies pour les deux propriétés d'entrée, FirstNumber et SecondNumber, et nous générons une erreur de validation si l'une ou l'autre n'est pas fournie. Tant que les erreurs de validation ne sont pas traitées, un workflow ne s’exécutera pas.

protected override void CacheMetadata(CodeActivityMetadata metadata)
{
    if (FirstNumber == null) metadata.AddValidationError(string.Format(Resources.MetadataValidationError, nameof(FirstNumber)));
    if (SecondNumber == null) metadata.AddValidationError(string.Format(Resources.MetadataValidationError, nameof(SecondNumber)));
    base.CacheMetadata(metadata);
}

ExecuteAsync

ExécuterAsync est l'endroit où la logique d'exécution de l'activité est conservée.

• Les deux premières lignes de la méthode interrogent le contexte d'activité, c'est-à-dire l'état actuel de l'activité ChildActivity et les éléments qui l'entourent, pour récupérer un objet Application dans le parentScope si celui-ci est entouré. Notez qu’en raison de la contrainte ajoutée dans le constructeur ci-dessus, cette activité ne sera jamais autorisée à s’exécuter si elle n’est pas déjà dans un ParentScope.
• Les lignes suivantes récupèrent les valeurs actuelles des propriétés FirstNumber et SecondNumber et les enregistrent dans des variables locales.
• Les dernières lignes effectuent une opération Sum sur les nombres entrés et définissent la propriété Sum sur cette valeur. Étant donné que Sum est une propriété de sortie, cette valeur peut ensuite être utilisée par des activités ultérieures dans le workflow.

  protected override async Task<Action<AsyncCodeActivityContext>> ExecuteAsync(AsyncCodeActivityContext context, CancellationToken cancellationToken)
  {
      var property = context.DataContext.GetProperties()[ParentScope.ApplicationTag];
      var app = property.GetValue(context.DataContext) as Application;
             
      var firstValue = FirstNumber.Get(context);
      var secondValue = SecondNumber.Get(context);
          
      var sum = app.Sum(firstValue, secondValue);
      return ctx =>
      {
          Sum.Set(ctx, sum);
      };
  }

  Important :

  Notez que la méthode ExécuterAsync renvoie un objet Task<Action<AsyncCodeActivityContext>> .

  Un Task est renvoyé pour que cette activité puisse s'exécuter de manière asynchrone.

  Un Action est renvoyé dans cette tâche afin de permettre l'exécution de fonctions complexes après la fin des opérations asynchrones. Dans l'exemple ci-dessus, cette fonction définit simplement la valeur de Sum.

  Enfin, Action prend un paramètre AsyncCodeActivityContext afin que le contexte de cette activité puisse être utilisé par toutes ces fonctions s'exécutant après la fin des opérations asynchrones. Si ce n’était pas le cas, le contexte pourrait être perdu et le Sum ne serait pas facilement modifiable.