O arquivo de atividades

Importante: este documento se refere a uma versão obsoleta do UiPath Activity Criador para Visual Studio. Consulte a nova documentação aqui.

Introdução

Cada atividade começa com um arquivo da classe Activity que define suas entradas, saídas e lógica de execução. Para entender melhor como isso é feito, abra o arquivo ChildrenActivity.cs no seu projeto de Atividade e navegue por ele seção por seção. Esta é uma atividade simples que adiciona dois números e gera a soma deles.

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
    }
}

Importações e Namespaces

O arquivo começa com um boilerplate padrão. Ele importa alguns namespaces e depois declara que essa atividade existirá no namespace 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
{

Definição de classe

Todas as classes de atividade padrão (como a ChildrenActivity de amostra) estendem AsyncTaskCodeActivity, que fornece métodos para a validação de tempo de design de propriedades e lógica de execução em tempo de execução, e pode ser encontrada na Pasta compartilhada incluída em sua solução. Além disso, todas as atividades que estendem AsyncTaskCodeActivity podem ser executadas de forma assíncrona, permitindo que sejam usadas com as atividades Parallel e Parallel For Each no UiPath Studio.

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

Acima da definição da classe ChildrenActivity, você observará dois atributos: LocalizedDisplayName e LocalizedDescription. Elas permitem que você defina o nome e a descrição da dica de ferramenta da atividade que é exibida no painel de atividades do UiPath Studio. Neste exemplo, os atributos fazem referência a versões localizadas de cada um (por exemplo, Resources.ChildActivityDisplayName), mas strings simples também podem ser usadas. Para obter mais informações sobre localização, consulte aqui.

Propriedades

Em seguida, estão as propriedades da atividade, que aparecem no Painel de Propriedades do UiPath Studio. Cada propriedade tem um nome de exibição e uma descrição como a da atividade de nível superior, mas também está incluído um atributo de Categoria para ajudar as atividades relacionadas ao grupo. Observe como FirstNumber e SecondNumber aparecem na categoria Entrada, mas Sum aparece em Saída.

[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; }

As propriedades podem ser declaradas como do tipo InArgument, InOutArgument ou OutArgument , e devem indicar seu tipo esperado (por exemplo, string, int, ...).

Construtor

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

O construtor é usado para definir valores e restrições padrão das propriedades.

• No exemplo acima, a propriedade FirstNumber recebe um valor padrão de 10, que aparece no painel de propriedades.
  
  

  

  
  

• Além disso, é colocada uma restrição na própria atividade, exigindo que ela esteja envolvida por um ParentScope. Caso contrário, um erro de validação será exibido.

  
  

  

  
  

CacheMetadata

O CacheMetadata fornece a validação das propriedades, delegados e/ou atividades filho de uma atividade. Neste exemplo, verificamos se os valores foram fornecidos para as duas propriedades de entrada, FirstNumber e SecondNumber, e geramos um erro de validação se algum deles não for fornecido. O fluxo de trabalho não será executado até que os erros de validação sejam tratados.

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

ExecuteAsync é onde a lógica de execução da atividade é mantida.

• As primeiras duas linhas do método consultam o contexto da atividade, ou o estado atual da ChildrenActivity e os elementos ao seu redor, para recuperar um objeto Application do ParentScope, caso haja algum ao redor dele. Observe que, devido à restrição adicionada no construtor acima, esta atividade nunca terá permissão para ser executada se já não estiver em um ParentScope.
• As próximas linhas usam os valores atuais das propriedades FirstNumber e SecondNumber e os salvam em variáveis locais.
• As últimas linhas executam uma operação de soma nos números inseridos e definem a propriedade Sum com esse valor. Como Sum é uma propriedade de saída, esse valor pode ser usado por atividades subsequentes no fluxo de trabalho.

  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);
      };
  }

  Importante:

  Observe que o método ExecuteAsync retorna um objeto Task<Action<AsyncCodeActivityContext>> .

  Uma Task é retornada para que essa atividade possa ser executada de forma assíncrona.

  Uma Action é retornada dentro desta Tarefa para permitir que funções complexas sejam executadas após a conclusão de qualquer operação assíncrona. No exemplo acima, essa função simplesmente define o valor de Sum.

  Por fim, o Action recebe um parâmetro AsyncCodeActivityContext para que o contexto dessa atividade possa ser usado por qualquer uma dessas funções em execução após a conclusão das operações assíncronas. Se não for esse o caso, o contexto poderá ser perdido e o Sum não poderá ser facilmente modificado.