Schreiben des Aktivitätscodes

Um zu veranschaulichen, wie Aktivitätscode geschrieben wird, erstellen wir eine einfache Rechneraktivität neu, die in der Beispiellösung UiPath.Examples.Activities enthalten ist, die Sie von GitHub herunterladen können. Diese Aktivität verwendet zwei Zahlen und einen Vorgang (Addieren, Subtrahieren, Multiplizieren oder Dividieren) als Eingabe und gibt das Ergebnis des ausgewählten Vorgangs zurück.

Der Aktivitätscode besteht aus zwei Teilen – der Aktivitätslogik und dem Aktivitätsdesign.

Aktivitätslogik

Ausgehend von UiPath.Activities.Template benennen wir die Lösung und alle zugehörigen Dateien und Verweise in UiPath.Examples.Activities um.

1. Benennen Sie die Datei, die die Aktivitätslogik enthält, von ActivityTemplate.cs in Activator.cs um.

2. Passen Sie die Referenzen und den Namespace wie folgt an:

   using System.Activities;
   using System.Diagnostics;
   using UiPath.Examples.Activities.Helpers;
   
   namespace UiPath.Examples.Activities
   {
   }

3. Deklarieren Sie die Eingabeargumente – zwei Zahlen (FirstNumber und SecondNumber als int) und die auszuführende Operation (SelectedOperation als enum, wobei ein optionaler Standardwert auf Multiply festgelegt ist). Markieren Sie alle drei Argumente mit dem Attribut [RequiredArgument] als erforderlich. Der zurückgegebene Wert wird verwendet, um den Wert des Ergebnisarguments festzulegen.

   public class Calculator : CodeActivity<int> // This base class exposes an OutArgument named Result
       {
           [RequiredArgument]
           public InArgument<int> FirstNumber { get; set; } //InArgument allows a varriable to be set from the workflow
   
           [RequiredArgument]
           public InArgument<int> SecondNumber { get; set; }
   
           [RequiredArgument]
           public Operation SelectedOperation { get; set; } = Operation.Multiply; // default value is optional
   
           /*
            * The returned value will be used to set the value of the Result argument
            */
       }

4. Ab der Ausführung fügen wir die Protokollierung hinzu, rufen die Werte der Zahlen aus dem Workflow-Kontext ab und fügen eine Logik hinzu, um das Szenario einer Teilung durch Null zu behandeln.

   protected override int Execute(CodeActivityContext context)
           {
               // This is how you can log messages from your activity. logs are sent to the Robot which will forward them to Orchestrator
               context.GetExecutorRuntime().LogMessage(new Robot.Activities.Api.LogMessage()
               {
                   EventType = TraceEventType.Information,
                   Message = "Executing Calculator activity"
               });
   
               var firstNumber = FirstNumber.Get(context); //get the value from the workflow context (remember, this can be a variable)
               var secondNumber = SecondNumber.Get(context);
   
               if (secondNumber == 0 && SelectedOperation == Operation.Divide)
               {
                   throw new DivideByZeroException("Second number should not be zero when the selected operation is divide");
               }
   
               return ExecuteInternal(firstNumber, secondNumber);
           }

5. Fügen Sie die Berechnungen hinzu, die für jeden ausgewählten Vorgang ausgeführt werden sollen.

   public int ExecuteInternal(int firstNumber, int secondNumber)
           {
               return SelectedOperation switch
               {
                   Operation.Add => firstNumber + secondNumber,
                   Operation.Subtract => firstNumber - secondNumber,
                   Operation.Multiply => firstNumber * secondNumber,
                   Operation.Divide => firstNumber / secondNumber,
                   _ => throw new NotSupportedException("Operation not supported"),
               };
           }

6. Definieren Sie die Vorgänge.

   public enum Operation
       {
           Add,
           Subtract,
           Multiply,
           Divide
       }

Aktivitätsdesign

Die in einer Aktivität verfügbaren Eingaben werden durch die Datentypen der Eigenschaften bestimmt. In der Beispielaktivität „Rechner“ führt der Datentyp int der Eigenschaften FirstNumber und SecondNumber zu einem Zahlen-Editor als Eingabefeld für die Eigenschaften, während Operation mit dem Datentyp enum In der Aktivität ist ein Dropdownmenü verfügbar.

Die Beschriftungen und QuickInfos der Eigenschaften können in der Datei Resources.resx definiert werden.

In der folgenden Tabelle werden die gängigsten Eigenschaften beschrieben, die für jede Aktivitätseigenschaft verfügbar sind.

Eigenschaften	Beschreibung
DisplayName	Das Label der Eigenschaft.
Tooltip	Der Text, der angezeigt werden soll, wenn der Mauszeiger auf die Eigenschaft zeigt
IsRequired1	Ob die Eigenschaft erforderlich ist. Erforderliche Eigenschaften müssen auch in der Aktivität mit dem Attribut [RequiredArgument] markiert sein.
Istprinzipal2	Ob die Eigenschaft immer in der Hauptkategorie der Aktivität sichtbar sein soll. Wenn false festgelegt ist, wird die Eigenschaft in einem Menü Erweiterte Optionen anzeigen angezeigt, das standardmäßig reduziert ist.
Auftragsindex	Die Reihenfolge, in der die Eigenschaft angezeigt werden soll.

