Le fichier d'activité

Important :

Ce document fait référence à une version obsolète de UiPath Activity Creator pour Visual Studio. Consultez la nouvelle documentation ici.

Introduction

Chaque activité commence par un fichier de classe d'activité qui définit ses entrées, ses sorties et sa logique d'exécution. Pour mieux comprendre comment procéder, ouvrez le fichier enfantActivity.cs dans votre projet d'activité et parcourez-le section par section. Il s'agit d'une activité simple qui ajoute 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 espaces de noms

Le fichier commence par un passe-partout standard. Il importe certains espaces de noms, puis déclare que cette activité sera elle-même dynamique dans l'espace de noms MyCompacy.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 la classe

Toutes les classes d'activités standard étendent AsyncTaskCodeActivity, qui fournit des méthodes de validation des propriétés au moment de la conception et de la logique d'exécution au moment de l'exécution, et se trouve 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 leur permet d'être utilisées avec les activités Parallèle et Parallèle pour chaque dans UiPath Studio.

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

Au-dessus de la définition de la classe enfantActivité, 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 Activités de UiPath Studio. Dans cet exemple, les attributs font référence aux 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, reportez-vous 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

CacheMetadata permet de valider les propriétés d'une activité, les délégués et/ou les activités enfants. 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 générons une erreur de validation si l'une des deux n'est pas fournie. Tant que les erreurs de validation n'ont pas été géré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écuterAsynchrone renvoie un objet Task<Action<AsyncCodeActivityContext>> . Un Task est renvoyé afin 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 une fois que des opérations asynchrones sont terminées. Dans l'exemple ci-dessus, cette fonction définit simplement la valeur de Sum. Enfin, le Action prend un paramètre AsyncCodeActivityContext de sorte que le contexte de cette activité peut être utilisé par l’ensemble des fonctions de ce type exécutées 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.