Schreiben des Aktivitätscodes

Um das Schreiben von Aktivitätscode zu veranschaulichen, wird in diesem Beispiel eine einfache Rechneraktivität aus der Lösung UiPath.Examples.Activities auf GitHub neu erstellt. Die Aktivität:

• Nimmt zwei Zahlen und einen Vorgang (Addieren, Subtrahieren, Multiplizieren oder Dividieren) als Eingabe

• Gibt das Ergebnis des ausgewählten Vorgangs zurück

Der Aktivitätscode besteht aus zwei Teilen:

1. Die Aktivitätslogik

2. Das Aktivitätsdesign

Aktivitätslogik

Beginnen Sie bei UiPath.Activities.Template und benennen Sie die Lösung sowie 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 Calculator.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 den auszuführenden Vorgang (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 Result -Arguments 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. Starten Sie den Ausführungsteil, fügen Sie Protokollierung hinzu, rufen Sie die Werte der Zahlen aus dem Workflow-Kontext ab, und fügen Sie 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 verfügbaren Eingaben in einer Aktivität werden durch die Datentypen der Eigenschaften bestimmt. In der Beispielrechneraktivität:

• Der Datentyp int der Eigenschaften FirstNumber und SecondNumber führt zu Zahleneditor-Eingabefeldern für diese Eigenschaften.
• Für die Eigenschaft Operation mit dem Datentyp enum ist in der Aktivität ein Dropdown-Menü verfügbar.

Diese Datentypen beeinflussen direkt, wie Benutzer mit den Eingaben der Aktivität interagieren.

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

In der folgenden Tabelle sind 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 CalculatorViewModel.csum 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 Eigenschaft Ergebnis 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 den Aktivitätsentwurf hinzu. Optional können Sie zum Debuggen ViewModel -Initialisierung einen Haltepunkt hinzufügen, indem Sie die Zeile mit Debugger.Break(); auskommentieren.
   Das folgende Code-Snippet initialisiert die Eigenschaften von ViewModel, fügt einen PersistValuesChangedDuringInit() -Aufruf hinzu, der obligatorisch ist, wenn Sie die Eigenschaftswerte während der Initialisierung ändern, und definiert die Eingabe- und Ausgabeeigenschaften der Aktivität:

   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 Resources.resx -Datei hinzu. Für Lokalisierungszwecke müssen Sie bestimmte Kommentare für den Aktivitätsnamen (Activity name) und die Aktivitätsbeschreibung (Activity description) verwenden. Bei anderen Zeichenfolgen wird das Hinzufügen von Kommentaren empfohlen.
   
   

   

   
   

Die folgende Abbildung zeigt die Aktivitätskonfiguration, wie sie in UiPath Studio angezeigt wird:

1 – Beschriftungen (Anzeigenamen) der drei Eingabeeigenschaften.

2 – QuickInfo für die Eigenschaft FirstNumber .