Crie e execute funções locais em fluxos de trabalho padrão para Aplicativos Lógicos do Azure

Aplica-se a: Aplicativos Lógicos do Azure (Standard)

Quando seu fluxo de integração precisar de lógica além das operações embutidas e conectores pré-construídos, crie uma função local onde o código permaneça específico para sua solução de logic app. Essa função local é código .NET personalizado que você cria, executa, depura e implanta no mesmo projeto Aplicativos Lógicos do Azure Standard que os fluxos de trabalho do chamador. Ao manter a função local, você pode desenvolver, proteger, implantar, escalar e operar o fluxo de trabalho e seu código personalizado como um único aplicativo.

Funções locais ajudam seus fluxos de trabalho a executar tarefas como:

Implemente lógica de negócio e cálculos personalizados.
Analise mensagens proprietárias ou complexas de entrada.
Valide, enriqueça ou realize transformações simples nos dados.
Modele mensagens de saída para uma API, conector ou sistema parceiro.
Reutilize lógica auxiliar .NET adequada de soluções de integração existentes, incluindo cenários de migração do BizTalk Server.

Com funções locais, você pode alcançar os seguintes objetivos:

Meta	Capacidade
Desenvolver e depurar uma solução	Crie o fluxo de trabalho e a função local no mesmo espaço de trabalho do Visual Studio Code e percorra ambos em uma única sessão de depuração.
Implantar em conjunto	Construa e implante a função local junto com os fluxos de trabalho do chamador sem provisionar um plano de serviço separado.
Reduzir os limites de serviço	Evite usar um aplicativo de funções, um endpoint HTTP, um fluxo de autenticação e um salto de rede separados para código específico do fluxo de trabalho.
Combine ferramentas low-code e pro-code	Use conectores e orquestração de fluxo de trabalho no fluxo de integração. Use funções locais para lógica .NET especializada.

Uma função local difere de uma função hospedada em um aplicativo de funções separado no Azure Functions. Azure Functions funciona melhor quando seu código precisa expor um endpoint independente, ser compartilhado entre apps, seguir seu próprio ciclo de implantação e versionamento, ou escalar de forma independente. Quando seu código precisar funcionar dentro de uma solução específica do Aplicativos Lógicos do Azure Standard e compartilhar o ciclo de vida da aplicação com os fluxos de trabalho dos chamadores, use uma função local.

Este guia mostra como criar, construir, chamar, depurar e implantar funções .NET locais para fluxos de trabalho padrão usando o Visual Studio Code.

Observação

Funções locais não são adequadas para os seguintes cenários:

Executando processos que podem exceder 10 minutos.
Usando componentes de pipeline do BizTalk Server que implementam streaming.

Para obter mais informações, consulte Limitações.

Pré-requisitos

Uma conta Azure e uma assinatura. Get uma conta de Azure gratuita.
O Visual Studio Code mais recente com a extensão Aplicativos Lógicos do Azure (Standard).

Para pré-requisitos, consulte Criar fluxos de trabalho padrão em Aplicativos Lógicos do Azure de locatário único com o Visual Studio Code.

A extensão fornece os seguintes recursos e benefícios:
- Escreva seu próprio código criando funções que têm a flexibilidade e o controle para resolver seus problemas de integração mais desafiadores.
- Depurar código localmente em Visual Studio Code. Percorra seu código e fluxos de trabalho na mesma sessão de depuração.
- Implante o código junto com seus fluxos de trabalho. Não são necessários outros planos de serviço.
- Suporte a cenários de migração do BizTalk Server, permitindo migrar investimentos personalizados em .NET do ambiente local para a nuvem.
Uma pasta local a ser usada para seu projeto de código.

Limitações

