.NET-code maken en uitvoeren vanuit Standard-werkstromen in Azure Logic Apps

Artikel
06/18/2024

Van toepassing op: Azure Logic Apps (Standard)

Voor integratieoplossingen waarin u .NET-code moet schrijven en uitvoeren vanuit uw werkstroom voor logische standaard-apps, kunt u Visual Studio Code gebruiken met de Extensie Azure Logic Apps (Standard). Deze 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.
Fouten in code lokaal opsporen 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.

Met de mogelijkheid om uw eigen code te schrijven, kunt u scenario's als de volgende uitvoeren:

Implementatie van aangepaste bedrijfslogica
Aangepaste parsering om gegevens uit een binnenkomend bericht te extraheren
Gegevensvalidatie en eenvoudige transformaties
Het vormgeven van berichten voor uitgaande berichten naar een ander systeem, zoals een API
Berekeningen

Deze mogelijkheid is niet geschikt voor scenario's zoals de volgende:

Processen die langer dan 10 minuten duren
Grote bericht- en gegevenstransformaties
Complexe batchverwerkings- en debatchingscenario's
BizTalk Server-pijplijnonderdelen die streaming implementeren

Zie Limieten en configuratie - Azure Logic Apps voor meer informatie over beperkingen in Azure Logic Apps.

Vereisten

Een Azure-account en -abonnement. Als u nog geen abonnement hebt, meld u dan aan voor een gratis Azure-account.
De meest recente Visual Studio Code met de Azure Logic Apps-extensie (Standard). Als u aan deze vereisten wilt voldoen, raadpleegt u de vereisten voor Het maken van Standard-werkstromen in Azure Logic Apps met één tenant met Visual Studio Code.
- De mogelijkheid voor aangepaste functies is momenteel alleen beschikbaar in Visual Studio Code, die wordt uitgevoerd op een Windows-besturingssysteem.
- De functie voor aangepaste functies ondersteunt momenteel het aanroepen van .NET Framework en .NET 8 voor door Azure gehoste werkstromen voor logische apps.
Een lokale map die moet worden gebruikt voor het maken van uw codeproject

Beperkingen

Het ontwerpen van aangepaste functies is momenteel niet beschikbaar in Azure Portal. Nadat u echter uw functies vanuit Visual Studio Code in Azure hebt geïmplementeerd, volgt u de stappen in Het aanroepen van uw code vanuit een werkstroom voor Azure Portal. U kunt de ingebouwde actie met de naam Een lokale functie aanroepen in deze logische app gebruiken om een keuze te maken uit uw geïmplementeerde aangepaste functies en uw code uit te voeren. Volgende acties in uw werkstroom kunnen verwijzen naar de uitvoer van deze functies, net als in elke andere werkstroom. U kunt de uitvoeringsgeschiedenis, invoer en uitvoer van de ingebouwde actie bekijken.

Een codeproject maken

