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 source du code 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 du code et implémentez les méthodes de l'interface créée précédemment.
   Cette classe doit hériter du même fichier source du 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éthode RegisterServices.
      En appelant 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 RegisterInstance au lieu de RegisterType. Vérifiez les différences suivantes entre les deux implémentations et leurs méthodes de signature respectives :

      • RegisterType : lorsque vous utilisez RegisterType, vous indiquez le conteneur pour créer une nouvelle copie ou instance de votre service chaque fois que vous l’appelez. RegisterType donne un modèle à suivre, basé sur lequel créer un nouveau service à chaque fois.
        • TService : il s’agit du type d’interface de service qui sera utilisé par le service. C’est 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 implémente l’interface TService. C’est la classe qui est créée lorsqu’un service de type TService est demandé.
        • registrationType : la valeur est définie par défaut sur CodeServiceRegistrationType.Singleton. Cela définit la stratégie d’enregistrement du service.

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

      • RegisterInstance : lorsque vous utilisez RegisterInstance, vous offrez au conteneur une instance prête à l’emploi de ce service, que vous avez déjà créée auparavant. Chaque fois que vous appelez le service, le conteneur renvoie ce service exact prédéfini. RegisterInstance renvoie une copie exacte du service que vous avez créé.
        • TServiceImplementation : il s’agit de l’instance prête à l’emploi d’une classe que vous avez déjà créée. Cette instance est renvoyée chaque fois qu’un service de ce type doit être résolu. Pour cet exemple, MySecondService.
        • serviceTypes : il s’agit d’un tableau des types sous lesquels l’instance sera disponible lors de l’appel.

        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.