Maak lokale functies aan en voer uit in standaardworkflows voor Azure Logic Apps

Van toepassing op: Azure Logic Apps (Standard)

Wanneer je integratieworkflow logica nodig heeft buiten de ingebouwde operaties en vooraf gebouwde connectoren, maak dan een lokale functie waarbij de code specifiek blijft voor je logica-appoplossing. Deze lokale functie is aangepaste .NET-code die je schrijft, uitvoert, debuggt en deployt in hetzelfde Azure Logic Apps Standard-project als de aanroeperworkflows. Door de functie lokaal te houden, kun je de workflow en de aangepaste code als één app ontwikkelen, beveiligen, deployen, opschalen en beheren.

Lokale functies helpen uw workflows taken uit te voeren zoals:

Implementeer aangepaste bedrijfslogica en berekeningen.
Verwerk bedrijfseigen of complexe inkomende berichten.
Valideer, verrijk of voer eenvoudige transformaties uit op data.
Vorm uitgaande berichten voor een API, connector of partnersysteem.
Hergebruik geschikte .NET-hulplogica uit bestaande integratieoplossingen, inclusief BizTalk Server-migratiescenario's.

Met lokale functies kunt u de volgende doelen bereiken:

Doel	Vermogen
Ontwikkel en debug één oplossing	Maak de workflow en lokale functie aan in dezelfde Visual Studio Code-werkruimte en doorloop beide in één debugsessie.
Samen uitzetten	Bouw en deploy de lokale functie naast de caller-workflows zonder een apart serviceplan te provisioneren.
Verminder de grenzen van de dienstverlening	Vermijd een aparte Function-app, HTTP-endpoint, authenticatieflow en netwerkhop voor workflow-specifieke code.
Combineer low-code- en pro-code-hulpmiddelen	Gebruik connectors en workflow-orkestratie voor de integratieflow. Gebruik lokale functies voor gespecialiseerde .NET-logica.

Een lokale functie verschilt van een functie die in een aparte functie-app wordt gehost in Azure Functions. Azure Functions werkt het beste wanneer je code een onafhankelijk endpoint moet openstellen, gedeeld moet worden tussen apps, een eigen implementatie- en versiecyclus moet volgen, of onafhankelijk moet schalen. Wanneer je code moet werken binnen een specifieke Azure Logic Apps Standard-oplossing en de applicatielevenscyclus moet delen met de workflows van de aanroeper, gebruik dan een lokale functie.

Deze gids laat zien hoe je lokale .NET-functies voor standaardworkflows kunt creëren, bouwen, aanroepen, debuggen en uitrollen met behulp van Visual Studio Code.

Notitie

Lokale functies zijn niet geschikt voor de volgende scenario's:

Draaiende processen die mogelijk langer duren dan 10 minuten.
Gebruik van BizTalk Server-pijplijncomponenten die streaming implementeren.

Zie Beperkingen voor meer informatie.

Vereisten

Een Azure-account en -abonnement. Get een gratis Azure-account.
De meest recente Visual Studio Code met de extensie Azure Logic Apps (Standard).

Zie Create Standard workflows in single-tenant Azure Logic Apps with Visual Studio Code voor vereisten.

De extensie biedt de volgende mogelijkheden en voordelen:
- Schrijf uw eigen code door functies te maken die de flexibiliteit en controle hebben om uw meest uitdagende integratieproblemen op te lossen.
- Code lokaal debuggen in Visual Studio Code. Doorloop uw code en werkstromen in dezelfde foutopsporingssessie.
- Code naast uw werkstromen implementeren. Er zijn geen andere serviceplannen nodig.
- Ondersteuning voor BizTalk Server migratiescenario's, zodat u aangepaste .NET investeringen van on-premises naar de cloud kunt verplaatsen.
Een lokale map die moet worden gebruikt voor uw codeproject.

Beperkingen