Você só pode criar funções locais no Visual Studio Code rodando no Windows. Essa funcionalidade suporta o .NET Framework e o .NET 8 para fluxos de trabalho padrão hospedados no Workflow Service Plan, Ambiente do Serviço de Aplicativo v3 (ASE v3) ou Hybrid.
Você não pode usar funções personalizadas de criação no portal do Azure. No entanto, para trabalhar com saídas de funções personalizadas em seu fluxo de trabalho, siga estas etapas:
1. Depois de implantar suas funções no Azure, siga as etapas em Chamar seu código de um fluxo de trabalho no portal do Azure.
2. Adicione a ação interna chamada Chamar uma função local neste aplicativo lógico ao fluxo de trabalho. Selecione as funções personalizadas implantadas desejadas e execute seu código.
3. Use ações subsequentes do fluxo de trabalho para referenciar as saídas de funções personalizadas, assim como em qualquer outro fluxo de trabalho. Exiba o histórico de execução, as entradas e as saídas da ação interna.

Para obter limitações gerais, consulte Limits e referência de configuração para Aplicativos Lógicos do Azure.

1: Criar um projeto de código

A extensão Aplicativos Lógicos do Azure (Standard) para Visual Studio Code inclui um modelo de projeto de código que fornece uma experiência simplificada para escrever, depurar e implantar seu próprio código com seus fluxos de trabalho. Este modelo de projeto cria um arquivo de workspace e dois projetos de exemplo: um projeto para escrever seu código e outro projeto para criar seus fluxos de trabalho.

Observação

Você não pode usar a mesma pasta de projeto para seu código e fluxos de trabalho.

Para criar um projeto de código, siga estas etapas:

Em Visual Studio Code, faça login na sua conta do Azure.

Se a entrada demorar mais do que o normal, Visual Studio Code solicitará que você entre por meio de um site de autenticação Microsoft fornecendo um código de dispositivo. Para entrar usando o código em vez disso, siga estas etapas:
1. Selecione Usar Código do Dispositivo e, em seguida, selecione Copiar &Abrir.
2. Selecione Abrir Link para abrir uma nova janela do navegador e continuar para o site de autenticação.
3. Na página Entrar na sua conta, insira seu código de autenticação e selecione Avançar.
Na Barra de Atividades, selecione o ícone Azure.
Na janela Azure, vá para a seção Workspace. Mova o ponteiro sobre a área de título para que a barra de ferramentas seja exibida.
No menu do Aplicativos Lógicos do Azure, selecione Criar novo espaço de trabalho do aplicativo lógico.
Na janela Selecionar Pasta , navegue até a pasta do projeto local, selecione a pasta e selecione.
Na janela Criar novo espaço de trabalho do aplicativo lógico, no prompt Nome do workspace, insira um nome para seu espaço de trabalho e pressione Enter.

Este exemplo usa weather-app como o nome do workspace:
Para a solicitação de selecionar um modelo para o seu novo projeto, escolha App lógica com projeto de código personalizado.
Para o prompt Selecione uma estrutura de destino prompt, selecione .NET Framework ou .NET 8.

Siga as instruções subsequentes para fornecer as informações a seguir.

Rápido	Valor de exemplo
Nome do Aplicativo Lógico	`weather-logic-app`
Nome da função para o seu projeto de funções .NET	`WeatherForecast`
Namespace para seu projeto de funções .NET	`Contoso.Enterprise`
Selecione um modelo para o primeiro fluxo de trabalho do projeto: - Fluxo de trabalho com estado - Fluxo de trabalho sem estado - Agente autônomo - Agente de conversação - Ignorar por enquanto	Fluxo de trabalho com estado
Nome do fluxo de trabalho	`weather-workflow`

Para selecionar como você deseja abrir o prompt do projeto, selecione Abrir na janela atual.

Depois de concluir esta etapa, Visual Studio Code cria seu workspace, que inclui um projeto de funções .NET e um projeto de aplicativo lógico, por padrão, por exemplo:

Captura de tela que mostra o espaço de trabalho criado com o projeto do app Logic e o projeto de funções .NET.

Na janela Do Explorer , observe as seguintes pastas em seu workspace:

Pasta	Descrição
< nome do workspace>	Contém o projeto de funções .NET e o projeto de fluxo de trabalho do aplicativo lógico.
< nome do aplicativo lógico>	Contém os arquivos e outros artefatos para seu projeto de aplicativo lógico. Por exemplo, o arquivo workflow.json é o arquivo de definição de fluxo de trabalho no qual você pode criar seu fluxo de trabalho.
< nome da função>	Contém os arquivos e outros artefatos para seu projeto de funções .NET. Por exemplo, o arquivo <function-name* >.cs* é o arquivo de código no qual você pode criar seu código.

Para o prompt Habilitar conectores para Azure para Aplicativos Lógicos <logic-app-name>, selecione Usar conectores do Azure.
Para o prompt Select subscription, selecione a assinatura do Azure desejada.
Para o prompt Selecionar um grupo de recursos para novos recursos , selecione o grupo de recursos desejado ou Crie um novo grupo de recursos.
Para o Selecione um local para novos recursos prompt, selecione a região Azure para implantação.

Para o método de autenticação Select para conectores Azure, selecione o tipo de autenticação a ser usado para conexões que precisam de autenticação.

Tipo de autenticação	Descrição
Identidade gerenciada	Selecione Identidade de Serviço Gerenciada para usar a identidade atribuída pelo sistema ou atribuída pelo usuário no recurso do aplicativo lógico. Por padrão, os recursos do aplicativo lógico Standard já têm a identidade atribuída pelo sistema habilitada. No entanto, você precisa configurar a identidade com acesso à função no recurso de destino, além de quaisquer outros requisitos. Para obter mais informações, consulte Atribuir acesso baseado em função a uma identidade gerenciada.
Chaves de conexão	Configure o acesso ao recurso de destino usando cadeias de conexões e chaves de acesso.

Tipo de autenticação

Descrição

Identidade gerenciada

Selecione Identidade de Serviço Gerenciada para usar a identidade atribuída pelo sistema ou atribuída pelo usuário no recurso do aplicativo lógico.

Por padrão, os recursos do aplicativo lógico Standard já têm a identidade atribuída pelo sistema habilitada. No entanto, você precisa configurar a identidade com acesso à função no recurso de destino, além de quaisquer outros requisitos.

Para obter mais informações, consulte Atribuir acesso baseado em função a uma identidade gerenciada.

Chaves de conexão

Configure o acesso ao recurso de destino usando cadeias de conexões e chaves de acesso.

Depois de concluir essas etapas, continue para a próxima seção para que você possa criar seu código.

2: Escrever seu código

Na janela do Explorer, expanda a pasta do projeto de função e abra o arquivo da função <function-name>.cs.

Esse arquivo contém código de exemplo e elementos de código específicos com valores fornecidos anteriormente.

Neste exemplo, o arquivo de função WeatherForecast.cs contém estes elementos de código com valores de exemplo:

Elemento de código	Valor
Nome do Namespace	`Contoso.Enterprise`
Nome da classe	`WeatherForecast`
Nome da função	`WeatherForecast`
Parâmetros de função	`zipCode`, `temperatureScale`
Tipo de retorno	`Task<Weather>`
Tipo complexo	`Weather`

O exemplo a seguir mostra o código de exemplo completo:

//------------------------------------------------------------
// Copyright (c) Microsoft Corporation. All rights reserved.
//------------------------------------------------------------

namespace Contoso.Enterprise
{
    using System;
    using System.Collections.Generic;
    using System.Threading.Tasks;
    using Microsoft.Azure.Functions.Extensions.Workflows;
    using Microsoft.Azure.WebJobs;
    using Microsoft.Extensions.Logging;

    /// <summary>
    /// Represents the WeatherForecast flow invoked function.
    /// </summary>
    public class WeatherForecast
    {

        private readonly ILogger<WeatherForecast> logger;

        public WeatherForecast(ILoggerFactory loggerFactory)
        {
            logger = loggerFactory.CreateLogger<WeatherForecast>();
        }

