Registro de serviços personalizados

Para melhorar suas automações codificadas, considere registrar serviços personalizados. Ao registrar um serviço personalizado, você pode usá-lo globalmente em seu projeto. Dessa forma, ele é acessível não apenas em uma única automação codificada, mas em todas as automações codificadas dentro de seu projeto.

1. Crie um arquivo de código-fonte e defina uma interface pública nomeada como o serviço que você deseja criar.Essa interface deve listar os métodos que você pretende usar com seu serviço personalizado. Cada método deve ser implementado em uma classe separada que herda o mesmo arquivo onde você está definindo a interface.

Para este exemplo, nomeie a interface como e IMyServicechame o método dentro dela DoMyMethod.

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

2. Prossiga para outro arquivo de código-fonte e implemente os métodos da interface criada anteriormente.Essa classe deve herdar do mesmo arquivo de código-fonte em que a interface pública foi criada.

Neste exemplo, implemente o DoMyMethodmétodo para gerar o valor de uma variável.

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

3. Crie uma classe parcial para encapsular seu serviço personalizado, tornando-o acessível a partir de qualquer fluxo de trabalho codificado que herde essa classe.
   1. Crie outro arquivo de código-fonte e declare a classe parcial pública chamada Coded Workflow. Faça essa classe herdar classe CodedWorkflowBase.
   2. Crie uma propriedade get-only para o serviço personalizado que você criou, que permite acesso a uma instância da interface de serviço.

A instância é obtida por meio de injeção de dependência usando o serviceContainer.Resolve<IMyService>()método .Isso fornece uma maneira de interagir com o serviço personalizado dentro da classe parcial.

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

3. Expandir ainda mais sua classe adicionando o métodoRegisterServices. Ao invocar esse método, você registra seu serviço personalizado dentro do contêiner de serviço da UiPath.

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

Você também pode usar RegisterInstance em vez de RegisterType. Verifique as seguintes diferenças entre as duas implementações e seus métodos de assinatura: * RegisterType - Quando você usa RegisterType, você especifica o contêiner para criar uma nova cópia ou instância do seu serviço cada vez que você o chama.RegisterType oferece um plano a ser seguido, com base no qual criar um novo serviço de cada vez. + TService: este é o tipo de interface de serviço que será consumido pelo serviço. É a interface que você cria para seu serviço. Para este exemplo, é IMyService. + TServiceImplementation: esta é a classe que implementa a interface TService.É a classe que é criada quando um serviço do tipo TService é solicitado.+ registrationType: esse padrão é CodeServiceRegistrationType.Singleton. Ele define a política de registro de serviço.

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

O fragmento de código abaixo mostra um exemplo de como a classe parcial pública foi implementada:

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óximas Etapas

Para usar o serviço personalizado que você criou, faça referência ao namespace desse serviço dentro do arquivo em que você está trabalhando, empregando a instrução using. O namespace do serviço personalizado representa o nome do projeto e o nome das pastas/subpastas nas quais o arquivo .cs pode estar. O formato do namespace é o seguinte: <ProjectName>.<Folder>.<SubFolder>

Por exemplo, se você criar um serviço personalizado dentro de um projeto chamado GeneralCustomServices, dentro da pasta MyCustomService, o namespace desse serviço será: GeneralCustomServices.MyCustomService.