Criar e executar funções locais em fluxos de trabalho padrão para Azure Logic Apps

Aplica-se a: Azure Logic Apps (Padrão)

Quando o seu fluxo de trabalho de integração precisar de lógica para além das operações incorporadas e dos conectores pré-construídos, crie uma função local onde o código permaneça específico para a solução da sua aplicação lógica. Esta função local é um código .NET personalizado que escreve, executa, depura e implementa no mesmo projeto Azure Logic Apps Standard que os fluxos de trabalho de chamada. Ao manter a função local, pode desenvolver, proteger, implementar, escalar e operar o fluxo de trabalho e o seu código personalizado como uma única aplicação.

As funções locais ajudam os 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.
Validar, enriquecer ou realizar transformações simples nos dados.
Moldar mensagens de saída para uma API, conector ou sistema parceiro.
Reutilizar 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, pode alcançar os seguintes objetivos:

Goal	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 numa única sessão de depuração.
Implementar em conjunto	Construa e implemente a função local juntamente com os fluxos de trabalho dos chamadores sem fornecer um plano de serviço separado.
Reduzir os limites de serviço	Evite uma aplicação Function App separada, um endpoint HTTP, um fluxo de autenticação e um salto de rede para código específico do fluxo de trabalho.
Combinar ferramentas low-code e pro-code	Use conectores e orquestração de workflow para o fluxo de integração. Use funções locais para lógica .NET especializada.

Uma função local difere de uma função alojada numa aplicação de funções separada no Funções do Azure. O Funções do Azure funciona melhor quando o seu código tem de expor um endpoint independente, ser partilhado entre aplicações, seguir o seu próprio ciclo de implementação e versionamento, ou escalar de forma independente. Quando o seu código precisa de funcionar dentro de uma solução específica do Azure Logic Apps Standard e partilhar 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 implementar funções .NET locais para fluxos de trabalho Standard utilizando o Visual Studio Code.

Nota

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

Processos em execução que podem ultrapassar os 10 minutos.
Usar componentes de pipeline do BizTalk Server que implementam streaming.

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

Pré-requisitos

Uma conta Azure e subscrição. Crie uma conta Azure gratuita.
A mais recente versão do Visual Studio Code com a extensão Azure Logic Apps (Standard).

Para pré-requisitos, veja Criar workflows Standard em Azure Logic Apps de inquilino único com o Visual Studio Code.

A extensão oferece as seguintes capacidades 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 no Visual Studio Code. Percorra seu código e fluxos de trabalho na mesma sessão de depuração.
- Implante código junto com seus fluxos de trabalho. Não são necessários outros planos de serviço.
- Suporta cenários de migração do BizTalk Server para que possa migrar investimentos personalizados em .NET do local para a cloud.
Uma pasta local para usar no seu projeto de código.

Limitações

Só podes criar funções locais no Visual Studio Code a correr no Windows. Esta funcionalidade suporta o .NET Framework e o .NET 8 para fluxos de trabalho Standard alojados no Workflow Service Plan, Ambiente do Serviço de Aplicações v3 (ASE v3) ou Hybrid.
Não podes usar funções personalizadas de autoria no portal Azure. No entanto, para trabalhar com saídas de funções personalizadas no seu fluxo de trabalho, siga estes passos:
1. Depois de implementares as tuas funções para Azure, segue os passos em Chama o teu código a partir de um workflow para o portal Azure.
2. Adicione a ação incorporada chamada Chamar uma função local nesta aplicação lógica ao seu fluxo de trabalho. Seleciona as funções personalizadas implementadas que queres e executa o teu código.
3. Use ações subsequentes do fluxo de trabalho para referenciar os resultados das funções personalizadas, tal como pode fazer em qualquer outro fluxo de trabalho. Você pode visualizar o histórico de execução, entradas e saídas da ação interna.

Para limitações gerais, veja Limites e referência de configuração para Azure Logic Apps.

1: Criar um projeto de código

A extensão Azure Logic Apps (Standard) para Visual Studio Code inclui um modelo de projeto de código que proporciona uma experiência simplificada para escrever, depurar e implementar o seu próprio código com os seus fluxos de trabalho. Este modelo de projeto cria um ficheiro de espaço de trabalho e dois projetos de exemplo: um projeto para escrever o seu código e outro para criar os seus fluxos de trabalho.

