Crea y ejecuta funciones locales en flujos de trabajo estándar para Azure Logic Apps

Se aplica a: Azure Logic Apps (Estándar)

Cuando tu flujo de trabajo de integración necesite lógica más allá de las operaciones integradas y los conectores preconstruidos, crea una función local donde el código siga siendo específico para tu solución de aplicación lógica. Esta función local es código .NET personalizado que creas, ejecutas, depuras y despliegas en el mismo proyecto de Azure Logic Apps Standard que los flujos de trabajo de los llamadores. Manteniendo la función local, puedes desarrollar, asegurar, desplegar, escalar y operar el flujo de trabajo y su código personalizado como una sola aplicación.

Las funciones locales ayudan a tus flujos de trabajo a realizar tareas como:

Implementa lógica y cálculos de negocio personalizados.
Analiza mensajes entrantes propietarios o complejos.
Validar, enriquecer o realizar transformaciones simples sobre los datos.
Moldea los mensajes salientes para una API, conector o sistema asociado.
Reutilice la lógica auxiliar adecuada de .NET de soluciones de integración existentes, incluyendo escenarios de migración de BizTalk Server.

Con las funciones locales, puedes alcanzar los siguientes objetivos:

Objetivo	Capacidad
Desarrollar y depurar una solución	Crea el flujo de trabajo y la función local en el mismo espacio de trabajo de Visual Studio Code, y recorre ambos en una sola sesión de depuración.
Desplegad juntos	Construye y despliega la función local junto con los flujos de trabajo de los llamantes sin tener que aprovisionar un plan de servicio separado.
Reducir los límites de servicio	Evita una aplicación de funciones independiente, un punto de conexión HTTP, un flujo de autenticación y un salto de red para el código específico del flujo de trabajo.
Combina herramientas low-code y pro-code	Utiliza conectores y orquestación de flujos de trabajo para el flujo de integración. Utiliza funciones locales para lógica .NET especializada.

Una función local difiere de una función alojada en una aplicación de funciones separada en Azure Functions. Azure Functions funciona mejor cuando tu código debe exponer un endpoint independiente, ser compartido entre aplicaciones, seguir su propio ciclo de despliegue y versionado, o escalar de forma independiente. Cuando tu código necesite funcionar dentro de una solución específica de Azure Logic Apps Standard y compartir el ciclo de vida de la aplicación con los flujos de trabajo de los llamantes, utiliza una función local.

Esta guía muestra cómo crear, construir, llamar, depurar y desplegar funciones .NET locales para flujos de trabajo estándar utilizando Visual Studio Code.

Nota:

Las funciones locales no son adecuadas para los siguientes escenarios:

Ejecución de procesos que pueden superar los 10 minutos.
Utilizando componentes de pipeline de BizTalk Server que implementan streaming.

Para obtener más información, consulta Limitaciones.

Requisitos previos

Una cuenta y una suscripción de Azure. Obtener una cuenta gratuita de Azure.
La versión más reciente de Visual Studio Code con la extensión de Azure Logic Apps (estándar).

Para conocer los requisitos previos, consulte Crear flujos de trabajo estándar en Azure Logic Apps de inquilino único con Visual Studio Code.

La extensión proporciona las siguientes funcionalidades y ventajas:
- Escriba su propio código mediante la creación de funciones que tengan la flexibilidad y el control para resolver los problemas de integración más difíciles.
- Depurar código localmente en Visual Studio Code. Recorra el código y los flujos de trabajo en la misma sesión de depuración.
- Implemente código junto con los flujos de trabajo. No es necesario ningún otro plan de servicio.
- Se pueden realizar procesos de migración de BizTalk Server para que pueda migrar mediante lift-and-shift inversiones personalizadas de .NET del entorno local a la nube.
Carpeta local que se va a usar para el proyecto de código.

Limitaciones