        /// <summary>
        /// Executes the logic app workflow.
        /// </summary>
        /// <param name="zipCode">The zip code.</param>
        /// <param name="temperatureScale">The temperature scale (e.g., Celsius or Fahrenheit).</param>
        [FunctionName("WeatherForecast")]
        public Task<Weather> Run([WorkflowActionTrigger] int zipCode, string temperatureScale)
        {

            this.logger.LogInformation("Starting WeatherForecast with Zip Code: " + zipCode + " and Scale: " + temperatureScale);

            // Generate random temperature within a range based on the temperature scale
            Random rnd = new Random();
            var currentTemp = temperatureScale == "Celsius" ? rnd.Next(1, 30) : rnd.Next(40, 90);
            var lowTemp = currentTemp - 10;
            var highTemp = currentTemp + 10;

            // Create a Weather object with the temperature information
            var weather = new Weather()
            {
                ZipCode = zipCode,
                CurrentWeather = $"The current weather is {currentTemp} {temperatureScale}",
                DayLow = $"The low for the day is {lowTemp} {temperatureScale}",
                DayHigh = $"The high for the day is {highTemp} {temperatureScale}"
            };

            return Task.FromResult(weather);
        }

        /// <summary>
        /// Represents the weather information for WeatherForecast.
        /// </summary>
        public class Weather
        {
            /// <summary>
            /// Gets or sets the zip code.
            /// </summary>
            public int ZipCode { get; set; }

            /// <summary>
            /// Gets or sets the current weather.
            /// </summary>
            public string CurrentWeather { get; set; }

            /// <summary>
            /// Gets or sets the low temperature for the day.
            /// </summary>
            public string DayLow { get; set; }

            /// <summary>
            /// Gets or sets the high temperature for the day.
            /// </summary>
            public string DayHigh { get; set; }
        }
    }
}

A definição de função inclui um método Run padrão que você pode usar para começar. Este método Run de exemplo demonstra alguns recursos disponíveis com o recurso de funções personalizadas, como passar entradas e saídas diferentes, incluindo tipos complexos de .NET.

O arquivo <function-name>.cs também inclui a interface ILogger, que fornece suporte para o registro de eventos em um recurso do Application Insights. Você pode enviar informações de rastreamento para o Application Insights e armazenar essas informações com as informações de rastreamento de seus fluxos de trabalho, por exemplo:

private readonly ILogger<WeatherForecast> logger;

public WeatherForecast(ILoggerFactory loggerFactory)
{
    logger = loggerFactory.CreateLogger<WeatherForecast>();
}

[FunctionName("WeatherForecast")]
public Task<Weather> Run([WorkflowActionTrigger] int zipCode, string temperatureScale)
{

    this.logger.LogInformation("Starting WeatherForecast with Zip Code: " + zipCode + " and Scale: " + temperatureScale);

    <...>

}

Substitua o código de função de exemplo pelo seu próprio e edite o método padrão Run para seus cenários específicos. Ou você pode copiar a função, incluindo a declaração [FunctionName("<function-name>")], e renomear a função com um nome exclusivo. Você pode então editar a função renomeada para atender às suas necessidades.

Este exemplo continua com o código de exemplo original, supondo que não haja alterações.

3: Compilar e criar seu código

Depois de terminar de escrever seu código, compile-o para garantir que não existam erros de compilação. Seu projeto de funções .NET inclui automaticamente tarefas de build que compilam e adicionam seu código à pasta lib\custom no seu projeto de app logic. Fluxos de trabalho procuram funções personalizadas nessa pasta. Dependendo da versão .NET, essas tarefas colocam os assemblies na pasta lib\custom\net472 ou lib\custom\net8.

Siga estas etapas:

Em Visual Studio Code, na Barra de Atividades, selecione Explorer.
Na janela Explorer, abra o menu de contexto da pasta do projeto de funções e selecione Compilar projeto de funções.

