Maak en voer .NET code uit van Standaardwerkstromen in Azure Logic Apps met behulp van Visual Studio Code

Van toepassing op: Azure Logic Apps (Standard)

Wanneer uw integratiescenario aangepaste taken of logica nodig heeft buiten de ingebouwde bewerkingen en connectors in Azure Logic Apps, maakt en voert u .NET code uit als customfuncties in uw Standaardwerkstromen. Uw werkstroom kan vervolgens taken uitvoeren, zoals aangepaste parsering, validatie of zelfs bedrijfsregels toepassen. Met deze mogelijkheid kunt u scenario's implementeren, zoals de volgende taken:

De implementatie van bedrijfslogica aanpassen.
Pas parseren aan om gegevens uit een binnenkomend bericht te extraheren.
Gegevensvalidatie en eenvoudige transformaties uitvoeren.
Berekeningen uitvoeren.
Uitgaande berichten vormgeven die naar een ander systeem worden verzonden, zoals een API.

Deze handleiding laat zien hoe u uw eigen .NET code rechtstreeks in Standaardwerkstromen schrijft en uitvoert met behulp van Visual Studio Code. U leert hoe u lokale functies kunt maken, fouten opsporen en implementeren met behulp van Visual Studio Code, zodat u aangepaste code en werkstroomindeling samen kunt houden, fouten in één sessie kunt opsporen en als één oplossing kunt implementeren.

Notitie

Aangepaste inline .NET code is niet geschikt voor de volgende scenario's:

Draaiende processen die mogelijk langer duren dan 10 minuten.
Grote bericht- en gegevenstransformaties proberen.
Het uitvoeren van complexe batchverwerkings- en debatchingscenario's.
BizTalk Server-pijplijnonderdelen gebruiken 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

U kunt de functie voor aangepaste functies alleen gebruiken in Visual Studio Code die worden uitgevoerd op Windows. Deze mogelijkheid ondersteunt het gebruik van .NET Framework en .NET 8 voor standaardwerkstromen voor logische apps die zijn geïmplementeerd en gehost op Azure.
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 :

In dit voorbeeld wordt de naam van de werkruimte gebruikt weather-project .
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: - Stateful workflow - 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:

Schermafbeelding toont de gemaakte werkruimte met het logische app-project en .NET-functieproject.

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`
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 u klaar bent met het schrijven van uw code, compileert u deze om er zeker van te zijn dat er geen buildfouten bestaan. Uw .NET functions-project bevat automatisch buildtaken, die uw code compileren en toevoegen aan de map lib\custom in uw logische app-project waar werkstromen zoeken naar aangepaste functies die moeten worden uitgevoerd. 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. Controleer of de submap met de naam net472 of net8 de assemblybestanden (DLL) bevat die nodig zijn om uw code uit te voeren, inclusief een bestand met de naam<van de functie>.dll.
- Vouw in uw werkruimte de volgende mappen uit: <uw logische app>>lib\custom><function-name>. Controleer of de submap met de naam <functienaam> een function.json-bestand bevat, inclusief de metagegevens over de functiecode die u hebt geschreven. 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 Queue Service
- 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 venster Foutopsporingsconsole wordt geopend en toont de foutopsporingsstatus.
  - 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 u nu implementeert vanuit Visual Studio Code of een CI/CD DevOps-proces gebruikt, zorg ervoor dat u uw code bouwt voordat u deze implementeert. Zorg er ook voor dat alle afhankelijke assembly's aanwezig zijn in de volgende map van het logische app-project voordat u implementeert:

.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. Met afhankelijkheidsinjectie kunt u het volgende doen:

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 uw aangepaste code echter de volgende vereisten heeft, moet u mogelijk afhankelijkheidsinjectie gebruiken:

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 interface IConfigureStartup wordt gedefinieerd in Microsoft.Extensions.DependencyInjection. Zie StartupConfiguration.cs voor meer informatie

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.

Uw eigen NuGet-pakketten meenemen

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]

Buildfouten

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-04-11

Delen via

Maak en voer .NET code uit van Standaardwerkstromen in Azure Logic Apps met behulp van Visual Studio Code

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

Uw eigen NuGet-pakketten meenemen

Problemen oplossen

Fout in actie-informatiepaneel

Er wordt momenteel geen proces uitgevoerd met de opgegeven naam

Pakket niet correct geïmporteerd

Buildfouten

Verwante inhoud

Feedback

Aanvullende resources