Studio
2024.4
falso
Registro de serviços personalizados - Versão independente 2024.4
Imagem de fundo do banner
Logotipo
Guia do usuário do Studio - Visualização
Última atualização 22 de fev de 2024

Registro de serviços personalizados

Para aprimorar suas automações codificadas, você pode registrar serviços personalizados, o que equivale a criar pacotes de atividades personalizadas.
  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>();
      		}
      You can also use RegisterInstance instead of RegisterType. Check the following differences between the two implementations, and their signature methods:
      • RegisterType - When you use RegisterType, you specify the container to create a new copy or instance of your service each time you call it. RegisterType gives a blueprint to follow, based on which to build a new service each time.
        • TService: This is the service interface type that will be consumed by the service. It's the interface that you create for your service. For this example, it's IMyService.
        • TServiceImplementation: This is the class that implements the TService interface. It's the class that is created when a service of type TService is requested.
        • registrationType: This defaults to CodeServiceRegistrationType.Singleton. It sets the service registration policy.
        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 - 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;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
Ícone de suporte e serviços
Obtenha a ajuda que você precisa
Ícone do UiPath Academy
Aprendendo RPA - Cursos de automação
Ícone do Fórum do UiPath
Fórum da comunidade da Uipath
Logotipo branco da Uipath
Confiança e segurança
© 2005-2024 UiPath. All rights reserved.