Je kunt lokale functies alleen maken in Visual Studio Code die op Windows draait. Deze functionaliteit ondersteunt .NET Framework en .NET 8 voor standaardworkflows die worden gehost op Workflow Service Plan, App Service Environment v3 (ASE v3) of Hybrid.
U kunt geen aangepaste functies schrijven in de Azure-portal. Als u echter wilt werken met uitvoer van aangepaste functies in uw werkstroom, voert u de volgende stappen uit:
1. Nadat u uw functies hebt geïmplementeerd in Azure, volgt u de stappen in Call your code from a workflow voor de Azure-portal.
2. Voeg de ingebouwde actie met de naam Een lokale functie aanroepen in deze logische app toe aan uw werkstroom. Selecteer de geïmplementeerde aangepaste functies die u wilt gebruiken en voer uw code uit.
3. Gebruik volgende werkstroomacties om te verwijzen naar de uitvoer van de aangepaste functie, zoals in elke andere werkstroom. U kunt de uitvoeringsgeschiedenis, invoer en uitvoer van de ingebouwde actie bekijken.

Zie Limits en configuratiereferenties voor Azure Logic Apps voor algemene beperkingen.

1: Een codeproject maken

De extensie Azure Logic Apps (Standard) voor Visual Studio Code bevat een codeprojectsjabloon die een gestroomlijnde ervaring biedt voor het schrijven, opsporen van fouten en het implementeren van uw eigen code met uw werkstromen. Met deze projectsjabloon maakt u een werkruimtebestand en twee voorbeeldprojecten: één project om uw code en een ander project te schrijven om uw werkstromen te maken.

Notitie

U kunt niet dezelfde projectmap gebruiken voor zowel uw code als werkstromen.

Voer de volgende stappen uit om een codeproject te maken:

Meld u aan bij uw Azure-account in Visual Studio Code.

Als het aanmelden langer duurt dan gebruikelijk, vraagt Visual Studio Code u zich aan te melden via een Microsoft-verificatiewebsite door u een apparaatcode aan te bieden. Volg deze stappen om u aan te melden met behulp van de code:
1. Selecteer Apparaatcode gebruiken en selecteer vervolgens Kopiëren en openen.
2. Selecteer Koppeling openen om een nieuw browservenster te openen en ga door naar de verificatiewebsite.
3. Voer op de pagina Aanmelden bij uw account uw verificatiecode in en selecteer Volgende.
Selecteer op de activiteitenbalk het pictogram Azure.
Ga in het venster Azure naar de sectie Werkruimte. Verplaats de aanwijzer over het titelgebied, zodat de werkbalk wordt weergegeven.
Selecteer in het menu Azure Logic Apps Nieuwe werkruimte voor logische apps maken.
In het venster Map selecteren, blader naar de lokale projectmap, selecteer de map en klik vervolgens op Selecteren.
Voer in het venster Nieuwe werkruimte voor logische app maken een naam in voor de werkruimtenaamprompt en druk op Enter.

In dit voorbeeld wordt de naam van de werkruimte gebruikt weather-app :
Selecteer voor de prompt Selecteer een sjabloon voor uw nieuwe project de optie Logic app met aangepast code-project.
Voor de prompt Selecteer een doelframework, selecteer .NET Framework of .NET 8.

Volg de volgende aanwijzingen om de volgende informatie op te geven:

Snel	Voorbeeldwaarde
Naam van de Logic App	`weather-logic-app`
Function-naam voor uw .NET functions-project	`WeatherForecast`
Namespace voor uw .NET functions-project	`Contoso.Enterprise`
Selecteer een sjabloon voor de eerste werkstroom van uw project: - Werkstroom met status - Staatloze werkstroom - Autonome agent - Gespreksagent - Nu overslaan	Stateful werkstroom
Werkstroomnaam	`weather-workflow`

Als u wilt selecteren hoe u de projectprompt wilt openen , selecteert u Openen in het huidige venster.

