Enregistrement de services personnalisés

Afin d’améliorer vos automatisations codées, vous pouvez enregistrer des services personnalisés. En enregistrant un service personnalisé, vous pourrez l’utiliser de façon globale dans votre projet. Il sera ainsi accessible non plus pour une seule automatisation codée, mais pour toutes les automatisations codées de votre projet.

1. Créez un fichier de code source et définissez une interface publique nommée comme le service que vous souhaitez créer. Cette interface doit répertorier les méthodes que vous avez l'intention d'utiliser avec votre service personnalisé.Chaque méthode doit être implémentée dans une classe distincte qui hérite du même fichier dans lequel vous définissez l'interface.

Pour cet exemple, nommez l'interface IMyService et nommez la méthode associée DoMyMethod.

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

2. Passez à un autre fichier source de code et implémentez les méthodes depuis l'interface précédemment créée. Cette classe doit hériter du même fichier source de code dans lequel l'interface publique a été créée.

Dans cet exemple, implémentez la méthode DoMyMethod pour générer la valeur d'une variable.

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

3. Créez une classe partielle pour encapsuler votre service personnalisé, le rendant ainsi accessible à partir de tout workflow codé qui hérite de cette classe.
   1. Créez un autre fichier source du code et déclarez la classe partielle publique nommée Coded Workflow. Faites en sorte que cette classe hérite de la classe CodedWorkflowBase.
   2. Créez une propriété à récupérer uniquement pour le service personnalisé que vous avez créé et qui permet d'accéder à une instance de l'interface de service.

L'instance est obtenue par l'injection de dépendances à l'aide de la méthode serviceContainer.Resolve<IMyService>(). Cela permet d'interagir avec le service personnalisé dans la classe partielle.

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

3. Développez davantage votre classe en ajoutant la méthodeRegisterServices. En invoquant cette méthode, vous enregistrez votre service personnalisé dans le conteneur de service UiPath.

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

Vous pouvez également utiliser RegisterInstanceau lieu de RegisterType. Vérifiez les différences suivantes entre les deux implémentations et leurs méthodes de signature : * RegisterType - Lorsque vous utilisez RegisterType, vous spécifiez le conteneur pour créer une nouvelle copie ou instance de votre service chaque fois que vous l'appelez. RegisterTypefournit un plan directeur à suivre en fonction duquel créer un nouveau service à chaque fois.+ TService: il s'agit du type d'interface de service qui sera consommé par le service. Il s'agit de l'interface que vous créez pour votre service. Dans cet exemple, il s'agit de IMyService. + TServiceImplementation: il s'agit de la classe qui met en œuvre l'interfaceTService. Il s'agit de la classe qui est créée lorsqu'un service de type TService est demandé.+ registrationType : cela est défini par défaut sur CodeServiceRegistrationType.Singleton. Il définit la politique d'enregistrement du service.

    ```
    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;
    ```

L'extrait de code ci-dessous montre un exemple d'implémentation de classe partielle publique :

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

Prochaines étapes

Pour utiliser le service personnalisé que vous avez créé, référencez l'espace de noms de ce service dans le fichier sur lequel vous travaillez, en utilisant l'instruction using. L'espace de noms du service personnalisé est constitué du nom du projet et du nom des dossiers/sous-dossiers dans lesquels le fichier .cs peut se trouver. Le format de l'espace de noms est le suivant : <ProjectName>.<Folder>.<SubFolder>

Par exemple, si vous créez un service personnalisé dans un projet nommé GeneralCustomServices, dans le dossier MyCustomService, l'espace de noms de ce service sera le suivant : GeneralCustomServices.MyCustomService.