Solo puedes crear funciones locales en Visual Studio Code ejecutándose en Windows. Esta capacidad soporta .NET Framework y .NET 8 para flujos de trabajo estándar alojados en Workflow Service Plan, App Service Environment v3 (ASE v3) o Hybrid.
No puede usar la creación de funciones personalizadas en Azure Portal. Sin embargo, para trabajar con salidas de funciones personalizadas en el flujo de trabajo, siga estos pasos:
1. Después de implementar sus funciones en Azure, siga los pasos descritos en Llamar a su código desde un flujo de trabajo en el portal de Azure.
2. Agregue la acción integrada denominada Llamar a una función local en esta aplicación lógica al flujo de trabajo. Seleccione las funciones personalizadas implementadas que desee y ejecute el código.
3. Utilice acciones posteriores del flujo de trabajo para hacer referencia a las salidas de funciones personalizadas, como puede hacerlo en cualquier otro flujo de trabajo. Puede ver el historial de ejecución, las entradas y las salidas de la acción integrada.

Para conocer las limitaciones generales, consulte Limits y referencia de configuración para Azure Logic Apps.

1: Creación de un proyecto de código

La extensión Azure Logic Apps (Estándar) para Visual Studio Code incluye una plantilla de proyecto de código que proporciona una experiencia simplificada para escribir, depurar e implementar su propio código con los flujos de trabajo. Esta plantilla de proyecto crea un archivo de área de trabajo y dos proyectos de ejemplo: un proyecto para escribir el código y otro proyecto para crear los flujos de trabajo.

Nota:

No puede usar la misma carpeta de proyecto para el código y los flujos de trabajo.

Para crear un proyecto de código, siga estos pasos:

En Visual Studio Code, inicia sesión en tu cuenta de Azure.

Si el inicio de sesión tarda más de lo habitual, Visual Studio Code le pedirá que inicie sesión a través de un sitio web de autenticación de Microsoft proporcionándole un código de dispositivo. Para iniciar sesión con el código en su lugar, siga estos pasos:
1. Seleccione Usar código de dispositivo y, a continuación, seleccione Copiar y abrir.
2. Seleccione Abrir vínculo para abrir una nueva ventana del explorador y continuar con el sitio web de autenticación.
3. En la página Iniciar sesión en tu cuenta, escriba el código de autenticación y seleccione Siguiente.
En la barra de actividades, seleccione el icono de Azure.
En la ventana Azure, vaya a la sección Workspace. Mueva el puntero sobre el área de título para que aparezca la barra de herramientas.
En el menú Azure Logic Apps, seleccione Crear área de trabajo de aplicación lógica nueva.
En la ventana Seleccionar carpeta, vaya a la carpeta del proyecto local, seleccione la carpeta y, a continuación, Seleccione.
En la ventana Crear área de trabajo de la aplicación lógica, en el indicador Nombre del área de trabajo, escriba un nombre para el área de trabajo y pulse Entrar.

En este ejemplo se usa weather-app como nombre del área de trabajo:
Para seleccionar una plantilla para su nuevo proyecto, seleccione aplicación de lógica con proyecto de código personalizado.
En la solicitud Seleccionar un marco de destino, seleccione .NET Framework o .NET 8.

Siga las indicaciones siguientes para proporcionar la siguiente información:

Pronto	Valor de ejemplo
Nombre de la aplicación lógica	`weather-logic-app`
nombre de función para el proyecto de funciones de .NET	`WeatherForecast`
Namespace para el proyecto de funciones de .NET	`Contoso.Enterprise`
Seleccione una plantilla para el primer flujo de trabajo del proyecto: - Flujo de trabajo con estado - Flujo de trabajo sin estado - Agente autónomo - Agente conversacional - Omitir por ahora	Flujo de trabajo con estado
Nombre del flujo de trabajo	`weather-workflow`

Para el indicador Seleccionar cómo desea abrir su proyecto, seleccione Abrir en la ventana actual.

Después de finalizar este paso, Visual Studio Code crea el área de trabajo, que incluye un proyecto de funciones de .NET y un proyecto de aplicación lógica, por ejemplo:

Captura de pantalla que muestra el espacio de trabajo creado con el proyecto de Logic App y el proyecto de funciones .NET.

En la ventana Explorador , tenga en cuenta las siguientes carpetas del área de trabajo:

Carpeta	Descripción
< nombre del espacio de trabajo>	Contiene tanto el proyecto de funciones de .NET como el proyecto de flujo de trabajo de la aplicación lógica.
< Nombre de la aplicación lógica>	Contiene los archivos y otros artefactos del proyecto de aplicación lógica. Por ejemplo, el archivo workflow.json es el archivo de definición de flujo de trabajo donde puede compilar el flujo de trabajo.
< nombre de función>	Contiene los archivos y otros artefactos del proyecto de funciones de .NET. Por ejemplo, el archivo <function-name>.cs es el archivo de código donde puede crear el código.