Nadat u deze stap hebt voltooid, maakt Visual Studio Code uw werkruimte, waaronder een .NET functions-project en een logic app-project, standaard:

Screenshot die de aangemaakte werkruimte toont met het logic app-project en het .NET functions-project.

Noteer in het Verkenner-venster de volgende mappen in uw werkruimte:

Map	Beschrijving
< werkruimtenaam>	Bevat zowel uw .NET functions-project als het werkstroomproject van de logische app.
< logic-app-naam>	Bevat de bestanden en andere artefacten voor uw logische app-project. Het workflow.json bestand is bijvoorbeeld het werkstroomdefinitiebestand waar u uw werkstroom kunt bouwen.
< functienaam>	Bevat de bestanden en andere artefacten voor uw .NET functions-project. Het bestand met de <functienaam>.cs is bijvoorbeeld het codebestand waarin u uw code kunt ontwerpen.

Voor de Schakel connectors in voor Azure voor Logic Apps <logic-app-name> melding, kiest u Gebruik connectors van Azure.
Selecteer voor de prompt Select subscription het gewenste Azure abonnement.
Bij de prompt Een resourcegroep selecteren voor nieuwe resources, selecteer de gewenste resourcegroep of maak een nieuwe resourcegroep aan.
Voor de prompt Selecteer een locatie voor nieuwe resources, selecteer de Azure-regio voor deployment.

Selecteer voor de Selecteer de verificatiemethode voor Azure connectors het verificatietype dat moet worden gebruikt voor verbindingen die verificatie nodig hebben.

Verificatietype	Beschrijving
Beheerde identiteit	Selecteer Managed Service Identity om de door het systeem toegewezen of door de gebruiker toegewezen identiteit in uw logische app-resource te gebruiken. Standaard is de door het systeem toegewezen identiteit al ingeschakeld voor de standaard logische app-resources. U moet echter de identiteit instellen met roltoegang voor de doelresource plus eventuele andere vereisten. Zie Toegang op basis van rollen toewijzen aan een beheerde identiteit voor meer informatie.
Verbindingssleutels	Toegang tot de doelresource instellen met behulp van verbindingsreeksen en toegangssleutels.

Verificatietype

Beschrijving

Beheerde identiteit

Selecteer Managed Service Identity om de door het systeem toegewezen of door de gebruiker toegewezen identiteit in uw logische app-resource te gebruiken.

Standaard is de door het systeem toegewezen identiteit al ingeschakeld voor de standaard logische app-resources. U moet echter de identiteit instellen met roltoegang voor de doelresource plus eventuele andere vereisten.

Zie Toegang op basis van rollen toewijzen aan een beheerde identiteit voor meer informatie.

Verbindingssleutels

Toegang tot de doelresource instellen met behulp van verbindingsreeksen en toegangssleutels.

Nadat u deze stappen hebt voltooid, gaat u verder met de volgende sectie, zodat u uw code kunt ontwerpen.

2: Uw code schrijven

Vouw in het verkennervenster de map van het functieproject uit en open de <functienaam>.cs bestand.

Dit bestand bevat voorbeeldcode en specifieke code-elementen met waarden die u eerder hebt opgegeven.

In dit voorbeeld bevat het WeatherForecast.cs functiebestand deze code-elementen met voorbeeldwaarden:

Code-element	Waarde
Naam van naamruimte	`Contoso.Enterprise`
Klassenaam	`WeatherForecast`
Functienaam	`WeatherForecast`
Functieparameters	`zipCode`, `temperatureScale`
Retourtype	`Task<Weather>`
Complexe type	`Weather`

In het volgende voorbeeld ziet u de volledige voorbeeldcode:

//------------------------------------------------------------
// 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; }
        }
    }
}

De functiedefinitie bevat een standaardmethode Run die u kunt gebruiken om aan de slag te gaan. In dit voorbeeld Run methode ziet u enkele mogelijkheden die beschikbaar zijn met de functie aangepaste functies, zoals het doorgeven van verschillende invoer- en uitvoergegevens, waaronder complexe .NET typen.

