Die Aktivitätsdatei

Wichtig: Dieses Dokument bezieht sich auf eine veraltete Version von UiPath Activity Creator für Visual Studio. Die neue Dokumentation finden Sie hier.

Einführung

Jede Aktivität beginnt mit einer Aktivitätsklassendatei, die ihre Eingaben, Ausgaben und Ausführungslogik definiert. Um dies besser zu verstehen, öffnen Sie die Datei „ ChildActivity.cs “ in Ihrem Aktivitätsprojekt und gehen Sie sie Abschnitt für Abschnitt durch. Dies ist eine einfache Aktivität, die zwei Zahlen addiert und ihre Summe ausgibt.

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

Importe und Namespace

Die Datei beginnt mit einem Standard-Textbaustein. Sie importiert einige Namespaces und deklariert dann, dass diese Aktivität selbst im Namespace MyCompany.MyProduct.Activities sein wird.

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
{

Klassendefinition

Alle Standardaktivitätsklassen (z. B. die BeispielaktivitätChildActivity) erweitern AsyncTaskCodeActivity, der Methoden für die Validierung von Eigenschaften und Ausführungszeit zur Laufzeit zur Verfügung stellt. Sie finden sie im Ordner Freigegeben in Ihrer Lösung. Darüber hinaus können alle Aktivitäten, die AsyncTaskCodeActivity erweitern, asynchron ausgeführt werden, sodass sie mit den Aktivitäten „ Parallel “ und „ Parallel For Each “ in UiPath Studio verwendet werden können.

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

Über der Definition der Klasse „ChildActivity“ sehen Sie zwei Attribute –LocalizedDisplayName und LocalizedDescription. Damit können Sie den Namen und die QuickInfo-Beschreibung der Aktivität festlegen, die im Aktivitätenbereich von UiPath Studio angezeigt wird. In diesem Beispiel verweisen die Attribute auf lokalisierte Versionen jeder (z. B. Resources.ChildActivityDisplayName), aber es können auch einfache Strings verwendet werden. Weitere Informationen zur Lokalisierung finden Sie hier.

Eigenschaften

Als Nächstes werden die Eigenschaften der Aktivität im Eigenschaftenbereich von UiPath Studio angezeigt. Jede Eigenschaft hat einen Anzeigenamen und eine Beschreibung wie die Aktivität der obersten Ebene, aber auch enthalten ist ein Kategorie-Attribut, um die Gruppierung verwandter Aktivitäten zu erleichtern. Beachten Sie, wie FirstNumber und SecondNumber in der Kategorie Eingabe angezeigt werden, aber Sum unter Ausgabe angezeigt wird.

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

Eigenschaften können als Typ InArgument, InOutArgument oder OutArgument deklariert werden und müssen den erwarteten Typ angeben (z. B string, int, ...).

Konstruktor

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

Der Konstruktor wird verwendet, um Standardwerte und Einschränkungen für Eigenschaften festzulegen.

• Im obigen Beispiel erhält die Eigenschaft FirstNumber den Standardwert 10, der im Eigenschaftenbereich angezeigt wird.
  
  

  

  
  

• Darüber hinaus wird für die Aktivität selbst eine Einschränkung auferlegt, die erfordert, dass sie von einem ParentScope umgeben ist. Ist dies nicht der Fall, wird ein Validierungsfehler angezeigt.

  
  

  

  
  

CacheMetadata

CacheMetadaten bietet eine Validierung der Eigenschaften, Stellvertreter und/oder untergeordneten Aktivitäten einer Aktivität. In diesem Beispiel überprüfen wir, ob Werte für die beiden Eingabeeigenschaften FirstNumber und SecondNumber angegeben wurden, und geben einen Validierungsfehler aus, wenn keine der beiden Eingabeeigenschaften angegeben wird. Ein Workflow wird erst ausgeführt, wenn die Validierungsfehler behandelt wurden.

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

Mit „ExecuteAsync“ wird die Ausführungslogik der Aktivität gespeichert.

• Die ersten beiden Zeilen der Methode fragen den Aktivitätskontext – oder den aktuellen Status der untergeordneten Aktivität und der sie umgebenden Elemente – ab, um ein Application -Objekt aus dem ParentScope abzurufen, wenn es eines umschließt. Beachten Sie, dass diese Aktivität aufgrund der Einschränkung, die im obigen Konstruktor hinzugefügt wurde, nie ausgeführt werden darf, wenn sie sich nicht bereits in einem ParentScope befindet.
• Die nächsten Zeilen speichern die aktuellen Werte der Eigenschaften FirstNumber und SecondNumber in lokalen Variablen.
• Die letzten Zeilen führen eine Sum-Operation für die eingegebenen Zahlen durch und legen die Eigenschaft Sum auf diesen Wert fest. Da Sum eine Ausgabeeigenschaft ist, kann dieser Wert dann von nachfolgenden Aktivitäten im Workflow verwendet werden.

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

  Wichtig:

  Beachten Sie, dass die ExecuteAsync-Methode ein Task<Action<AsyncCodeActivityContext>> -Objekt zurückgibt.

  Eine Task wird zurückgegeben, damit diese Aktivität asynchron ausgeführt werden kann.

  Ein Action wird in dieser Aufgabe zurückgegeben, damit komplexe Funktionen ausgeführt werden können, nachdem asynchrone Vorgänge abgeschlossen wurden. Im obigen Beispiel legt diese Funktion einfach den Wert von Sum.

  Action schließlich akzeptiert einen AsyncCodeActivityContext -Parameter, sodass der Kontext aus dieser Aktivität von solchen Funktionen verwendet werden kann, die nach Abschluss der asynchronen Vorgänge ausgeführt werden. Wenn dies nicht der Fall ist, könnte der Kontext verloren gehen und Sum nicht einfach geändert werden.