Para la indicación Habilitar conectores para Azure en Logic Apps <logic-app-name>, seleccione Usar conectores de Azure.
En el mensaje Seleccionar suscripción, seleccione la suscripción de Azure que desee.
Para el mensaje de Seleccionar un grupo de recursos para nuevos recursos, seleccione el grupo de recursos que desee o Crear nuevo grupo de recursos.
En el recuadro Seleccionar una ubicación para los nuevos recursos, elija la región Azure para la implementación.

En el Seleccionar método de autenticación para conectores Azure, seleccione el tipo de autenticación que se usará para las conexiones que necesitan autenticación.

Tipo de autenticación	Descripción
Identidad administrada	Seleccione Managed Service Identity para usar la identidad asignada por el sistema o asignada por el usuario en el recurso de la aplicación lógica. De forma predeterminada, los recursos de aplicación lógica estándar ya tienen habilitada la identidad asignada por el sistema. Aun así, debe configurar la identidad con acceso mediante roles en el recurso de destino, además de cualquier otro requisito. Para obtener más información, consulte Asignación de acceso basado en roles a una identidad administrada.
Claves de conexión	Configure el acceso al recurso de destino mediante cadenas de conexiones y claves de acceso.

Tipo de autenticación

Descripción

Identidad administrada

Seleccione Managed Service Identity para usar la identidad asignada por el sistema o asignada por el usuario en el recurso de la aplicación lógica.

De forma predeterminada, los recursos de aplicación lógica estándar ya tienen habilitada la identidad asignada por el sistema. Aun así, debe configurar la identidad con acceso mediante roles en el recurso de destino, además de cualquier otro requisito.

Para obtener más información, consulte Asignación de acceso basado en roles a una identidad administrada.

Claves de conexión

Configure el acceso al recurso de destino mediante cadenas de conexiones y claves de acceso.

Después de completar estos pasos, continúe con la sección siguiente para que pueda crear el código.

2: Escribir el código

En la ventana Explorador, expanda la carpeta del proyecto de función y abra el < archivo function-name>.cs.

Este archivo contiene código de ejemplo y elementos de código específicos con los valores proporcionados anteriormente.

En este ejemplo, el archivo de función WeatherForecast.cs contiene estos elementos de código con valores de ejemplo:

Elemento de Código	Importancia
Nombre del espacio de nombres	`Contoso.Enterprise`
Nombre de clase	`WeatherForecast`
Nombre de función	`WeatherForecast`
Parámetros de función	`zipCode`, `temperatureScale`
Tipo de valor devuelto	`Task<Weather>`
Tipo complejo	`Weather`

A continuación se muestra un ejemplo de código de ejemplo 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; }
        }
    }
}

La definición de función incluye un método predeterminado Run que puede usar para empezar. En este ejemplo Run método se muestran algunas funcionalidades disponibles con la característica de funciones personalizadas, como pasar entradas y salidas diferentes, incluidos tipos de .NET complejos.

El < archivo function-name>.cs también incluye la interfaz que proporciona soporte para el ILogger registro de eventos en un recurso de Application Insights. Puede enviar información de seguimiento a Application Insights y almacenar esa información con la información de seguimiento de los flujos de trabajo, por ejemplo:

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);

    <...>

}

Reemplace el código de función de ejemplo por el suyo propio y edite el método predeterminado Run para sus escenarios específicos. O bien, puede copiar la función, incluida la declaración [FunctionName("<function-name>")] y, a continuación, cambiar el nombre de la función por un nombre único. Puede editar la función que se volvió a nombrar para satisfacer sus necesidades.

Este ejemplo continúa con el código de ejemplo original, suponiendo que no haya cambios.

3: Compilar y construir el código

Cuando termines de escribir tu código, compiláralo para asegurarte de que no existen errores de compilación. Tu proyecto .NET functions incluye automáticamente tareas de compilación que compilan y añaden tu código a la carpeta lib\custom en tu proyecto de Logic App. Los flujos de trabajo buscan funciones personalizadas en esta carpeta. En función de la versión de .NET, estas tareas colocan los ensamblados en la carpeta lib\custom\net472 o lib\custom\net8.

Siga estos pasos:

En Visual Studio Code, en la barra de actividades, seleccione Explorer.
En la ventana Explorador , abra el menú contextual de la carpeta del proyecto de functions y seleccione Compilar proyecto de funciones.

La tarea de compilación se ejecuta para el proyecto de funciones. Si la compilación se realiza correctamente, la ventana Terminal muestra un mensaje Compilación correcta .
Confirme que existen los siguientes elementos en el proyecto de aplicación lógica:
- En el área de trabajo, expanda las siguientes carpetas: <your-logic-app>>lib\custom>net472 o net8, en función de la versión de .NET. Confirma que la subcarpeta net472 o net8 contiene los archivos ensamblador (DLL) necesarios para ejecutar tu código, incluyendo un archivo llamado <nombre> de función.dll.
- En el área de trabajo, expande las siguientes carpetas: <tu aplicación lógica>>lib\custom><function-name>. Comprueba que la subcarpeta <function-name> contiene un archivo function.json, que incluye los metadatos del código de la función que has escrito. El diseñador de flujo de trabajo usa este archivo para determinar las entradas y salidas necesarias al llamar al código.
En el ejemplo siguiente se muestran ensamblados generados de ejemplo y otros archivos en el proyecto de aplicación lógica:

4: Llamar al código a través del flujo de trabajo

Después de confirmar que el código se compila y el proyecto de aplicación lógica contiene los archivos necesarios para que se ejecute el código, configure el flujo de trabajo para llamar al código.

En la ventana Explorador, expanda <workspace-name>, <logic-app-name> y, a continuación<, workflow-name>.

Abra el menú contextual de workflow.jsony seleccione Abrir diseñador.

El diseñador de flujo de trabajo se abre y muestra el flujo de trabajo predeterminado con el siguiente desencadenador y acciones:

Operación	Descripción
Trigger	Desencadenador de solicitud integrado denominado Cuando se recibe una solicitud HTTP.
Acción	La acción integrada denominada Llamar a una función local en esta aplicación lógica.
Acción	La acción de respuesta integrada denominada Respuesta se utiliza para responder a la persona que llama solo cuando se emplea el desencadenador Petición.

En el diseñador, seleccione la acción llamada Llamar a una función local en esta aplicación lógica.

Se abre el panel de información de la acción para que pueda configurar la llamada de función personalizada, por ejemplo:
Revise y confirme que el valor del parámetro Nombre de función está establecido en la función que desea ejecutar. Revise o cambie cualquier otro valor de parámetro que use la función.

5: Depurar el código y el flujo de trabajo

Para cada uno de los siguientes servicios de Azure Storage, inicie el emulador de almacenamiento de Azurite:
- Servicio Blob de Azure
- Azure Queue Service
- Azure Table Service (Servicio de Tabla de Azure)
1. En el menú Visual Studio Code View, seleccione Paleta de comandos.
2. En el mensaje que aparece, seleccione Azurite: Start Blob Service en la lista.
3. En la lista de directorios de trabajo que aparece, seleccione la aplicación lógica.
4. Repita estos pasos para Azurite: Iniciar Queue Service y Azurite: Iniciar Table Service.
Si se ejecuta correctamente, la barra de tareas Visual Studio Code en la parte inferior de la pantalla muestra los tres servicios de almacenamiento en ejecución.
Adjunte el depurador tanto al proyecto de aplicación lógica como al proyecto de funciones de .NET siguiendo estos pasos:
1. En Visual Studio Code, en la barra de actividades, seleccione Run and Debug (teclado: Ctrl+Mayús+D).
2. En la lista Ejecutar y depurar, seleccione Ejecutar/Depurar aplicación lógica con función local (<su aplicación lógica>) y, a continuación, seleccione Ejecutar (flecha verde).
  
  Se producen los siguientes eventos:
  - Se abre la ventana Terminal y se muestra el proceso de depuración iniciado.
  - La ventana de la Consola de Depuración se abre y muestra el estado de depuración.
  - En la parte inferior de Visual Studio Code, la barra de tareas se vuelve naranja, lo que indica que se carga el depurador .NET.