De <functienaam>.cs bestand bevat ook de ILogger interface die ondersteuning biedt voor het vastleggen van gebeurtenissen in een Application Insights-resource. U kunt traceringsgegevens verzenden naar Application Insights en die informatie opslaan met de traceringsgegevens uit uw werkstromen, bijvoorbeeld:

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

    <...>

}

Vervang de voorbeeldfunctiecode door uw eigen code en bewerk de standaardmethode Run voor uw specifieke scenario's. U kunt de functie ook kopiëren, inclusief de [FunctionName("<function-name>")] declaratie, en vervolgens de naam van de functie wijzigen met een unieke naam. Vervolgens kunt u de hernoemde functie bewerken om aan uw behoeften te voldoen.

In dit voorbeeld wordt de oorspronkelijke voorbeeldcode voortgezet, ervan uitgaande dat er geen wijzigingen zijn.

3: Uw code compileren en bouwen

Nadat je je code hebt geschreven, compileer je deze om zeker te zijn dat er geen bouwfouten zijn. Je .NET Functions-project bevat automatisch buildtaken die je code compileren en aan de map lib\custom in je Logic Apps-project toevoegen. Workflows zoeken naar aangepaste functies in deze map. Afhankelijk van uw .NET versie worden de assembly's in de map lib\custom\net472 of lib\custom\net8 geplaatst.

Volg deze stappen:

Selecteer in Visual Studio Code op de activiteitenbalk Explorer.
Open het snelmenu voor de functies-projectfolder in de Verkenner en selecteer Bouw functies-project.

De build-taak wordt uitgevoerd voor het functions-project. Als uw build slaagt, wordt in het terminalvenster een bericht weergegeven dat het bouwen is voltooid .
Controleer of de volgende items aanwezig zijn in uw logische app-project:
- Vouw in uw werkruimte de volgende mappen uit: <your-logic-app>>lib\custom>net472 of net8, gebaseerd op uw .NET versie. Bevestig dat de submap net472 of net8 de assembly (DLL) bestanden bevat die nodig zijn om je code uit te voeren, inclusief een bestand met functienaam><.dll.
- Vouw in uw werkruimte de volgende mappen uit: <uw logische app>>lib\custom><function-name>. Controleer of de <functienaam-submap> een function.json bestand bevat, waarin de metadata over de functiecode die je hebt geschreven bevat. De werkstroomontwerper gebruikt dit bestand om de benodigde invoer en uitvoer te bepalen bij het aanroepen van uw code.
In het volgende voorbeeld ziet u voorbeeld van gegenereerde assembly's en andere bestanden in het project van de logische app:

4: Uw code aanroepen vanuit een werkstroom

Nadat u hebt bevestigd dat uw code wordt gecompileerd en uw logische app-project de benodigde bestanden bevat om uw code uit te voeren, stelt u uw werkstroom in om uw code aan te roepen.

In het Verkenner-venster, vouw <werkruimtenaam>, <logic-app-naam>, en vervolgens <werkstroomnaam> uit.

Open het snelmenu voor workflow.jsonen selecteer Ontwerpfunctie openen.

De werkstroomontwerper wordt geopend en toont de standaardwerkstroom met de volgende trigger en acties:

Operatie	Beschrijving
Aanleiding	De ingebouwde aanvraagtrigger met de naam Wanneer een HTTP-aanvraag wordt ontvangen.
Action	De ingebouwde actie met de naam Een lokale functie aanroepen in deze logische app.
Action	De ingebouwde antwoordactie met de naam Antwoord die u gebruikt om de beller alleen te beantwoorden wanneer u de aanvraagtrigger gebruikt.

Selecteer in de ontwerper de actie Een lokale functie aanroepen in deze logische app.

