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. das Beispiel-ChildActivity) erweitern AsyncTaskCodeActivity, das Methoden für die Entwurfszeitvalidierung von Eigenschaften und Laufzeitausführungslogik bereitstellt und die im Ordner „Freigegeben“ zu finden ist, der in Ihrer Lösung enthalten ist. Darüber hinaus können alle Aktivitäten, die AsyncTaskCodeActivity erweitern, asynchron ausgeführt werden, sodass sie mit den Aktivitäten Parallel und Parallel für jede /n in UiPath Studio verwendet werden können.

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

Über der Definition der untergeordneten Aktivität (ChildActivity) werden Sie zwei Attribute bemerken: LocalizedDisplayName und LocalizedDescription. Mit diesen können Sie den Namen und die Tooltip-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

CacheMetadata ermöglicht die Validierung der Eigenschaften, Delegaten und/oder untergeordneten Aktivitäten einer Aktivität. In diesem Beispiel überprüfen wir, ob für die beiden Eingabeeigenschaften FirstNumber und SecondNumber Werte angegeben wurden, und geben einen Validierungsfehler aus, wenn keine von beiden angegeben ist. Solange die Validierungsfehler nicht behandelt wurden, wird ein Workflow nicht ausgeführt.

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.