Cómo crear un desencadenador personalizado

Los proyectos de automatización se benefician de desencadenadores, que supervisan la actividad de la máquina en busca de eventos específicos con el fin de desencadenar Actionsconcretas. Los desencadenadores se pueden configurar a través del marco de supervisión de eventos, pero también puedes crear otros personalizados, como se explica en esta guía.

Requisitos previos

Para crear un desencadenador personalizado, se requiere lo siguiente:

Microsoft Visual Studio
Microsoft .NET Framework v4.6.1 o superior

Creación y configuración del proyecto

Abra Microsoft Visual Studio y elija Crear un nuevo proyecto. Se mostrará la ventana de selección de proyecto.
Selecciona Biblioteca de clases (.NET Framework)y haz clic en Siguiente. Se mostrará la ventana Configura tu nuevo proyecto .
Proporciona un nombre de proyecto, ubicación, nombre de solución y marco. Asegúrese de seleccionar el marco .NET Framework 4.6.1 o superior. Cuando haya rellenado todos los campos, haga clic en Crear. Se crea el nuevo proyecto y se muestra la ventana del diseñador.
En el menú Herramientas , selecciona Opciones. Se mostrará la ventana Opciones .
Expanda la entrada del Administrador de paquetes NuGet y seleccione Orígenes del paquete.
Añade un nuevo origen de paquete y rellena el campo Nombre con Fuente oficial de UiPath y el campo Origen con https://pkgs.dev.azure.com/uipath/Public.Feeds/_packaging/UiPath-Official/nuget/v3/index.json. Haz clic en Aceptar para confirmar y guardar los cambios.
Haz clic en el menú Herramientas y, en la entrada del Administrador de paquetes NuGet, selecciona Administrar paquetes NuGet para la solución ... Se mostrará la pestaña NuGet - Soluciones .
Busque la referencia de UiPath.Platform y selecciónela. En el panel de la derecha, selecciona el proyecto para el que añadir la referencia y luego haz clic en Instalar. Asegúrese de marcar la casilla Incluir versión preliminar e instalar la referencia de UiPath.Platform v20.8 o superior.

Escribir el código de desencadenador

Once the references are added to the project, it's time to write the code, which should look something like this:

using System; 
using System.Activities; 
using System.Threading; 
using UiPath.Platform.Triggers; 
 
public class TimerTrigger : TriggerBase<TimerTriggerArgs> 
{ 
 //it is recommended to use Variable to store fields in order for  
 //activities like Parallel For Each to work correctly 
   private readonly Variable<Timer> _timer = new Variable<Timer>();   
  public InArgument<TimeSpan> Period { get; set; }    
protected override void CacheMetadata(NativeActivityMetadata metadata) 
    { 
        metadata.AddImplementationVariable(_timer); 
        base.CacheMetadata(metadata); 
    }     
  
//in this method you can subscribe to events. It is called when the trigger starts execution 
protected override void StartMonitor(NativeActivityContext context, Action<TimerTriggerArgs> sendTrigger) 
    { 
        var eventIndex = 0; 
        var period = Period.Get(context); 
        _timer.Set(context, new Timer(OnTick, state: null, dueTime: period, period: period)); 
        return;  
void OnTick(object state) => sendTrigger(new TimerTriggerArgs(eventIndex++));    
}     
 
   //this is used for cleanup. It is called when the trigger is Cancelled or Aborted 
   protected override void StopMonitor(ActivityContext context) => _timer.Get(context).Dispose(); 
} 
 
//Each trigger may declare a type that sub-classes TriggerArgs 
//that corresponds to the “args” item in Trigger Scope activity. If no extra info 
//needs to be passed along, TriggerArgs can be used directly 
public class TimerTriggerArgs : TriggerArgs 
{ 
    public int EventIndex { get; } 
 
    public TimerTriggerArgs(int eventIndex) => EventIndex = eventIndex; 
}using System; 
using System.Activities; 
using System.Threading; 
using UiPath.Platform.Triggers; 
 
public class TimerTrigger : TriggerBase<TimerTriggerArgs> 
{ 
 //it is recommended to use Variable to store fields in order for  
 //activities like Parallel For Each to work correctly 
   private readonly Variable<Timer> _timer = new Variable<Timer>();   
  public InArgument<TimeSpan> Period { get; set; }    
protected override void CacheMetadata(NativeActivityMetadata metadata) 
    { 
        metadata.AddImplementationVariable(_timer); 
        base.CacheMetadata(metadata); 
    }     
  
//in this method you can subscribe to events. It is called when the trigger starts execution 
protected override void StartMonitor(NativeActivityContext context, Action<TimerTriggerArgs> sendTrigger) 
    { 
        var eventIndex = 0; 
        var period = Period.Get(context); 
        _timer.Set(context, new Timer(OnTick, state: null, dueTime: period, period: period)); 
        return;  
void OnTick(object state) => sendTrigger(new TimerTriggerArgs(eventIndex++));    
}     
 
   //this is used for cleanup. It is called when the trigger is Cancelled or Aborted 
   protected override void StopMonitor(ActivityContext context) => _timer.Get(context).Dispose(); 
} 
 
//Each trigger may declare a type that sub-classes TriggerArgs 
//that corresponds to the “args” item in Trigger Scope activity. If no extra info 
//needs to be passed along, TriggerArgs can be used directly 
public class TimerTriggerArgs : TriggerArgs 
{ 
    public int EventIndex { get; } 
 
    public TimerTriggerArgs(int eventIndex) => EventIndex = eventIndex; 
}

El siguiente paso es implementar los métodos StartMonitor y StopMonitor . Esto se hace para dictar el comportamiento del desencadenador para monitorear eventos específicos.

Es importante tener en cuenta que si quieres proporcionar argumentos para expandir el uso del desencadenador en el controlador de eventos, debes añadir y configurar una clase <Custom>TriggerArgs en el diseñador.

El último paso es compilar la biblioteca y crear el paquete NuGet para usar en Studio. El nuevo desencadenador ahora se puede usar dentro de una actividad de ámbito de desencadenador.

En esta página