De nieuwste Azure Logic Apps-extensie (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 te schrijven, het andere project om uw werkstromen te maken.

Notitie

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

Open Visual Studio Code. Selecteer op de activiteitenbalk het Azure-pictogram . (Toetsenbord: Shift+Alt+A)
Selecteer in het Azure-venster dat wordt geopend, op de werkbalk werkruimte, in het menu Van Azure Logic Apps de optie Nieuwe werkruimte voor logische apps maken.
Blader in het vak Map selecteren naar en selecteer de lokale map die u voor uw project hebt gemaakt.
Wanneer het promptvak Nieuwe logische app-werkruimte maken wordt weergegeven, geeft u een naam op voor uw werkruimte:

Dit voorbeeld gaat verder met MyLogicAppWorkspace.
Wanneer het promptvak Een projectsjabloon voor uw logische app-werkruimte selecteren wordt weergegeven, selecteert u Logische app met aangepast codeproject.
Volg de prompt om .NET Framework of .NET 8 te selecteren voor werkstromen voor door Azure gehoste logische apps.

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

Artikel	Voorbeeldwaarde
Functienaam voor uw .NET Functions-project	WeatherForecast
Naamruimtenaam voor uw .NET Functions-project	Contoso.Enterprise
Werkstroomsjabloon: - Stateful werkstroom - Staatloze werkstroom	Stateful werkstroom
Werkstroomnaam	MyWorkflow

Selecteer 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:

Schermopname van Visual Studio Code met gemaakte werkruimte.

Knooppunt	Beschrijving
*<werkruimtenaam>*	Bevat zowel uw .NET Functions-project als het werkstroomproject voor logische apps.
Functies	Bevat de artefacten voor uw .NET Functions-project. Het bestand met de *<functienaam>.cs* is bijvoorbeeld het codebestand waarin u uw code kunt ontwerpen.
LogicApp	Bevat de artefacten voor uw logische app-project, inclusief een lege werkstroom.

Uw code schrijven

Vouw in uw werkruimte het Functions-knooppunt uit als dit nog niet is uitgevouwen.

Open de <functienaam>.cs bestand, dat in dit voorbeeld WeatherForecast.cs heet.

Dit bestand bevat standaard voorbeeldcode met de volgende code-elementen, samen met de eerder opgegeven voorbeeldwaarden, indien van toepassing:

Naam van naamruimte
Klassenaam
Functienaam
Functieparameters
Retourtype
Complex type

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. Deze voorbeeldmethode Run demonstreert enkele van de mogelijkheden die beschikbaar zijn met de functie voor aangepaste functies, zoals het doorgeven van verschillende invoer- en uitvoerwaarden, waaronder complexe .NET-typen.

De <functienaam>.cs 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 deze informatie opslaan naast 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 eigen 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.

Dit voorbeeld gaat verder met de voorbeeldcode zonder wijzigingen.

Uw code compileren en bouwen

Nadat u klaar bent met het schrijven van uw code, compileert u om ervoor te zorgen dat er geen buildfouten bestaan. Uw .NET Functions-project bevat automatisch buildtaken, die uw code compileren en vervolgens toevoegen aan de map lib\custom in uw logische app-project, waar werkstromen zoeken naar aangepaste functies die moeten worden uitgevoerd. Met deze taken worden de assembly's in de map lib\custom\net472 of lib\custom\net8 geplaatst op basis van uw .NET-versie.

Selecteer in Visual Studio Code in het menu Terminal de optie Nieuwe terminal.
Selecteer Functies in de lijst met werkmapen die wordt weergegeven als uw huidige werkmap voor de nieuwe terminal.

Visual Studio Code opent een terminalvenster met een opdrachtprompt.
Voer in het Terminal-venster, bij de opdrachtprompt, dotnet-herstel in.

Visual Studio Code analyseert uw projecten en bepaalt of ze up-to-date zijn.
Nadat de opdrachtprompt opnieuw wordt weergegeven, voert u dotnet-build in. Of selecteer taak uitvoeren in het terminalmenu. Selecteer build (Functions) in de takenlijst.

Als uw build slaagt, rapporteert het Terminal-venster dat de build is geslaagd.
Controleer of de volgende items aanwezig zijn in uw logische app-project:
- Vouw in uw werkruimte de volgende mappen uit: LogicApp>lib\custom>net472 of net8, op basis van uw .NET-versie. Controleer of de submap met de naam net472 of net8 respectievelijk de assemblybestanden (DLL) bevat die nodig zijn om uw code uit te voeren, inclusief een bestand met de naam <functienaam>.dll.
- Vouw in uw werkruimte de volgende mappen uit: LogicApp>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:

Uw code aanroepen vanuit een werkstroom

Nadat u hebt bevestigd dat uw code wordt gecompileerd en dat uw logische app-project de benodigde bestanden bevat om uw code uit te voeren, opent u de standaardwerkstroom die is opgenomen in uw logische app-project.

Vouw in uw werkruimte onder LogicApp het< werkstroomnaamknooppunt> uit, open het snelmenu voor workflow.json en selecteer Open Designer.

In de werkstroomontwerper die wordt geopend, wordt de standaardwerkstroom, die deel uitmaakt van uw logische app-project, weergegeven met de volgende trigger en acties:
- De ingebouwde aanvraagtrigger met de naam Wanneer een HTTP-aanvraag wordt ontvangen
- De ingebouwde actie met de naam Een lokale functie aanroepen in deze logische app
- De ingebouwde antwoordactie met de naam Antwoord, die u gebruikt om de beller alleen te beantwoorden wanneer u de aanvraagtrigger gebruikt
Selecteer de actie met de naam Een lokale functie aanroepen in deze logische app.

Het informatievenster van de actie wordt aan de rechterkant geopend.
Controleer en controleer of de parameterwaarde Functienaam is ingesteld op de functie die u wilt uitvoeren. Controleer of wijzig andere parameterwaarden die door uw functie worden gebruikt.

Fouten opsporen in uw code en werkstroom

Herhaal de volgende stappen om de Azurite-opslagemulator drie keer te starten: één keer voor de volgende Azure Storage-services:
- Azure Blob Service
- Azure-wachtrijservice
- Azure Table Service
1. Selecteer opdrachtpalet in het menu Weergave van Visual Studio Code.
2. Zoek en selecteer Azurite bij de prompt die wordt weergegeven: Blob-service starten.
3. Selecteer LogicApp in de lijst met werkmap die wordt weergegeven.
4. Herhaal deze stappen voor Azurite: Start Queue Service en Azurite: Start Table Service.
U bent succesvol wanneer op de taakbalk van Visual Studio Code onder aan het scherm de drie opslagservices worden weergegeven die worden uitgevoerd, bijvoorbeeld:
Koppel het foutopsporingsprogramma aan uw logische app-project door de volgende stappen uit te voeren:
1. Selecteer Uitvoeren en fouten opsporen op de activiteitenbalk van Visual Studio Code. (Toetsenbord: Ctrl+Shift+D)
2. Selecteer In de lijst Uitvoeren en fouten opsporen de optie Koppelen aan logische app (LogicApp) als deze nog niet is geselecteerd en selecteer vervolgens Afspelen (groene pijl).
  
  Het terminalvenster wordt geopend en toont het gestarte foutopsporingsproces. Het venster Foutopsporingsconsole wordt vervolgens weergegeven en toont de foutopsporingsstatussen. Onder aan Visual Studio Code wordt de taakbalk oranje, waarmee wordt aangegeven dat het foutopsporingsprogramma van .NET is geladen.
Koppel het foutopsporingsprogramma aan uw .NET Functions-project door deze stappen uit te voeren op basis van uw code:

.NET 8-projecten
1. Selecteer opdrachtpalet in het menu Weergave van Visual Studio Code.
2. Zoek en selecteer fouten opsporen in het opdrachtenpalet: Koppelen aan een .NET 5+ of .NET Core-proces.
3. Zoek en selecteer het dotnet.exe proces in de lijst. Als er meerdere dotnet.exe processen bestaan, selecteert u het proces met het volgende pad:
  
  <drive-name>:\Users<user-name.azure-functions-core-tools>\Functions\ExtensionBundles\Microsoft.Azure.Functions.ExtensionBundle.Workflows<extension-bundle-version>\CustomCodeNetFxWorker\net8\Microsoft.Azure.Workflows.Functions.CustomCodeNetFxWorker.dll
.NET Framework-projecten

Selecteer Koppelen aan .NET-functies (functies) in de lijst Uitvoeren en fouten opsporen, als deze nog niet is geselecteerd en selecteer vervolgens Afspelen (groene pijl).
Als u onderbrekingspunten wilt instellen, zoekt u in de functiedefinitie (<functienaam>.cs) of werkstroomdefinitie (workflow.json) het regelnummer op de gewenste positie en selecteert u de kolom links, 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 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.
Selecteer Op de werkbalk Overzichtspagina de optie Trigger Uitvoeren.

Nadat uw werkstroom is gestart, activeert het foutopsporingsprogramma uw eerste onderbrekingspunt.
Selecteer een foutopsporingsactie in het menu Uitvoeren of foutopsporingsprogramma.

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.

Uw code implementeren

U kunt uw aangepaste functies op dezelfde manier implementeren als uw logische app-project. Ongeacht of u implementeert vanuit Visual Studio Code of een CI/CD DevOps-proces gebruikt, moet u ervoor zorgen dat u uw code bouwt en dat alle afhankelijke assembly's aanwezig zijn in de volgende map van het logische app-project voordat u implementeert:

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

Zie Standard-werkstromen van Visual Studio Code implementeren in Azure voor meer informatie.

Problemen oplossen

Fout in deelvenster Actiegegevens

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 onderzoekt u uw logische app-project om te controleren of de map LogicApp\lib\custom leeg is. Als dit leeg is, selecteert u Build-functies voor taak>uitvoeren in het terminalmenu.

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 dat is gekoppeld aan .NET Functions, 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)

Volgende stappen

Standaardwerkstromen maken met Visual Studio Code

Share via