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 RegisterServicesmétodo .
      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 - Ao usar RegisterType, você especifica o contêiner para criar uma nova cópia ou instância do seu serviço cada vez que você o chamar. RegisterType dá um modelo a ser seguido, com base no qual criar um novo serviço a 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 - Ao usar 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.