studio
2024.10
true
Guia do usuário do Studio
Last updated 30 de out de 2024

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();
        }
    }{
        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);
            }
        }
    }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>()};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>();
      		}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;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;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);
    		}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.
  • Próximas Etapas

Esta página foi útil?

Obtenha a ajuda que você precisa
Aprendendo RPA - Cursos de automação
Fórum da comunidade da Uipath
Uipath Logo White
Confiança e segurança
© 2005-2024 UiPath. Todos os direitos reservados.