Para establecer los puntos de interrupción, en la definición de función (<nombre> de función.cs) o definición de flujo de trabajo (workflow.json), busque el número de línea donde desee el punto de interrupción y seleccione la columna adyacente, por ejemplo:
Para ejecutar manualmente el desencadenador de Solicitud en su flujo de trabajo, abra la página de Resumen del flujo de trabajo:
1. En el proyecto de aplicación lógica, abra el menú contextual del archivoworkflow.json y, a continuación, seleccione Información general.
  
  En la página Información general del flujo de trabajo, el botón Ejecutar desencadenador está disponible para cuando desee iniciar manualmente el flujo de trabajo. En Propiedades del flujo de trabajo, el valor de Dirección URL de devolución de llamada es la dirección URL de un punto de conexión al que se puede llamar creado por el desencadenador Solicitud en el flujo de trabajo. Puede enviar solicitudes a esta dirección URL para desencadenar el flujo de trabajo desde otras aplicaciones, incluidos otros flujos de trabajo de aplicaciones lógicas.
2. En la barra de herramientas de la página Información general, seleccione Ejecutar desencadenador.
  
  Una vez que el flujo de trabajo comienza a ejecutarse, el depurador activa el primer punto de interrupción.
3. En el menú Ejecutar o en la barra de herramientas del depurador, seleccione una acción de depuración.
Una vez completada la ejecución del flujo de trabajo, la página Información general muestra la ejecución finalizada y los detalles básicos sobre esa ejecución.
Para revisar más información sobre la ejecución del flujo de trabajo, seleccione la ejecución finalizada. O bien, en la lista situada junto a la columna Duración, seleccione Mostrar ejecución.

6: Implementación del código

Implemente las funciones personalizadas de la misma manera que implemente el proyecto de aplicación lógica. Tanto si despliegas desde Visual Studio Code como si usas un proceso DevOps de CI/CD, asegúrate de compilar tu código antes de desplegar. Además, asegúrate de que todos los ensambladores dependientes existan en las siguientes carpetas de proyectos de Logic App antes de desplegar:

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

Para obtener más información, consulte Deploy Standard workflows from Visual Studio Code to Azure.

Inserción de dependencia

Al elegir .NET 8, el código de .NET personalizado en flujos de trabajo estándar admite inserción de dependencias (DI). Esta funcionalidad le permite registrar servicios una vez, lo que hace que estén disponibles automáticamente para las funciones de código personalizadas en tiempo de ejecución, en lugar de crear dependencias dentro de cada función.

Nota:

Solo los proyectos de código personalizado de .NET 8 en Visual Studio Code admiten la inyección de dependencias.

Sin la inserción de dependencias, las funciones de código personalizadas suelen:

Cree instancias de servicio directamente en la función .
Lógica duplicada entre varias funciones o flujos de trabajo.
Combina la lógica de negocios con el código de instalación y configuración.

A medida que crecen los flujos de trabajo, el código personalizado se vuelve más difícil de probar, reutilizar y mantener. Utilizando la inyección de dependencia, puedes:

Separe la lógica de negocios de la ejecución del flujo de trabajo.
Reutilizar servicios compartidos en varias funciones de código personalizadas.
Alinee el código personalizado con patrones de desarrollo de .NET estándar.

El código personalizado se vuelve más fácil de administrar en los flujos de trabajo de producción, especialmente cuando varios flujos de trabajo dependen de la misma lógica.

Cuándo usar la inserción de dependencias

Si tiene funciones de código personalizadas simples o únicas, probablemente no necesite la inserción de dependencias. Sin embargo, si tu código personalizado cumple con los siguientes requisitos, considera usar la inyección de dependencias:

Varios flujos de trabajo usan o comparten las mismas funciones de código personalizadas.
Las funciones de código personalizadas contienen lógica de enrutamiento o negocio que cambia con el tiempo.
Necesita una mejor capacidad de prueba o mantenimiento a largo plazo.

¿Cómo afecta la inserción de dependencias a las funciones de .NET personalizadas?

La inserción de dependencias no cambia la forma de llamar a funciones de .NET personalizadas ni al comportamiento del flujo de trabajo. Esta funcionalidad solo cambia la estructura de código personalizada subyacente, pero genera el mismo resultado. En los pasos siguientes se describe este proceso:

Azure Logic Apps carga el proyecto de código personalizado.
Azure Logic Apps crea instancias, registra e inserta los servicios necesarios en la función .
La función se ejecuta mediante las dependencias insertadas.

Habilitar la inyección de dependencias