Nota

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 estes passos:

Em Visual Studio Code, inicia sessão na tua conta Azure.

Se o início de sessão demorar mais do que o habitual, o Visual Studio Code pede-lhe para iniciar sessão através de um site de autenticação da Microsoft, fornecendo-lhe um código do dispositivo. Para iniciar sessão usando o código, siga estes passos:
1. Selecione Usar Código do Dispositivo e depois selecione Copiar & Abrir.
2. Selecione Abrir Link para abrir uma nova janela do navegador e continue até ao site de autenticação.
3. Na página Iniciar sessão na sua conta, introduza o seu código de autenticação e selecione Seguinte.
Na Barra de Atividade, selecione o ícone do Azure.
Na janela Azure, vai à secção Workspace. Mova o ponteiro sobre a área do título para que a barra de ferramentas apareça.
No menu Azure Logic Apps, selecione Criar novo espaço de trabalho de aplicação lógica.
Na janela Select Folder , navegue até à pasta local do projeto, selecione a pasta e depois Selecione.
Na janela Criar novo espaço de trabalho de aplicação lógica, introduza um nome para o seu espaço de trabalho no campo Nome do espaço de trabalho e, em seguida, prima Enter.

Este exemplo utiliza weather-app como nome do espaço de trabalho:
Para selecionar um modelo para o seu novo prompt de projeto , selecione a aplicação Logic com projeto de código personalizado.
Para o prompt Select a target framework, selecione .NET Framework ou .NET 8.

Siga as indicações seguintes para fornecer a seguinte informação:

Prompt	Valor de exemplo
Nome da Aplicação Lógica	`weather-logic-app`
Nome da função para o seu projeto de funções .NET	`WeatherForecast`
Namespace para o teu projeto de funções .NET	`Contoso.Enterprise`
Selecione um modelo para o primeiro fluxo de trabalho do seu projeto: - Workflow com estado persistente - Fluxo de trabalho sem estado - Agente autónomo - Agente conversacional - Saltar por enquanto	Fluxo de trabalho com estado
Nome do fluxo de trabalho	`weather-workflow`

Para selecionar como deseja abrir o seu projeto , selecione Abrir na janela atual.

Depois de concluir este passo, o Visual Studio Code cria o seu espaço de trabalho, que inclui um projeto de funções .NET e um projeto de aplicação lógica, por defeito, por exemplo:

Captura de ecrã que mostra o espaço de trabalho criado com o projeto da app lógica e o projeto de funções .NET.

Na janela do Explorador , note as seguintes pastas no seu espaço de trabalho:

Folder	Descrição
< nome do espaço de trabalho>	Contém tanto o teu projeto de funções .NET como o projeto de workflow de Logic App.
< logic-app-name>	Contém os ficheiros e outros artefactos do teu projeto de aplicação lógica. Por exemplo, o ficheiroworkflow.json é o ficheiro de definição do fluxo de trabalho onde podes construir o teu fluxo de trabalho.
< Nome da função>	Contém os ficheiros e outros artefactos do seu projeto de funções .NET. Por exemplo, o <arquivo de nome> da função.cs é o arquivo de código onde você pode criar seu código.

Para o prompt Enable connectors for Azure for Logic Apps <logic-app-name>, selecione Utilizar conectores do Azure.
Para o prompt Select subscription, seleciona a subscrição Azure que queres.
Para o aviso Selecionar um grupo de recursos para novos recursos, selecione o grupo de recursos que deseja ou Criar novo grupo de recursos.
Para o prompt Selecione um local para novos recursos, selecione a região Azure para implementação.

Para o método de autenticação Select para conectores Azure, selecione o tipo de autenticação a usar para ligações que necessitem de autenticação.

Tipo de autenticação	Descrição
Identidade gerenciada	Selecione Identidade de Serviço Gerido para usar a identidade atribuída pelo sistema ou pelo utilizador no recurso da sua aplicação lógica. Por defeito, os recursos da aplicação Standard Logic já têm a identidade atribuída ao sistema ativada. No entanto, tens de configurar a identidade com acesso de função no recurso de destino, além de quaisquer outros requisitos. Para mais informações, consulte Atribuir acesso baseado em função a uma identidade gerida.
Chaves de ligação	Configura o acesso ao recurso alvo usando strings de ligação e chaves de acesso.