Het informatievenster van de actie wordt geopend, zodat u de aangepaste functieoproep kunt instellen, bijvoorbeeld:
Controleer en controleer of de parameterwaarde van de functienaam is ingesteld op de functie die u wilt uitvoeren. Controleer of wijzig andere parameterwaarden die door uw functie worden gebruikt.

5: Fouten opsporen in uw code en werkstroom

Voor elk van de volgende Azure Storage-services start u de Azurite opslagemulator.
- Azure Blob Service
- Azure-wachtrijservice
- Azure Table Service
1. Selecteer in het menu Visual Studio Code WeergaveOpdrachtpalet.
2. Bij de prompt die wordt weergegeven, selecteert u Azurite: Blob Service starten in de lijst.
3. Selecteer uw logische app in de lijst met werkmap die wordt weergegeven.
4. Herhaal deze stappen voor Azurite: Start Queue Service en Azurite: Start Table Service.
Als u succesvol bent, worden in de Visual Studio Code taakbalk onder aan het scherm de drie opslagservices weergegeven die worden uitgevoerd.
Koppel het foutopsporingsprogramma aan zowel uw logische app-project als .NET functions-project door de volgende stappen uit te voeren:
1. Selecteer in Visual Studio Code op de activiteitenbalk Run and Debug (toetsenbord: Ctrl+Shift+D).
2. Selecteer in de lijst Uitvoeren en fouten opsporen de logische app Uitvoeren/fouten opsporen met de lokale functie (<uw logische app>) en selecteer vervolgens Afspelen (groene pijl).
  
  De volgende gebeurtenissen vinden plaats:
  - Het terminalvenster wordt geopend en toont het gestarte foutopsporingsproces.
  - Het Debugconsole-venster opent en toont de debugstatus.
  - Onderaan Visual Studio Code wordt de taakbalk oranje, waarmee wordt aangegeven dat het .NET foutopsporingsprogramma is geladen.
Als u onderbrekingspunten wilt instellen, zoekt u in de functiedefinitie (<functienaam>.cs) of werkstroomdefinitie (workflow.json), het regelnummer waar u het onderbrekingspunt wilt gebruiken en selecteert u de aangrenzende kolom, bijvoorbeeld:
Als u de aanvraagtrigger handmatig wilt uitvoeren in uw werkstroom, opent u de overzichtspagina van de werkstroom:
1. Open vanuit uw logische app-project het snelmenu van het workflow.json bestand en selecteer Vervolgens Overzicht.
  
  Op de overzichtspagina vande werkstroom is de knop Trigger uitvoeren beschikbaar voor wanneer u de werkstroom handmatig wilt starten. Onder Werkstroomeigenschappen is de waarde van de callback-URL de URL voor een aanroepbaar eindpunt dat is gemaakt door de aanvraagtrigger in uw werkstroom. U kunt aanvragen verzenden naar deze URL om uw werkstroom te activeren vanuit andere apps, inclusief andere werkstromen voor logische apps.
2. Selecteer op de werkbalk van de Overzichtspagina de optie Trigger uitvoeren.
  
  Nadat uw werkstroom is gestart, activeert de debugger uw eerste onderbrekingspunt.
3. Selecteer een debugactie in het menu Uitvoeren of op de foutopsporingswerkbalk.
Nadat de uitvoering van de werkstroom is voltooid, ziet u op de pagina Overzicht de voltooide uitvoering en de basisinformatie over die uitvoering.
Als u meer informatie over de uitvoering van de werkstroom wilt bekijken, selecteert u de voltooide uitvoering. U kunt ook de optie Uitvoeren weergeven selecteren in de lijst naast de kolom Duur.

6: Uw code implementeren

Implementeer uw aangepaste functies op dezelfde manier als u uw logische app-project implementeert. Of je nu deployt vanuit Visual Studio Code of een CI/CD DevOps-proces gebruikt, zorg ervoor dat je je code bouwt voordat je deployt. Zorg er ook voor dat alle afhankelijke assemblies in de volgende logic app projectmappen aanwezig zijn voordat je deployeert:

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

