- Notas de Versão
- Visão geral
- Introdução
- Fornecedores do Marketplace
- Clientes do Marketplace
- Diretrizes de publicação
- Diretrizes de publicação para automações prontas para execução
- Segurança e Proteção de IP
- Outras listagens da UiPath
- Node-RED
- Configuração
- Teams
- Escopo do Microsoft Teams
- Criar Equipe
- Create Team from Group
- Obter equipe
- Obter equipes
- Canais
- Criar canal
- Excluir canal
- Obter canal
- Obter canais
- Canal de Atualização
- Chats
- Obter chat
- Obter chats
- Obter membros do chat
- Mensagens
- Get message
- Get Messages
- Obter respostas de mensagem
- Reply To Message
- Enviar mensagem
- Events
- Create Event
- Delete Event
- Obter evento
- Obter eventos
- Usuários
- Obter presença do usuário
- Como funciona
- Referências técnicas
- Introdução
- Sobre
- Configuração
- Referências técnicas
- Escopo do reconhecedor de formulário do Azure
- Atividades
- Analisar Formulário
- Analisar Formulário Assíncrono
- Obter resultado do formulário de análise
- Analisar Recebimento
- Analisar Recebimento Assíncrono
- Obter resultado de recibo de análise
- Analisar Layout
- Analisar Layout Assíncrono
- Obter resultado de layout de análise
- Treinar Modelo
- Obter modelos
- Obter chaves de modelo
- Obter informações do modelo
- Excluir modelo
- Conectores
- Como criar atividades
- Crie sua integração
O arquivo de atividades
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
}
}
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
}
}
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
{
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
{
AsyncTaskCodeActivity
, que fornece métodos para validação de tempo de design de propriedades e lógica de execução de runtime e pode ser encontrado na pasta compartilhada incluída em sua solução. Além disso, todas as atividades que estendem o 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
{
[LocalizedDisplayName(nameof(Resources.ChildActivityDisplayName))]
[LocalizedDescription(nameof(Resources.ChildActivityDescription))]
public class ChildActivity : AsyncTaskCodeActivity
{
LocalizedDisplayName
e LocalizedDescription
. Elas permitem que você defina o nome e a descrição da dica de ferramenta da atividade que aparece 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.
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; }
[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; }
InArgument
, InOutArgument
ou OutArgument
, e devem indicar seu tipo esperado (por exemplo, string, int, ...).
public ChildActivity()
{
FirstNumber = 10;
Constraints.Add(ActivityConstraints.HasParentType<ChildActivity, ParentScope>(Resources.ValidationMessage));
}
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.
FirstNumber
e SecondNumber
, e geramos um erro de validação se algum deles não for fornecido. Até que os erros de validação sejam tratados, o fluxo de trabalho não será executado.
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 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 é 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
eSecondNumber
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. ComoSum
é 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); }; }
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 objetoTask<Action<AsyncCodeActivityContext>>
.UmaTask
é retornada para que essa atividade possa ser executada de forma assíncrona.UmaAction
é 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 deSum
.Por fim, oAction
recebe um parâmetroAsyncCodeActivityContext
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 oSum
não poderá ser facilmente modificado.