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 quieres crear. Esta interfaz debe enumerar los métodos que pretendes 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 previamente. 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 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 ambas implementaciones y sus métodos de firma: * RegisterType- Cuando utilizas RegisterType, especificas el contenedor para crear una nueva copia o instancia de tu servicio cada vez que lo llames. RegisterType ofrece un plan a seguir, basándose en el cual crear un nuevo servicio cada vez. + TService: este es el tipo de interfaz de servicio que consumirá 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 valor es CodeServiceRegistrationType.Singleton de forma predeterminada. Establece la política de registro de servicio.

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

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.