Para usar la inserción de dependencias con el código de .NET personalizado, complete los siguientes requisitos:

Al crear el proyecto de código personalizado, seleccione .NET 8.

Solo .NET 8 proyectos de código personalizados admiten la inserción de dependencias.

En el proyecto, agregue una StartupConfiguration clase para definir la lista de dependencias. Implemente la IConfigureStartup interfaz y registre las dependencias mediante IServiceCollection, por ejemplo:

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>();
    }
}

La IConfigureStartup interfaz está definida en Microsoft.Azure.Functions.Extensions.Workflows, mientras IServiceCollection que está definida en Microsoft.Extensions.DependencyInjection. Para más información, véase StartupConfiguration.cs.

En el constructor de la clase de función de código personalizado, inicialice los servicios registrados definiéndolas como parámetros de constructor, en lugar de crearlos dentro de la función, por ejemplo:

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

}

Más allá de compilar e implementar el proyecto de código personalizado, no es necesario realizar ningún otro paso, editar el flujo de trabajo ni realizar ningún otro cambio de configuración en Azure Logic Apps para habilitar la inserción de dependencias.

Para obtener más información, consulte el ejemplo de inserción de dependencias de código personalizado.

Lleva tus propios paquetes NuGet a proyectos de código personalizados

En el caso de los proyectos de código personalizado basados en NuGet que usan .NET 8, puede incluir y administrar sus propios paquetes NuGet sin tener que resolver conflictos con las dependencias usadas por el host de trabajo del lenguaje. Solo tiene que agregar directamente las dependencias de ensamblado a la ubicación de ensamblado independiente en su proyecto. Con las siguientes excepciones, puede traer las versiones de ensamblado dependientes compatibles con .NET 8 que necesite el proyecto:

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

Solucionar problemas

Error del panel de información de acción

En el diseñador de flujos de trabajo, al seleccionar la acción integrada denominada Llamar a una función local en esta aplicación lógica, el panel de información de la acción muestra el mensaje siguiente:

Failed to retrieve dynamic inputs. Error details:

En este escenario, compruebe el proyecto de aplicación lógica para ver si la carpeta LogicApp\lib\custom está vacía. Si está vacío, en el menú Terminal, seleccione Ejecutar tarea> funciones de compilación.

Actualmente no se está ejecutando ningún proceso con el nombre especificado.

Si recibe este mensaje de error al ejecutar el flujo de trabajo, es probable que asocie el proceso del depurador a .NET Functions, en lugar de a la aplicación lógica.

Para solucionar este problema, en la lista Ejecutar y depurar, seleccione Asociar a la aplicación lógica (LogicApp) y, a continuación, seleccione Reproducir (flecha verde).

Paquete no importado correctamente

Si la ventana Salida muestra un error similar al siguiente mensaje, asegúrese de que tiene al menos .NET 6.0 instalado. Si tiene instalada esta versión, intente desinstalarla y volver a instalarla.

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]

Fallos de compilación con errores CS1031 y CS1001

Si la función no incluye variables y compila el código, la ventana Salida podría mostrar los siguientes mensajes de error:

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 corregir este problema, en el método del Run código, agregue el siguiente parámetro:

string parameter1 = null

En el ejemplo siguiente se muestra cómo aparece la firma del método Run:

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

Crear flujos de trabajo de aplicaciones lógicas estándar con Visual Studio Code

Comentarios

¿Le ha resultado útil esta página?

Last updated on 2026-09-15

Crea y ejecuta funciones locales en flujos de trabajo estándar para Azure Logic Apps

Requisitos previos

Limitaciones

1: Creación de un proyecto de código

2: Escribir el código

3: Compilar y construir el código

4: Llamar al código a través del flujo de trabajo

5: Depurar el código y el flujo de trabajo

6: Implementación del código

Inserción de dependencia

Cuándo usar la inserción de dependencias

¿Cómo afecta la inserción de dependencias a las funciones de .NET personalizadas?

Habilitar la inyección de dependencias

Lleva tus propios paquetes NuGet a proyectos de código personalizados

Solucionar problemas

Error del panel de información de acción

Actualmente no se está ejecutando ningún proceso con el nombre especificado.

Paquete no importado correctamente

Fallos de compilación con errores CS1031 y CS1001

Contenido relacionado

Comentarios

Recursos adicionales