Zie Deploy Standard-werkstromen van Visual Studio Code naar Azure voor meer informatie.

Afhankelijkheidsinjectie

Wanneer u .NET 8 kiest, ondersteunt aangepaste .NET code in standaardwerkstromen dependency-injectie (DI). Met deze mogelijkheid kunt u services eenmaal registreren, waardoor deze automatisch beschikbaar worden gemaakt voor uw aangepaste codefuncties tijdens runtime, in plaats van afhankelijkheden binnen elke functie te maken.

Notitie

Alleen .NET 8 aangepaste code-projecten in Visual Studio Code ondersteunen afhankelijkheidsinjectie.

Zonder afhankelijkheidsinjectie zijn aangepaste codefuncties vaak:

Maak service-exemplaren rechtstreeks in de functie.
Dubbele logica voor meerdere functies of werkstromen.
Combineer bedrijfslogica met installatie- en configuratiecode.

Naarmate werkstromen groeien, wordt aangepaste code moeilijker te testen, opnieuw te gebruiken en te onderhouden. Door gebruik te maken van afhankelijkheidsinjectie kun je:

Scheid bedrijfslogica van werkstroomuitvoering.
Gedeelde services hergebruiken in meerdere aangepaste codefuncties.
Aangepaste code uitlijnen met standaard-.NET ontwikkelingspatronen.

Aangepaste code wordt beter beheerbaar in productiewerkstromen, met name wanneer meerdere werkstromen afhankelijk zijn van dezelfde logica.

Wanneer gebruikt u afhankelijkheidsinjectie?

Als u eenvoudige of eenmalige aangepaste codefuncties hebt, hebt u waarschijnlijk geen afhankelijkheidsinjectie nodig. Als je aangepaste code echter de volgende vereisten heeft, overweeg dan dependency injection:

Meerdere werkstromen gebruiken of delen dezelfde aangepaste codefuncties.
Uw aangepaste codefuncties bevatten bedrijfs- of routeringslogica die na verloop van tijd verandert.
U hebt betere testbaarheid of onderhoud op lange termijn nodig.

Hoe heeft afhankelijkheidsinjectie invloed op aangepaste .NET functies

Afhankelijkheidsinjectie verandert niet hoe u aangepaste .NET functies of uw werkstroomgedrag aanroept. Deze mogelijkheid wijzigt alleen de onderliggende aangepaste codestructuur, maar produceert hetzelfde resultaat. In de volgende stappen wordt dit proces beschreven:

Azure Logic Apps uw aangepaste codeproject laadt.
Azure Logic Apps instantieert, registreert en injecteert de vereiste services in de functie.
De functie wordt uitgevoerd met behulp van de geïnjecteerde afhankelijkheden.

Afhankelijkheidsinjectie inschakelen

Als u afhankelijkheidsinjectie wilt gebruiken met uw aangepaste .NET code, moet u de volgende vereisten voltooien:

Wanneer u uw aangepaste codeproject maakt, selecteert u .NET 8.

Alleen .NET 8 aangepaste codeprojecten ondersteunen afhankelijkheidsinjectie.

Voeg in uw project een StartupConfiguration klasse toe om de lijst met afhankelijkheden te definiëren. Implementeer de IConfigureStartup interface en registreer uw afhankelijkheden met behulp van IServiceCollectionbijvoorbeeld:

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

De IConfigureStartup interface is gedefinieerd in Microsoft.Azure.Functions.Extensions.Workflows, terwijl IServiceCollection gedefinieerd is in Microsoft.Extensions.DependencyInjection. Voor meer informatie, zie StartupConfiguration.cs.

Initialiseer in de klasseconstructor van de aangepaste codefunctie de geregistreerde services door ze te definiëren als constructorparameters, in plaats van ze in de functie te maken, bijvoorbeeld:

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

}

