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.

Esta classe deve herdar do mesmo arquivo de código-fonte onde 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. Expanda ainda mais sua classe adicionando o método RegisterServices.

Ao invocar esse método, você registra seu serviço personalizado no contêiner de serviço 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. 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 - Quando você usa RegisterInstance, você oferece ao contêiner uma instância pronta desse serviço, que você já criou antes. Toda vez que você chama o serviço, o contêiner retorna esse serviço pré-fabricado exato. RegisterInstance retorna uma cópia exata do serviço que você criou. + TServiceImplementation: esta é a instância pronta de uma classe que você já criou. Essa instância é retornada sempre que um serviço desse tipo precisa ser resolvido. Para este exemplo, MySecondService. + serviceTypes: esta é uma matriz de tipos com os quais a Instância estará disponível, quando chamada. 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.