A tarefa de compilação é executada para o projeto de funções. Se o build for bem-sucedido, a janela Terminalmostrará uma mensagem de build bem-sucedida .
Confirme se os seguintes itens existem em seu projeto de aplicativo lógico:
- Em seu espaço de trabalho, expanda as seguintes pastas: <your-logic-app>>lib\custom>net472 ou net8, com base na sua versão .NET. Confirme que a subpasta net472 ou net8 contém os arquivos assembly (DLL) necessários para rodar seu código, incluindo um arquivo chamado <nome de função>.dll.
- No seu espaço de trabalho, expanda as seguintes pastas: <seu aplicativo de lógica>>lib\custom><function-name>. Confirme se a <subpasta function-name> contém um arquivo function.json, que inclui os metadados do código da função que você escreveu. O designer do fluxo de trabalho usa esse arquivo para determinar as entradas e saídas necessárias ao chamar seu código.
O exemplo a seguir mostra exemplos de assemblies gerados e outros arquivos no projeto do aplicativo lógico:

4: Chame seu código de um fluxo de trabalho

Depois de confirmar que seu código é compilado e seu projeto de aplicativo lógico contém os arquivos necessários para que seu código seja executado, configure seu fluxo de trabalho para chamar seu código.

Na janela Explorer, expanda workspace-name, logic-app-name e, em seguida, workflow-name.

Abra o menu de atalho para workflow.jsone selecione Abrir designer.

O designer de fluxo de trabalho é aberto e mostra o fluxo de trabalho padrão com o seguinte gatilho e ações:

Operação	Descrição
Gatilho	O gatilho de solicitação integrado chamado Quando uma solicitação HTTP é recebida.
Ação	A ação integrada chamada Chamar uma função local neste aplicativo lógico.
Ação	A ação Response integrada chamada Response é usada para responder ao chamador apenas quando se utiliza o gatilho Request.

No designer, selecione a ação chamada Chamar uma função local neste aplicativo lógico.

O painel de informações da ação é aberto para que você possa configurar a chamada de função personalizada, por exemplo:
Examine e confirme se o valor do parâmetro de nome da função está definido como a função que você deseja executar. Examinar ou alterar quaisquer outros valores de parâmetro que sua função utiliza.

5: Depurar seu código e fluxo de trabalho

Para cada um dos seguintes serviços de Armazenamento do Azure, inicie o emulador de armazenamento do Azurite:
- Serviço de Blob de Azure
- Serviço de Fila do Azure
- Serviço de Tabela Azure
1. No menu Visual Studio Code View, selecione Command Palette.
2. No prompt que aparece, selecione Azurite: Iniciar Serviço de Blob na lista.
3. Na lista de diretórios de trabalho exibida, selecione seu aplicativo lógico.
4. Repita essas etapas para Azurite: Iniciar Serviço de Fila e Azurite: Iniciar Serviço de Tabela.
Se você tiver êxito, a barra de tarefas Visual Studio Code na parte inferior da tela mostrará os três serviços de armazenamento em execução.
Anexe o depurador ao seu projeto de aplicativo lógico e ao projeto de funções .NET seguindo estas etapas:
1. Em Visual Studio Code, na Barra de Atividades, selecione Run e Depurar (teclado: Ctrl+Shift+D).
2. Na lista Executar e Depurar, selecione Executar/Depurar aplicativo lógico com função local (<seu aplicativo lógico>) e, em seguida, selecione Executar (seta verde).
  
  Os seguintes eventos ocorrem:
  - A janela Terminal será aberta e mostrará o processo de depuração iniciado.
  - A janela do Console de Depuração se abre e mostra o status da depuração.
  - Na parte inferior do Visual Studio Code, a barra de tarefas fica laranja, indicando que o depurador de .NET está carregado.
