Registrar servicios personalizados

Para mejorar tus automatizaciones codificadas, considera registrar servicios personalizados. Al registrar un servicio personalizado, puedes utilizarlo globalmente en tu proyecto. De esta manera, es accesible no solo en una sola automatización codificada, sino en todas las automatizaciones codificadas dentro de tu proyecto.

1. Crea un archivo de código fuente y define una interfaz pública llamada como el servicio que deseas crear.
   Esta interfaz debe enumerar los métodos que piensas utilizar con tu servicio personalizado. Cada método debe implementarse en una clase independiente que herede el mismo archivo donde se define la interfaz.
   Para este ejemplo, nombra la interfaz como IMyService y llama al método que contiene DoMyMethod.

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

2. Continúa con otro archivo de código fuente e implementa los métodos desde la interfaz creada anteriormente.
   Esta clase debe heredar del mismo archivo de código fuente donde se creó la interfaz pública.
   En este ejemplo, implementa el método DoMyMethod para generar el valor de una variable.

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

3. Crea una clase parcial para envolver tu servicio personalizado, haciéndolo accesible desde cualquier flujo de trabajo codificado que herede esta clase.
   1. Crea otro archivo de código fuente y declara la clase parcial pública llamada Coded Workflow. Haz que esta clase herede la clase CodedWorkflowBase.
   2. Crea una propiedad de solo obtener para el servicio personalizado que creaste, que permita el acceso a una instancia de la interfaz de servicio.
      La instancia se obtiene a través de la inyección de dependencias utilizando el método serviceContainer.Resolve<IMyService>(). Esto proporciona una forma de interactuar con el servicio personalizado dentro de la clase parcial.

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

   3. Expande aún más tu clase añadiendo el método RegisterServices.
      Al invocar este método, registras tu servicio personalizado dentro del contenedor de servicio de UiPath.

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

      También puedes utilizar RegisterInstance en lugar de RegisterType. Comprueba las siguientes diferencias entre las dos implementaciones y sus métodos de firma:

      • RegisterType: al utilizar RegisterType, especificas el contenedor para crear una nueva copia o instancia de tu servicio cada vez que lo llames. RegisterType da un plan a seguir, en función del cual crear un nuevo servicio cada vez.
        • TService: este es el tipo de interfaz de servicio que será consumido por el servicio. Es la interfaz que creas para tu servicio. Para este ejemplo, es IMyService.
        • TServiceImplementation: esta es la clase que implementa la interfaz TService. Es la clase que se crea cuando se solicita un servicio de tipo TService.
        • registrationType: este es el valor predeterminado en CodeServiceRegistrationType.Singleton.Establece la política de registro de servicio.

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

      • RegisterInstance: al utilizar RegisterInstance, ofreces al contenedor una instancia lista para usar de ese servicio, que ya creaste antes. Cada vez que llamas al servicio, el contenedor devuelve este servicio prefabricado exacto. RegisterInstance devuelve una copia exacta del servicio que creaste.
        • TServiceImplementation: esta es la instancia lista para usar de una clase que ya has creado. Esta instancia se devuelve cada vez que se debe resolver un servicio de este tipo. Por ejemplo, MySecondService.
        • serviceTypes: esta es una matriz de tipos como la instancia estará disponible al llamarla.

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

   El siguiente fragmento de código muestra un ejemplo de cómo se implementó la clase parcial pública:

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

Próximos pasos

Para utilizar el servicio personalizado que has creado, haz referencia al espacio de nombres de ese servicio dentro del archivo en el que estás trabajando, utilizando la instrucción using. El espacio de nombres del servicio personalizado representa el nombre del proyecto y el nombre de las carpetas/subcarpetas en las que podría estar el archivo .cs. El formato del espacio de nombres es el siguiente: <ProjectName>.<Folder>.<SubFolder>

Por ejemplo, si creas un servicio personalizado dentro de un proyecto que se llama GeneralCustomServices, dentro de la carpeta MyCustomService, entonces el espacio de nombres de ese servicio es: GeneralCustomServices.MyCustomService.