The activity file

Wichtig:

This document refers to a deprecated version of the UiPath Activity Creator for Visual Studio. Please see the new documentation here.

Einführung

Every activity begins with an Activity class file that defines its inputs, outputs, and execution logic. To better understand how this is done, open the ChildActivity.cs file in your Activity project and walk through it section by section. This is a simple activity that adds two numbers together and outputs their sum.

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

Imports and namespace

The file starts with standard boilerplate. It imports some namespaces and then declares that this activity will itself live in the MyCompany.MyProduct.Activities namespace.

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
{

Class definition

All standard activity classes (such as the sample ChildActivity) extend AsyncTaskCodeActivity, which provides methods for design-time validation of properties and run-time execution logic, and can be found in the Shared folder included in your solution. Additionally, all activities that extend AsyncTaskCodeActivity may run asynchronously, allowing them to be used with the Parallel and Parallel For Each activities in UiPath Studio.

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

Above the ChildActivity class definition, you'll notice two attributes--LocalizedDisplayName and LocalizedDescription. These allow you to set the name and tooltip description of the activity that appear in UiPath Studio's activities pane. In this example, the attributes reference localized versions of each (e.g. Resources.ChildActivityDisplayName), but simple strings may be used as well. For more information on localization, see here.

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 provides validation of an activity's properties, delegates, and/or child activities. In this example, we check that values have been provided for the two input properties, FirstNumber and SecondNumber, and throw a validation error if either is not provided. Until the validation errors are handled, a workflow will not run.

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:

  Notice that the ExecuteAsync method returns a Task<Action<AsyncCodeActivityContext>> object. A Task is returned so this activity can run asynchronously. An Action is returned within this Task in order to allow for complex functions to be executed after any asynchronous operations have completed. In the example above, this function simply sets the value of Sum. Lastly, the Action takes an AsyncCodeActivityContext parameter so the context from this activity may be used by any such functions running after the asynchronous operations have finished. If this was not the case, the context could be lost and the Sum would not be easily modifiable.