¹ Nicht für Ausgabeeigenschaften verfügbar, die nie obligatorisch sind.

² Per Konvention werden Ausgabeeigenschaften am Ende der Aktivität unter erweiterten Optionen platziert.

Erstellen des Designs für die Aktivität Rechner

1. Benennen Sie die Datei ActivityTemplateViewModel.cs in ActivatorViewModel.cs um und fügen Sie den Code für die Aktivitätsbenutzeroberfläche hinzu.

2. Passen Sie die Referenzen und den Namespace wie folgt an:

   using System.Activities.DesignViewModels;
   using System.Diagnostics;
   
   namespace UiPath.Examples.Activities.ViewModels
   {
   }

3. Deklarieren Sie die Eingabeeigenschaften. Die Result-Eigenschaft stammt aus der Basisklasse der Aktivität. Die Namen und Typargumente müssen mit denen aus der Aktivität übereinstimmen.

   public class CalculatorViewModel : DesignPropertiesViewModel
       {
           /*
            * Properties names must match the names and generic type arguments of the properties in the activity
            * Use DesignInArgument for properties that accept a variable
            */
           public DesignInArgument<int> FirstNumber { get; set; }
           public DesignInArgument<int> SecondNumber { get; set; }
           /*
            * Use DesignProperty for properties that accept a constant value                
            */
           public DesignProperty<Operation> SelectedOperation { get; set; }
            /*
            * The result property comes from the activity's base class
            */
           public DesignOutArgument<int> Result { get; set; }
           
           public CalculatorViewModel(IDesignServices services) : base(services)
           {
           }
       }

4. Fügen Sie den Code für das Aktivitätsdesign hinzu. Optional können wir einen Haltepunkt zum Debuggen der ViewModel-Initialisierung hinzufügen, indem wir die Auskommentierung der Zeile aufheben, die Debugger.Break(); enthält. Wir initialisieren die Eigenschaften des ViewModels, fügen einen PersistValuesChangedDuringInit() -Aufruf hinzu, der obligatorisch ist, wenn Sie die Eigenschaftswerte während der Initialisierung ändern, und definieren die Eingabe- und Ausgabeeigenschaften der Aktivität.

   Der Code sollte wie folgt aussehen:

   protected override void InitializeModel()
           {
              //Debugger.Break(); 
               /*
                * The base call will initialize the properties of the view model with the values from the xaml or with the default values from the activity
                */
               base.InitializeModel();
   
               PersistValuesChangedDuringInit(); // just for heads-up here; it's a mandatory call only when you change the values of properties during initialization
   
               var orderIndex = 0;
   
               FirstNumber.DisplayName = Resources.Calculator_FirstNumber_DisplayName;
               FirstNumber.Tooltip = Resources.Calculator_FirstNumber_Tooltip;
               /*
                * Required fields will automatically raise validation errors when empty.
                * Unless you do custom validation, required activity properties should be marked as such both in the view model and in the activity:
                *   -> in the view model use the IsRequired property
                *   -> in the activity use the [RequiredArgument] attribute.
                */
               FirstNumber.IsRequired = true;
   
               FirstNumber.IsPrincipal = true; // specifies if it belongs to the main category (which cannot be collapsed)
               FirstNumber.OrderIndex = orderIndex++; // indicates the order in which the fields appear in the designer (i.e. the line number);
   
               SecondNumber.DisplayName = Resources.Calculator_SecondNumber_DisplayName;
               SecondNumber.Tooltip = Resources.Calculator_SecondNumber_Tooltip;
               SecondNumber.IsRequired = true;
               SecondNumber.IsPrincipal = true;
               SecondNumber.OrderIndex = orderIndex++;
   
               SelectedOperation.DisplayName = Resources.Calculator_SelectedOperation_DisplayName;
               SelectedOperation.Tooltip = Resources.Calculator_SelectedOperation_Tooltip;
               SelectedOperation.IsRequired = true;
               SelectedOperation.IsPrincipal = true;
               SelectedOperation.OrderIndex = orderIndex++;
   
               /*
                * Output properties are never mandatory.
                * By convention, they are not principal and they are placed at the end of the activity.
                */
               Result.DisplayName = Resources.Calculator_Result_DisplayName;
               Result.Tooltip = Resources.Calculator_Result_Tooltip;
               Result.OrderIndex = orderIndex;
           }

5. Fügen Sie die Zeichenfolgenwerte für die Beschriftungen und QuickInfos in der Datei Resources.resx wie in der folgenden Abbildung hinzu. Zu Lokalisierungszwecken müssen Sie spezifische Kommentare für den Aktivitätsnamen (Activity name) und die Aktivitätsbeschreibung (Activity description) verwenden. Für andere Zeichenfolgen wird das Hinzufügen von Kommentaren empfohlen, ist aber nicht obligatorisch.
   
   

   

   
   

In Studio führt die Konfiguration zu den folgenden Ergebnissen:

1 – Beschriftungen (Anzeigenamen) der drei Eingabeeigenschaften.

2 – QuickInfo für die Eigenschaft FirstNumber .