Registrieren von benutzerdefinierten Diensten

Um Ihre codierten Automatisierungen zu verbessern, sollten Sie benutzerdefinierte Dienste registrieren. Durch die Registrierung eines benutzerdefinierten Dienstes können Sie ihn global in Ihrem Projekt verwenden. So ist er nicht nur in einer einzelnen codierten Automatisierung, sondern in allen codierten Automatisierungen innerhalb Ihres Projekts zugänglich.

1. Erstellen Sie eine Code-Quelldatei und definieren Sie eine öffentliche Oberfläche mit dem Namen des Dienstes, den Sie erstellen möchten. In dieser Oberfläche sollten die Methoden aufgeführt sein, die Sie mit Ihrem benutzerdefinierten Dienst verwenden möchten. Jede Methode muss in eine separate Klasse implementiert werden, welche die gleiche Datei erbt, in der Sie die Schnittstelle definieren.

In diesem Beispiel benennen Sie die Schnittstelle IMyService und rufen Sie die darin enthaltene Methode DoMyMethod auf.

{
    public interface IMyService
    {
        void DoMyMethod();
    }
}

2. Gehen Sie zu einer anderen Code-Quelldatei und implementieren Sie die Methoden über die zuvor erstellte Oberfläche. Diese Klasse muss aus derselben Code-Quelle übernehmen, in der die öffentliche Oberfläche erstellt wurde.

In diesem Beispiel implementieren Sie die Methode DoMyMethod, um den Wert einer Variablen auszugeben.

public class MyService : IMyService
    {
        public void DoMyMethod()
        {
            var a = "hello world";
            Console.WriteLine(a);
        }
    }
}

3. Erstellen Sie eine partielle Klasse, um Ihren benutzerdefinierten Dienst zu umschließen, sodass er von jedem codierten Workflow aus zugänglich ist, der diese Klasse erbt.
   1. Erstellen Sie eine weitere Codequelldatei und deklarieren Sie die öffentliche partielle Klasse mit dem Namen Coded Workflow. Lassen Sie diese Klasse die Klasse CodedWorkflowBase erben.
   2. Erstellen Sie eine „get-only“-Eigenschaft (nur Abrufen) für Ihren erstellten benutzerdefinierten Dienst, die den Zugriff auf eine Instanz der Dienstschnittstelle ermöglicht.

Die Instanz wird per Abhängigkeitsinjektion mit der Methode serviceContainer.Resolve<IMyService>() abgerufen. Dies bietet eine Möglichkeit, mit dem benutzerdefinierten Dienst in der partiellen Klasse zu interagieren.

  ```
  public IMyService myService { get => serviceContainer.Resolve<IMyService>()};
  ```

3. Erweitern Sie Ihre Klasse weiter, indem Sie die RegisterServicesMethode hinzufügen. Durch das Aufrufen dieser Methode registrieren Sie Ihren benutzerdefinierten Dienst im UiPath-Dienstcontainer.

  ```
  protected override void RegisterServices(ICodedWorkflowsServiceLocator serviceLocator)
  		{
  			serviceLocator.RegisterType<IMyService, MyService>();
  		}
  ```

Sie können auch RegisterInstanceanstelle von RegisterType. Aktivieren Sie die folgenden Unterschiede zwischen den beiden Implementierungen und ihren Signaturmethoden: * RegisterType – Wenn Sie RegisterType, geben Sie den Container an, um bei jedem Aufruf eine neue Kopie oder Instanz Ihres Dienstes zu erstellen.RegisterType gibt eine Blaupause an, auf der jedes Mal ein neuer Dienst erstellt wird. + TService: Dies ist der Typ der Dienstoberfläche, der vom Dienst verwendet wird. Dies ist die Oberfläche, die Sie für Ihren Dienst erstellen. Für dieses Beispiel ist es IMyService. + TServiceImplementation: Dies ist die Klasse, die die TService Oberfläche implementiert. Es ist die Klasse, die erstellt wird, wenn ein Dienst vom Typ TServiceangefordert wird. + registrationType: Dies ist standardmäßig CodeServiceRegistrationType.Singleton. Es legt die Richtlinie für die Dienstregistrierung fest.

    ```
    void RegisterType<TService, TServiceImplementation>(CodeServiceRegistrationType registrationType = CodeServiceRegistrationType.Singleton)
                where TService : class
                where TServiceImplementation : class, TService;
    ```

  * `RegisterInstance` - When you use `RegisterInstance`, you offer the container a ready-made instance of that service, that you already created before. Every time you call the service, the container returns this exact pre-made service. `RegisterInstance` returns an exact copy of the service that you created.
    + `TServiceImplementation`: This is the ready-made instance of a class that you have already created. This instance is returned whenever a service of this type needs to be resolved. For this example, `MySecondService`.
    + `serviceTypes`: This is an array of types that the instance will be available as, when calling it.

    ```
    void RegisterInstance<TServiceImplementation>(TServiceImplementation instance, params Type[] serviceTypes) 
                where TServiceImplementation : class;
    ```

Das folgende Code-Snippet zeigt ein Beispiel dafür, wie die öffentliche partielle Klasse implementiert wurde:

public partial class CodedWorkflow : CodedWorkflowBase
    {
		public IMyService myService { get => serviceContainer.Resolve<IMyService>() ; }
		
		protected override void RegisterServices(ICodedWorkflowsServiceLocator serviceLocator)
		{
                    // Implementation using 'RegisterType'
			serviceLocator.RegisterType<IMyService, MyService>();
                    // Implementation using 'RegisterInstance'
                    var secondService = new MySecondService();
                    serviceLocator.RegisterInstance<MySecondService>(secondService);
		}

Nächste Schritte

Um den von Ihnen erstellten benutzerdefinierten Dienst zu verwenden, verweisen Sie auf den Namespace dieses Dienstes in der Datei, an der Sie arbeiten, indem Sie die Anweisung using verwenden. Der Namespace des benutzerdefinierten Dienstes stellt den Namen des Projekts und den Namen der Ordner/Unterordner dar, in denen sich die .cs-Datei möglicherweise befindet. Das Format des Namespace ist wie folgt: <ProjectName>.<Folder>.<SubFolder>

Wenn Sie beispielsweise einen benutzerdefinierten Dienst innerhalb eines Projekts namens GeneralCustomServices im Ordner MyCustomService erstellen, dann lautet der Namespace dieses Dienstes: GeneralCustomServices.MyCustomService.