Para definir pontos de interrupção, na definição de função (<nome >.cs) ou definição de fluxo de trabalho (workflow.json), localize o número de linha onde você deseja o ponto de interrupção e selecione a coluna adjacente, por exemplo:
Para executar manualmente o gatilho Solicitação em seu fluxo de trabalho, abra a página Visão Geral do fluxo de trabalho:
1. No projeto do aplicativo lógico, abra o menu de atalho do arquivo workflow.json e selecione Visão geral.
  
  Na página Visão geral do fluxo de trabalho, o botão Executar gatilho está disponível para quando você quiser iniciar manualmente o fluxo de trabalho. Em Propriedades do Fluxo de Trabalho, o valor URL da Chamada de Retorno é a URL de um ponto de extremidade que pode ser chamado criado pelo gatilho Solicitar em seu fluxo de trabalho. Você pode enviar solicitações a essa URL para disparar seu fluxo de trabalho a partir de outros aplicativos, inclusive outros fluxos de trabalho de aplicativos lógicos.
2. Na barra de ferramentas da página Visão geral, selecione Executar gatilho.
  
  Após o início da execução do fluxo de trabalho, o depurador ativa seu primeiro ponto de interrupção.
3. No menu Executar ou na barra de ferramentas do depurador, selecione uma ação de depuração.
Após a conclusão da execução do fluxo de trabalho, a página Visão geral mostra a execução concluída e os detalhes básicos sobre essa execução.
Para revisar mais informações sobre a execução do fluxo de trabalho, selecione a execução concluída. Ou, na lista ao lado da coluna Duração, selecione Mostrar execução.

6: Implantar seu código

Implante suas funções personalizadas da mesma maneira que implanta seu projeto de aplicativo lógico. Seja implantando a partir do Visual Studio Code ou usando um processo DevOps CI/CD, certifique-se de construir seu código antes de implantar. Além disso, certifique-se de que todos os assemblies dependentes existam nas seguintes pastas de projeto do Logic App antes de implantar:

.NET 4.7.2: pasta lib/custom/net472
.NET 8: pasta lib/custom/net8

Para obter mais informações, consulte Implantar fluxos de trabalho padrão do Visual Studio Code no Azure.

Injeção de dependência

Quando você escolhe .NET 8, o código personalizado do .NET nos fluxos de trabalho padrão oferece suporte à injeção de dependência (DI). Essa funcionalidade permite que você registre serviços uma vez, o que os torna automaticamente disponíveis para suas funções de código personalizadas em runtime, em vez de criar dependências dentro de cada função.

Observação

Somente projetos de código personalizado .NET 8 no Visual Studio Code dão suporte à injeção de dependências.

Sem injeção de dependência, funções de código personalizado costumam:

Crie instâncias de serviço diretamente na função.
Repetir a lógica em diferentes funções ou fluxos de trabalho.
Misture a lógica de negócios com o código de instalação e configuração.

À medida que os fluxos de trabalho aumentam, o código personalizado torna-se mais difícil de testar, reutilizar e manter. Ao usar injeção de dependência, você pode:

Separar a lógica de negócios da execução do fluxo de trabalho.
Reutilize serviços compartilhados em várias funções de código personalizadas.
Alinhe o código personalizado com padrões padrão de desenvolvimento de .NET.

O código personalizado torna-se mais gerenciável em fluxos de trabalho de produção, especialmente quando vários fluxos de trabalho dependem da mesma lógica.

Quando usar a injeção de dependência

Se você tiver funções de código personalizadas simples ou pontuais, provavelmente não precisará de injeção de dependência. No entanto, se seu código personalizado tiver os seguintes requisitos, considere usar injeção de dependências:

Vários fluxos de trabalho usam ou compartilham as mesmas funções de código personalizadas.
Suas funções de códigos personalizados contêm lógica comercial ou de roteamento que muda ao longo do tempo.
Você precisa de melhor capacidade de teste ou de manutenção a longo prazo.

Como a injeção de dependência afeta as funções de .NET personalizadas

A injeção de dependência não altera a forma como você chama funções de .NET personalizadas ou seu comportamento de fluxo de trabalho. Essa funcionalidade altera apenas a estrutura de código personalizada subjacente, mas produz o mesmo resultado. As etapas a seguir descrevem esse processo:

Aplicativos Lógicos do Azure carrega seu projeto de código personalizado.
Aplicativos Lógicos do Azure instancia, registra e injeta os serviços necessários na função.
A função é executada usando as dependências injetadas.

