Abonnieren

UiPath Developer

The UiPath Developer Guide

Erstellen von Workflow-Analyseregeln

Die Workflow-Analyse ist ein Tool, mit dem Sie sicherstellen können, dass Ihr Projekt den Anforderungen an Best Practices, Wartbarkeit, Lesbarkeit, Leistung, Wiederverwendbarkeit, ZuverlÀssigkeit und Sicherheit entspricht.

Diese Konzepte sind wichtig fĂŒr die GewĂ€hrleistung sauberer und zuverlĂ€ssiger Workflows, die große Automatisierungsprojekte zusammenfassen können.

📘

Hinweis:

Zum Erstellen benutzerdefinierter Regeln benötigen Sie das Paket UiPath.Activities.Api aus dem Feed Official. Das SDK-Paket muss als EntwicklungsabhĂ€ngigkeit in Ihrem benutzerdefinierten Projekt verwendet werden. Lesen Sie mehr ĂŒber EntwicklungsabhĂ€ngigkeiten.

Watch the video below to get step-by-step instructions on how to build custom rules, and how to create custom activities with the Activity Creator extension.

In ihrer Standardform ist die Workflow-Analyse in Studio integriert und umfasst Validierungs- und Analysefunktionen. Die Analyse kann nicht durchgefĂŒhrt werden, wenn die Validierung Fehler zurĂŒckgibt.

Konzepte der Workflow-Analyse

FĂŒr die Erstellung benutzerdefinierter Regeln fĂŒr Ihr Projekt sollten eine Reihe von Konzepten definiert werden, um besser zu verstehen, wie die Workflow-Analyse hinter den Kulissen funktioniert.

📘

Hinweis:

When building custom rules, target the .NET version depending on the version of Studio and the project compatibility:

  • Studio 2021.4 and earlier: .NET Framework 4.6.1.
  • Studio 2021.10.6 and later: .NET Framework 4.6.1 for Windows-legacy projects, .NET 6 for Windows and cross-platform projects.

Regeln und ZĂ€hler

Die Workflow-Analyse nutzt bestimmte Kriterien, um die ZuverlĂ€ssigkeit des Projekts zu gewĂ€hrleisten. Diese PrĂŒfungen werden mit sorgfĂ€ltig definierten Regeln und ZĂ€hlern durchgefĂŒhrt.

Eine Regel stellt eine Anforderung dar, die erfĂŒllt werden muss. Sie kann fĂŒr ÜberprĂŒfung des PrĂŒfobjekts anhand der Regeldefinition konfiguriert werden.

Ein ZĂ€hler stellt eine ÜberprĂŒfung dar, die durchgefĂŒhrt wird, um die Anzahl der Male zu ermitteln, die ein bestimmtes Ereignis oder eine bestimmte Bedingung aufgetreten ist.

FĂŒr jede nicht erfĂŒllte Regel wird im Panel „Fehlerliste“ eine Meldung vom Typ „Warnung“, „Fehler“, „Info“ oder „AusfĂŒhrlich“ angezeigt. Diese Auflistungen enthalten auch Empfehlungen fĂŒr Änderungen und die Sicherstellung der Einhaltung von Regeln.

📘

Hinweis:

When creating custom rules and counters, we recommend following the naming convention detailed in the About Workflow Analyzer page.

PrĂŒfobjekt

Die Workflow-Analyse ist in der Lage, eine eingehende Analyse eines vordefinierten Objekts durchzufĂŒhren. Das Objekt stellt den zu analysierenden Scope dar, den Bereich, in dem die Regel oder der ZĂ€hler durchgesetzt wird.

Erstellen von Regeln