Naast het bouwen en implementeren van uw aangepaste codeproject hoeft u geen andere stappen uit te voeren, uw werkstroom te bewerken of andere installatiewijzigingen aan te brengen in Azure Logic Apps om afhankelijkheidsinjectie in te schakelen.

Zie het voorbeeld van aangepaste codeafhankelijkheidsinjectie voor meer informatie.

Breng je eigen NuGet-pakketten naar custom code-projecten

Voor op NuGet gebaseerde aangepaste codeprojecten die gebruikmaken van .NET 8, kunt u uw eigen NuGet-pakketten opnemen en beheren zonder dat u conflicten hoeft op te lossen met afhankelijkheden die door de taalwerkrolhost worden gebruikt. Voeg de assembly-afhankelijkheden rechtstreeks toe aan de afzonderlijke assembly-locatie in uw project. Met de volgende uitzonderingen kunt u elke .NET 8 compatibele afhankelijke assemblyversies meenemen die uw project nodig heeft:

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

Problemen oplossen

Fout in actie-informatiepaneel

Wanneer u in de werkstroomontwerper de ingebouwde actie met de naam Een lokale functie aanroepen in deze logische app selecteert, wordt in het informatievenster van de actie het volgende bericht weergegeven:

Failed to retrieve dynamic inputs. Error details:

In dit scenario controleert u uw logische app-project om te zien of de map LogicApp\lib\custom leeg is. Als deze leeg is, selecteert u in het menu Terminal de optie Taak Uitvoeren>Build-functies.

Er wordt momenteel geen proces uitgevoerd met de opgegeven naam

Als u dit foutbericht krijgt wanneer u uw werkstroom uitvoert, hebt u waarschijnlijk het foutopsporingsprogramma aan .NET Functions gekoppeld, in plaats van aan uw logische app.

U kunt dit probleem oplossen door in de lijst Uitvoeren en fouten opsporen de optie Koppelen aan logische app (LogicApp) te selecteren en vervolgens Afspelen (groene driehoek) te selecteren.

Pakket niet correct geïmporteerd

Als in het uitvoervenster een fout wordt weergegeven die lijkt op het volgende bericht, controleert u of er ten minste .NET 6.0 is geïnstalleerd. Als u deze versie hebt geïnstalleerd, verwijdert u deze en installeert u deze opnieuw.

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]

Bouwfouten met fouten CS1031 en CS1001

Als uw functie geen variabelen bevat en u uw code bouwt, worden in het uitvoervenster mogelijk de volgende foutberichten weergegeven:

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)

Als u dit probleem wilt oplossen, voegt u in de methode van Run uw code de volgende parameter toe:

string parameter1 = null

In het volgende voorbeeld ziet u hoe de Run methodehandtekening wordt weergegeven:

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

Werkstromen voor standaard logische apps maken met Visual Studio Code

Feedback

Is deze pagina nuttig?

Last updated on 2026-09-16

Maak lokale functies aan en voer uit in standaardworkflows voor Azure Logic Apps

Vereisten

Beperkingen

1: Een codeproject maken

2: Uw code schrijven

3: Uw code compileren en bouwen

4: Uw code aanroepen vanuit een werkstroom

5: Fouten opsporen in uw code en werkstroom

6: Uw code implementeren

Afhankelijkheidsinjectie

Wanneer gebruikt u afhankelijkheidsinjectie?

Hoe heeft afhankelijkheidsinjectie invloed op aangepaste .NET functies

Afhankelijkheidsinjectie inschakelen

Breng je eigen NuGet-pakketten naar custom code-projecten

Problemen oplossen

Fout in actie-informatiepaneel

Er wordt momenteel geen proces uitgevoerd met de opgegeven naam

Pakket niet correct geïmporteerd

Bouwfouten met fouten CS1031 en CS1001

Verwante inhoud

Feedback

Aanvullende resources