Habilitar a injeção de dependência

Para usar a injeção de dependência com seu código de .NET personalizado, conclua os seguintes requisitos:

Ao criar seu projeto de código personalizado, selecione .NET 8.

Somente projetos de código personalizados em .NET 8 suportam injeção de dependência.

Em seu projeto, adicione uma StartupConfiguration classe para definir a lista de dependências. Implemente a IConfigureStartup interface e registre suas dependências usando IServiceCollection, por exemplo:

using Microsoft.Azure.Functions.Extensions.Workflows;
using Microsoft.Extensions.DependencyInjection;

public class StartupConfiguration : IConfigureStartup
{
    /// <summary>
    /// Configures services for the custom code function to use.
    /// </summary>
    /// <param name="services">The service collection to configure.</param>
    public void Configure(IServiceCollection services)
    {
        // Register the routing service with dependency injection
        services.AddSingleton<IRoutingService, OrderRoutingService>();
        services.AddSingleton<IDiscountService, DiscountService>();
    }
}

A IConfigureStartup interface é definida em Microsoft.Azure.Functions.Extensions.Workflows, enquanto IServiceCollection é definida em Microsoft.Extensions.DependencyInjection. Para mais informações, veja StartupConfiguration.cs.

No construtor da classe de função de código personalizado, inicialize os serviços registrados definindo-os como parâmetros de construtor, em vez de criá-los dentro da função, por exemplo:

public class MySampleFunction
{
    private readonly ILogger<MySampleFunction> logger;
    private readonly IRoutingService routingService;
    private readonly IDiscountService discountService;

    public MySampleFunction(ILoggerFactory loggerFactory, IRoutingService routingService, IDiscountService discountService)
    {
        this.logger = loggerFactory.CreateLogger<MySampleFunction>();
        this.routingService = routingService;
        this.discountService = discountService;
    }

    // Add your function logic here

}

Além de criar e implantar seu projeto de código personalizado, você não precisa executar outras etapas, editar seu fluxo de trabalho ou fazer outras alterações de instalação no Aplicativos Lógicos do Azure para habilitar a injeção de dependência.

Para mais detalhes, consulte o exemplo Injeção de Dependência de Código Personalizado.

Use seus próprios pacotes NuGet em projetos com código personalizado

Para projetos de código personalizado baseados em NuGet que usam .NET 8, você pode incluir e gerenciar seus próprios pacotes NuGet sem precisar resolver conflitos com as dependências usadas pelo host de trabalho de idioma. Basta adicionar as dependências do assembly diretamente ao local do assembly separado no seu projeto. Com as seguintes exceções, você pode usar qualquer versão de assembly dependente compatível com .NET 8 que seu projeto precisar.

Microsoft.Extensions.Logging.Abstractions
Microsoft.Extensions.DependencyInjection.Abstractions
Microsoft.Azure.Functions.Extensions.Workflows.Abstractions

Solução de problemas

Erro no painel de informações da ação

No designer do fluxo de trabalho, quando você seleciona a ação interna chamada Chamar uma função local neste aplicativo lógico, o painel de informações da ação mostra a seguinte mensagem:

Failed to retrieve dynamic inputs. Error details:

Nesse cenário, verifique seu projeto de aplicativo lógico para ver se a pasta LogicApp\lib\custom está vazia. Se estiver vazio, no menu Terminal, selecione Executar Tarefa>build Functions.

Nenhum processo com o nome especificado está em execução no momento

Se você receber essa mensagem de erro ao executar seu fluxo de trabalho, provavelmente anexou o processo de depurador ao .NET Functions, em vez de ao seu aplicativo lógico.

Para corrigir esse problema, na lista Executar e Depurar, selecione Anexar ao aplicativo lógico (LogicApp) e, em seguida, Reproduzir (triângulo verde).

O pacote não foi importado corretamente

Se a janela Saída mostrar um erro semelhante à mensagem a seguir, verifique se você tem pelo menos .NET 6.0 instalado. Se você tiver essa versão instalada, experimente desinstalar e depois reinstalar.