Tipo de autenticação

Descrição

Identidade gerenciada

Selecione Identidade de Serviço Gerido para usar a identidade atribuída pelo sistema ou pelo utilizador no recurso da sua aplicação lógica.

Por defeito, os recursos da aplicação Standard Logic já têm a identidade atribuída ao sistema ativada. No entanto, tens de configurar a identidade com acesso de função no recurso de destino, além de quaisquer outros requisitos.

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

Chaves de ligação

Configura o acesso ao recurso alvo usando strings de ligação e chaves de acesso.

Depois de completares estes passos, continua para a secção seguinte para poderes criar o teu código.

2: Escreve o teu código

Na janela do Explorador, expanda a pasta do projeto da função e abra o ficheiro <nome-da-função>.cs.

Este ficheiro contém código de exemplo e elementos específicos de código com valores que forneceu anteriormente.

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

Elemento de código	valor
Nome do espaço de nomes	`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 padrão Run que você pode usar para começar. Este método de exemplo Run demonstra algumas capacidades disponíveis com a funcionalidade de funções personalizadas, como passar diferentes entradas e saídas, incluindo tipos complexos de .NET.

O ficheiro <nome da função>.cs também inclui a interface ILogger que fornece suporte para registar eventos num recurso do Application Insights. Pode enviar informação de rastreio para o Application Insights e armazenar essa informação juntamente com a informação de rastreio dos 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);

    <...>

}

Substitui o código da função de exemplo pelo teu próprio e edita o método padrão Run para os teus cenários específicos. Ou, você pode copiar a função, incluindo a [FunctionName("<function-name>")] declaração, e, em seguida, renomear a função com um nome exclusivo. Em seguida, você pode editar a função renomeada para atender às suas necessidades.

Este exemplo continua com o código de exemplo original, assumindo que não há alterações.

3: Compilar e construir o seu código

Depois de terminares de escrever o teu código, compila-o para garantir que não existem erros de compilação. O teu projeto de funções .NET inclui automaticamente tarefas de compilação que compilam e adicionam o teu código à pasta lib\custom no teu projeto Logic App. Os fluxos de trabalho procuram funções personalizadas nesta pasta. Dependendo da sua versão .NET, estas tarefas colocam os assemblies na pasta lib\custom\net472 ou lib\custom\net8.

Siga estes passos:

No Visual Studio Code, na Barra de Atividade, selecione Explorer.
Na janela Explorer , abra o menu de atalho para a pasta do projeto de funções e selecione Construir projeto de funções.

A tarefa de compilação corre para o projeto de funções. Se a sua compilação for bem-sucedida, a janela do Terminal mostra uma mensagem de compilação bem-sucedida.
Confirme se os seguintes itens existem em seu projeto de aplicativo lógico:
- No seu espaço de trabalho, expanda as seguintes pastas: <your-logic-app>>lib\custom>net472 ou net8, com base na versão .NET. Confirme que a subpasta net472 ou net8 contém os ficheiros assembly (DLL) necessários para executar o seu código, incluindo um ficheiro chamado <nome de função>.dll.
- No seu espaço de trabalho, expanda as seguintes pastas: <sua lógica app>>lib\custom><nome-da-função>. Confirme que a subpasta <function-name> contém o ficheiro function.json, que inclui os metadados relativos ao código da função que escreveu. O designer de 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 assemblies gerados de exemplo e outros arquivos no projeto de aplicação lógica:

4: Chamar o seu código de um fluxo de trabalho

Depois de confirmares que o teu código compila e que o projeto da tua aplicação lógica contém os ficheiros necessários para o teu código correr, configura o teu fluxo de trabalho para chamar o teu código.

Na janela do Explorador, expande< nome >, < nome da aplicação> lógica e depois <nome do> fluxo de trabalho.

Abra o menu de atalho para workflow.json, e selecione Abrir designer.

O designer do workflow abre e mostra o workflow predefinido com o seguinte gatilho e ações:

Funcionamento	Descrição
Trigger	O gatilho incorporado de pedido chamado When an HTTP request is received.
Action	A ação incorporada chamada Chamar uma função local nesta aplicação lógica.
Action	A ação de Resposta incorporada chamada Resposta que você usa para responder ao chamador apenas quando usa o gatilho Pedido.

No designer, selecione a ação chamada Chamar uma função local nesta aplicação lógica.

O painel de informação da ação abre-se para que possas configurar a chamada de função personalizada, por exemplo:
Revise e confirme se o valor do parâmetro Function Name está definido para a função que pretende executar. Revise ou altere quaisquer outros valores de parâmetro usados pela sua função.

5: Depurar o seu código e fluxo de trabalho

Para cada um dos seguintes serviços Armazenamento do Azure, inicie o emulador de armazenamento Azurite:
- Azure Blob Service
- Serviço de Fila do Azure
- Serviço de Tabela do Azure
1. No menu Visual Studio Code View, selecione Command Palette.
2. No aviso que aparece, selecione Azurite: Iniciar Serviço de Blob da lista.
3. Na lista de diretórios de trabalho que aparece, selecione a sua aplicação lógica.
4. Repita estas etapas para Azurite: Start Queue Service e Azurite: Start Table Service.
Se tiveres sucesso, a barra de tarefas do Visual Studio Code na parte inferior do ecrã mostra os três serviços de armazenamento a funcionar.
Anexe o depurador tanto ao seu projeto de aplicação lógica como ao projeto de funções .NET seguindo estes passos:
1. No Visual Studio Code, na Barra de Atividade, selecione Run and Debug (teclado: Ctrl+Shift+D).
2. Da lista Executar e Depurar, selecione Executar/Depurar a aplicação lógica com função local (<a sua aplicação lógica>) e depois selecione Play (ícone de seta verde).
  
  Ocorrem os seguintes eventos:
  - A janela Terminal é aberta e mostra o processo de depuração iniciado.
  - A janela da Consola de Depuração abre-se e mostra o estado da depuração.
  - No final do Visual Studio Code, a barra de tarefas fica laranja, indicando que o depurador .NET está carregado.
Para definir quaisquer pontos de interrupção, na definição da sua<função (> da função.cs) ou definição do fluxo de trabalho (workflow.json), encontre o número da linha onde quer o ponto de interrupção e selecione a coluna adjacente, por exemplo:
Para executar manualmente o gatilho de Pedido no seu fluxo de trabalho, abra a página de Visão Geral do fluxo:
1. A partir do teu projeto da Aplicação Lógica, abre o menu de contexto do ficheiro workflow.json, e depois seleciona Visão Geral.
  
  Na página Visão geral do fluxo de trabalho, o botão Acionar está disponível para quando se deseja iniciar manualmente o fluxo de trabalho. Em Propriedades do Fluxo de Trabalho, o valor da URL de Callback é a URL de um ponto de extremidade invocável criado pelo ativador de Solicitação no seu fluxo de trabalho. Pode enviar pedidos para este URL para acionar o seu fluxo de trabalho a partir de outras aplicações, incluindo outros fluxos de trabalho de aplicações lógicas.
2. Na barra de ferramentas da página Visão geral , selecione Executar gatilho.
  
  Depois que o fluxo de trabalho começar a ser executado, o depurador ativará 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: Implemente o seu código

Implementa as tuas funções personalizadas da mesma forma que implementas o teu projeto de Logic App. Quer implementes a partir do Visual Studio Code ou uses um processo DevOps CI/CD, certifica-te de que compilas o teu código antes de implementares. Além disso, certifique-se de que todos os assemblies dependentes existem nas seguintes pastas do projeto da Logic App antes de implementar:

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

Para mais informações, consulte Deploy Standard workflows from Visual Studio Code to Azure.

Injeção de dependência

Quando escolhe .NET 8, código de .NET personalizado nos fluxos de trabalho Standard suporta injeção de dependência (DI). Esta funcionalidade permite-lhe registar serviços uma vez, o que os torna automaticamente disponíveis para as suas funções de código personalizadas em tempo de execução, em vez de criar dependências dentro de cada função.

Nota

Apenas os projetos de código personalizado .NET 8 no Visual Studio Code suportam injeção de dependências.

Sem injeção de dependências, o código personalizado funciona frequentemente:

Crie instâncias de serviço diretamente na função.
Duplicar lógica através de múltiplas funções ou fluxos de trabalho.
Misture a lógica de negócios com o código de configuração e inicialização.

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

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

O código personalizado torna-se mais gerível em fluxos de trabalho de produção, especialmente quando múltiplos fluxos de trabalho dependem da mesma lógica.

Quando usar a injeção de dependência

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

Múltiplos fluxos de trabalho usam ou partilham as mesmas funções de código personalizado.
As suas funções de código personalizado contêm lógica de negócio ou de encaminhamento que muda ao longo do tempo.
Precisa de melhor testabilidade ou manutenção a longo prazo.

Como é que a injeção de dependências afeta funções personalizadas de .NET

A injeção de dependências não altera a forma como chamas funções .NET personalizadas ou o comportamento do teu fluxo de trabalho. Esta funcionalidade apenas altera a estrutura do código personalizado subjacente, mas produz o mesmo resultado. As etapas a seguir descrevem esse processo:

O Azure Logic Apps carrega o seu projeto de código personalizado.
O Azure Logic Apps instancia, regista e injeta os serviços necessários na função.
A função executa-se usando as dependências injetadas.

Permitir a injeção de dependências

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

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

Apenas os projetos de código personalizado .NET 8 suportam injeção de dependências.

No seu projeto, adicione uma StartupConfiguration classe para definir a lista de dependências. Implemente a IConfigureStartup interface e registe as 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 está definida em Microsoft.Extensions.DependencyInjection. Para mais informações, consulte StartupConfiguration.cs.

No seu construtor de classes de função de código personalizado, inicialize os serviços registados definindo-os como parâmetros do construtor, em vez de os criar 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

}

Para além de construir e implementar o seu projeto de código personalizado, não precisa de tomar mais passos, editar o seu fluxo de trabalho ou fazer quaisquer alterações de configuração no Azure Logic Apps para permitir a injeção de dependências.

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

Utilize os seus próprios pacotes NuGet em projetos de código personalizado

Para projetos de código personalizado baseados em NuGet que utilizam .NET 8, pode incluir e gerir os seus próprios pacotes NuGet sem precisar resolver conflitos com dependências usadas pelo host do trabalhador de linguagem. Basta adicionar diretamente as dependências de montagem ao local de montagem separado no teu projeto. Com as seguintes exceções, pode trazer quaisquer versões de assembly dependentes compatíveis com .NET 8 que o seu projeto necessite:

Microsoft.Extensions.Logging.Abstractions
Microsoft. Extensões.DependencyInjection.Abstrações
Microsoft. Azure. Funções.Extensões.Workflows.Abstrações

Resolução de problemas

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

No designer de 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:

Neste cenário, verifica o teu projeto de Logic App para ver se a pasta LogicApp\lib\custom está vazia. Se estiver vazio, no menu Terminal, selecione Executar Tarefa>construir Funções.

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

Se receberes esta mensagem de erro ao executar o teu fluxo de trabalho, provavelmente associaste o processo de depuração às Funções .NET, em vez de à tua aplicação lógica.

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

Pacote não importado corretamente

Se a janela de Saída mostrar um erro semelhante à mensagem seguinte, certifique-se de que tem pelo menos o .NET 6.0 instalado. Se tiver esta versão instalada, tente desinstalar e, em seguida, 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 a sua função não incluir variáveis e você compilar o seu código, a Janela de Resultados pode 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 resolver este problema, no método do Run seu código, adicione o seguinte parâmetro:

string parameter1 = null

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

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

Criar fluxos de trabalho de aplicações de lógica padrão com Visual Studio Code

Comentários

Esta página foi útil?

Last updated on 2026-09-15

Criar e executar funções locais em fluxos de trabalho padrão para Azure Logic Apps

Pré-requisitos

Limitações

1: Criar um projeto de código

2: Escreve o teu código

3: Compilar e construir o seu código

4: Chamar o seu código de um fluxo de trabalho

5: Depurar o seu código e fluxo de trabalho

6: Implemente o seu código

Injeção de dependência

Quando usar a injeção de dependência

Como é que a injeção de dependências afeta funções personalizadas de .NET

Permitir a injeção de dependências

Utilize os seus próprios pacotes NuGet em projetos de código personalizado

Resolução de problemas

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

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

Pacote não importado corretamente

Falhas de compilação com erros CS1031 e CS1001

Conteúdo relacionado

Comentários

Recursos adicionais