Installieren Sie ĂŒber den Feed Official (https://pkgs.dev.azure.com/uipath/Public.Feeds/_packaging/UiPath-Official/nuget/v3/index.json) das Paket UiPath.Activities.Api.

To help you create a custom rule, let's look at a current predefined rule in the Workflow Analyzer, Variable Length Exceeded. This rule checks whether the length of variables defined in the project is smaller than 20 characters. The rule's inspection object is activity.

Hinter den Kulissen sieht die Regel so aus:

// This static class is not mandatory. It just helps organizining the code.
internal static class VariableLengthRule
    {
  // This should be as unique as possible, and should follow the naming convention.
        private const string RuleId = "ST-NMG-008";

        internal static Rule<IActivityModel> Get()
        {
            var rule = new Rule<IActivityModel>("Variable Length Rule", RuleId, Inspect)
            {
                RecommendationMessage = Recommendation,
              /// Off and Verbose are not supported.
                ErrorLevel = System.Diagnostics.TraceLevel.Warning
            };
            return rule;
        }
  
            // This is the function that executes for each activity in all the files. Might impact performance.
        // The rule instance is the rule provided above which also contains the user-configured data.
                 private static InspectionResult Inspect(IActivityModel activityModel, Rule ruleInstance)
        {
            var messageList = new List<string>();
            foreach(var activityModelVariable in activityModel.Variables)
            {
                if (activityModelVariable.DisplayName.Length > 20)
                {
                    messageList.Add($"The variable {activityModelVariable.DisplayName} has a length longer than 20");
                }
            }

            if (messageList.Count > 0)
            {
                return new InspectionResult()
                {
                    ErrorLevel = ruleInstance.ErrorLevel,
                    HasErrors = true,
                    RecommendationMessage = ruleInstance.RecommendationMessage,
                  // When inspecting a model, a rule can generate more than one message.
                    Messages = messageList
                };
            }
            else
            {
                return new InspectionResult() { HasErrors = false };
            }
        }
    }

The RuleId parameter requires the name of your rule. In this example, the Variable Length Exceeded rule carries the ST-NMG-008 rule ID and follows the Rule Naming Convention. Please note that the naming convention used by the rules available by default in Studio is not mandatory.

Der Parameter RecommendationMessage erfordert die Anzeige einer Meldung als Empfehlung, die dem Benutzer nach der Analyse bei der Lösung der gefundenen Inkonsistenzen hilft. Die Meldung sollte prÀgnant sein und eindeutige Schritte enthalten.

Der Parameter ErrorLevel gibt die Standardaktion fĂŒr den Fall an, dass die Bedingung nicht erfĂŒllt ist. In diesem Beispiel gibt die Regel eine Warnung aus. Standardaktionen können „Fehler“, „Warnung“, „Info“ oder „AusfĂŒhrlich“ sein.

Erstellen von Regeln mit Parametern

The situation changes slightly when we want to build rules that contain customizable parameters. One of such rules is Variables Naming Convention. Its inspection element is activity and carries a default Regex expression, which can be changed.

Hinter den Kulissen sieht diese Regel so aus:

internal static class VariableNamingRule
    {
        private const string RuleId = "ST-NMG-001";
        private const string RegexKey = "Regex";
        private const string DefaultRegex = @"^([A-Z]|[a-z])+([0-9])*$";

        internal static Rule<IActivityModel> Get()
        {
            var rule = new Rule<IActivityModel>(Strings.ST_NMG_001_Name, RuleId, Inspect)
            {
                RecommendationMessage = Recommendation,
                ErrorLevel = System.Diagnostics.TraceLevel.Warning
            };
            rule.Parameters.Add(RegexKey, new Parameter()
        }
                                
       private static InspectionResult Inspect(IActivityModel activityModel, Rule ruleInstance) 
        {
          // This retrieves the parameter value from the rule instance as configured by the user, if not, the default value.
            var setRegexValue = ruleInstance.Parameters[RegexKey]?.Value;
          
            var regex = new Regex(setRegexValue);
            var messageList = new List<string>();
            foreach (var activityModelVariable in activityModel.Variables)
            {
                if(!regex.IsMatch(activityModelVariable.DisplayName))
                {
                    messageList.Add(string.Format(Strings.ST_NMG_001_ErrorFormat, activityModelVariable.DisplayName, setRegexValue));
                }
            }

            if(messageList.Count > 0)
            {
                return new InspectionResult()
                {
                    ErrorLevel = ruleInstance.ErrorLevel,
                    HasErrors = true,
                    RecommendationMessage = ruleInstance.RecommendationMessage,
                    Messages = messageList
                };
            }
            else
            {
                return new InspectionResult() { HasErrors = false };
            }
        }
    }

Beachten Sie, dass sie RuleId, RegexKey und DefaultRegex aufruft, was der standardmĂ€ĂŸige regulĂ€re Ausdruck ist, der dieser Regel zugeordnet ist.

Die Parameter RecommendationMessage und ErrorLevel sind die gleichen wie bei der zuvor vorgestellten Regel.

Erstellen von ZĂ€hlern

ZĂ€hler stellen ÜberprĂŒfungen dar, die durchgefĂŒhrt werden, um die Anzahl der Male zu ermitteln, die ein bestimmtes Ereignis oder eine bestimmte Bedingung aufgetreten ist.

Ihre Struktur ist insofern etwas anders als die von Regeln, als der einzige verfĂŒgbare ErrorLevel-Parameter fĂŒr ZĂ€hler Info ist. Daher sollte der Ausdruck zur Definition der Fehlerstufe fĂŒr einen ZĂ€hler wie folgt aussehen: ErrorLevel = System.Diagnostics.TraceLevel.Info.

Let's take File Activities Stats as an example of how counter rules look behind the scenes:

internal static class NumberOfActivitiesInFile
    {
        private const string RuleId = "ST-ANA-009";

        internal static Counter<IActivityModel> Get()
        {
            return new Counter<IActivityModel>(Strings.ST_ANA_009_Name, RuleId, Inspect);
        }
  
  // A Counter<T> receives the entire collection of T objects in the parent structure. e.g. activities in workflow, workflows in project.
  private static InspectionResult Inspect(IReadOnlyCollection<IActivityModel> activities, Counter ruleInstance)
        {
            return new InspectionResult()
            {
              // For a counter, the error level is always info, even if not set here.
                ErrorLevel = System.Diagnostics.TraceLevel.Info,
              // For a counter, the Has Errors field is always ignored.
                HasErrors = false,
                Messages = new List<string>() { string.Format(Strings.ST_ANA_009_ErrorFormat,  activities.Count) }
            };
        }

Buildregeln fĂŒr StudioX

StandardmĂ€ĂŸig gelten Regeln nur fĂŒr das Studio-Profil. Um eine Regel auch im StudioX-Profil anzeigen zu lassen, fĂŒgen Sie die ApplicableScopes-Eigenschaft hinzu, und konfigurieren Sie sie so, dass sie BusinessRule enthĂ€lt. Sie können die Eigenschaft z. B. wie folgt hinzufĂŒgen:

var rule = new Rule<IActivityModel>(Strings.ORG_USG_001_Name, RuleId, Inspect)
            {
                RecommendationMessage = Strings.ORG_USG_001_Recommendation,
                ErrorLevel = TraceLevel.Error,
                //Must contain "BusinessRule" to appear in StudioX, rules always appear in Studio
                ApplicableScopes = new List<string> { RuleConstants.BusinessRule }
            };

Registrierung von Regeln

Methode der Registrierungsschnittstelle

Bitte beachten Sie, dass Ihr Paket auf diese Weise nur mit Studio-Versionen ab 2019.10 kompatibel ist.

Implementieren Sie die IRegisterAnalyzerConfiguration-Schnittstelle mit der folgenden Methode: Initialize(IAnalyzerConfigurationService workflowAnalyzerConfigService).

using UiPath.Studio.Activities.Api;
using UiPath.Studio.Activities.Api.Analyzer;
using UiPath.Studio.RulesLibrary.Rules.Naming;

namespace UiPath.Studio.RulesLibrary
{
    public class RegisterAnalyzerConfiguration : IRegisterAnalyzerConfiguration
    {
        public void Initialize(IAnalyzerConfigurationService workflowAnalyzerConfigService)
        {
            // Naming
            workflowAnalyzerConfigService.AddRule(VariableNamingRule.Get());
            workflowAnalyzerConfigService.AddRule(DisplayNameDuplicationRule.Get());
            workflowAnalyzerConfigService.AddRule(VariableNameDuplicationRule.Get());
            workflowAnalyzerConfigService.AddRule(ArgumentNamingRule.Get());
            workflowAnalyzerConfigService.AddRule(VariableLengthRule.Get());
        }
    }
}

📘

Hinweis:

Rufen Sie die HasFeature-Methode in IAnalyzerConfigurationService auf, um Regeln fĂŒr eine bestimmte Studio-Version zu registrieren.

IRegisterMetadata-Methode

Bitte beachten Sie, dass diese Methode nur fĂŒr Studio-Versionen ab 2019.6 zur VerfĂŒgung steht und nicht so geeignet ist wie die Methode der Registrierungsschnittstelle.

  • FĂŒgen Sie Ihrer Implementierung von IRegisterMetadata eine Methode vom Typ void Initialize(object api) hinzu.
  • In Ihrer Initialize-Implementierung ĂŒbergeben Sie den object-Parameter an WorkflowDesignApi, und fĂŒgen Sie alles unter einem Try Catch hinzu, nur um sicherzustellen, dass alle Ausnahmen verwaltet werden.
  • Sobald Sie die WorkflowDesignApi-API aufgelöst haben, ist WorkflowAnalyzerConfigService als Eigenschaft verfĂŒgbar.
  • An diesem Punkt haben Sie Zugriff auf den im Abschnitt oben beschriebenen IAnalyzerConfigurationService.

HinzufĂŒgen von Regeln zu Studio

Benutzerdefinierte Regeln fĂŒr die Workflow-Analyse können auf zwei Arten in Studio integriert werden:

  • auf globaler Ebene durch HinzufĂŒgen des externen Assemblys (.dll) im Studio-Installationsverzeichnis
  • auf Projektebene durch Installation des benutzerdefinierten AktivitĂ€tenpakets.

Auf globaler Ebene

Um benutzerdefinierte Regeln in allen Projekten verfĂŒgbar zu machen, die in Ihrer Instanz von Studio erstellt werden, mĂŒssen Sie die externen Assembly-Pakete (.dll) zu einem bestimmten Ordner hinzufĂŒgen, aus dem Studio benutzerdefinierte Regeln lĂ€dt. StandardmĂ€ĂŸig lautet der Ordnerpfad:

  • In Studio versions prior to 2021.10:
    • For per-machine installations: %ProgramFiles%\UiPath\Studio\Rules
    • For per-user installations: %LocalAppData%\Programs\UiPath\Studio\Rules
  • In Studio 2021.10.6 and later:
    • FĂŒr Installationen pro Maschine: %ProgramFiles%\UiPath\Studio\Rules\net6.0 (fĂŒr Regeln, die fĂŒr Windows- und plattformĂŒbergreifende Projekte bestimmt sind) und %ProgramFiles%\UiPath\Studio\net461\Rules (fĂŒr Regeln, die fĂŒr Windows-Legacy-Projekte bestimmt sind)
    • FĂŒr Installationen pro Benutzer: %LocalAppData%\Programs\UiPath\Studio\Rules\net6.0 (fĂŒr Regeln, die fĂŒr Windows- und plattformĂŒbergreifende Projekte bestimmt sind) und %LocalAppData%\Programs\UiPath\Studio\net461\Rules (fĂŒr Regeln, die fĂŒr Windows-Legacy-Projekte bestimmt sind)

Optionally, you can change the folder from which Studio loads custom rules by going to Home (Studio Backstage View) > Settings > Locations and defining a Custom Workflow Analyzer rules location. This feature is available in Studio v2020.10. and later.

Follow the steps detailed in the Creating a Custom Activity page to export the code as a .dll file.

Auf Projektebene

To make custom rules available only for a certain project, create a NuGet package (.nupkg) and install it in a Studio project as a dependency, as detailed here.

Aktualisiert vor 3 Monaten


Erstellen von Workflow-Analyseregeln


Auf API-Referenzseiten sind ÄnderungsvorschlĂ€ge beschrĂ€nkt

Sie können nur Änderungen an dem Textkörperinhalt von Markdown, aber nicht an der API-Spezifikation vorschlagen.