C:\Users\yourUserName\.nuget\packages\microsoft.net.sdk.functions\4.2.0\build\Microsoft.NET.Sdk.Functions.targets(83,5): warning : The ExtensionsMetadataGenerator package was not imported correctly. Are you missing 'C:\Users\yourUserName\.nuget\packages\microsoft.azure.webjobs.script.extensionsmetadatagenerator\4.0.1\build\Microsoft.Azure.WebJobs.Script.ExtensionsMetadataGenerator.targets' or 'C:\Users\yourUserName\.nuget\packages\microsoft.azure.webjobs.script.extensionsmetadatagenerator\4.0.1\build\Microsoft.Azure.WebJobs.Script.ExtensionsMetadataGenerator.props'? [C:\Desktop\...\custom-code-project\MyLogicAppWorkspace\Function\WeatherForecast.csproj] WeatherForecast -> C:\Desktop\...\custom-code-project\MyLogicAppWorkspace\Function\\bin\Debug\net472\WeatherForecast.dll C:\Users\yourUserName\.nuget\packages\microsoft.net.sdk.functions\4.2.0\build\Microsoft.NET.Sdk.Functions.Build.targets(32,5): error : It was not possible to find any compatible framework version [C:\Desktop\...\custom-code-project\MyLogicAppWorkspace\Function\WeatherForecast.csproj] C:\Users\yourUserName\.nuget\packages\microsoft.net.sdk.functions\4.2.0\build\Microsoft.NET.Sdk.Functions.Build.targets(32,5): error : The specified framework 'Microsoft.NETCore.App', version '6.0.0' was not found. [C:\Desktop\...\custom-code-project\MyLogicAppWorkspace\Function\WeatherForecast.csproj] C:\Users\yourUserName\.nuget\packages\microsoft.net.sdk.functions\4.2.0\build\Microsoft.NET.Sdk.Functions.Build.targets(32,5): error : - Check application dependencies and target a framework version installed at: [C:\Desktop\...\custom-code-project\MyLogicAppWorkspace\Function\WeatherForecast.csproj]

Falhas de compilação com erros CS1031 e CS1001

Se sua função não incluir variáveis e você criar seu código, a janela Saída poderá mostrar as seguintes mensagens de erro:

C:\Users\yourUserName\...\custom-code-project\Function\func.cs (24,64): error CS1031: Type expected [C:\Users\yourUserName\...\custom-code-project\Function\func.csproj]
C:\Users\yourUserName\...\custom-code-project\Function\func.cs (24,64): error CS1001: Identifier expected [C:\Users\yourUserName\...\custom-code-project\Function\func.csproj]

Build FAILED.

0 Warning(s)
2 Error(s)

Para corrigir esse problema, no método do Run código, adicione o seguinte parâmetro:

string parameter1 = null

O exemplo a seguir mostra como a assinatura do método Run aparece:

public static Task<Weather> Run([WorkflowActionTrigger] int zipCode, string temperatureScale, string parameter1 = null)

Criar fluxos de trabalho de Logic Apps Standard com o Visual Studio Code

Comentários

Esta página foi útil?

Last updated on 2026-09-16

Crie e execute funções locais em fluxos de trabalho padrão para Aplicativos Lógicos do Azure

Pré-requisitos

Limitações

1: Criar um projeto de código

2: Escrever seu código

3: Compilar e criar seu código

4: Chame seu código de um fluxo de trabalho

5: Depurar seu código e fluxo de trabalho

6: Implantar seu código

Injeção de dependência

Quando usar a injeção de dependência

Como a injeção de dependência afeta as funções de .NET personalizadas

Habilitar a injeção de dependência

Use seus próprios pacotes NuGet em projetos com código personalizado

Solução de problemas

Erro no painel de informações da ação

Nenhum processo com o nome especificado está em execução no momento

O pacote não foi importado corretamente

Falhas de compilação com erros CS1031 e CS1001

Conteúdo relacionado

Comentários

Recursos adicionais