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

  • Artikel

Van toepassing op: Azure Logic Apps (Standard)

Voor integratieoplossingen waarin u .NET Framework-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 Framework-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

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.

  1. Open Visual Studio Code. Selecteer op de activiteitenbalk het Azure-pictogram . (Toetsenbord: Shift+Alt+A)

  2. 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.

    Screenshot shows Visual Studio Code, Azure window, Workspace section toolbar, and selected option for Create new logic app workspace.

  3. Blader in het vak Map selecteren naar en selecteer de lokale map die u voor uw project hebt gemaakt.

  4. Wanneer het promptvak Nieuwe logische app-werkruimte maken wordt weergegeven, geeft u een naam op voor uw werkruimte:

    Screenshot shows Visual Studio Code with prompt to enter workspace name.

    Dit voorbeeld gaat verder met MyLogicAppWorkspace.

  5. Wanneer het promptvak Een projectsjabloon voor uw logische app-werkruimte selecteren wordt weergegeven, selecteert u Logische app met aangepast codeproject.

    Screenshot shows Visual Studio Code with prompt to select project template for logic app workspace.

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

    Artikel Voorbeeldwaarde
    Functienaam voor functions-project Weatherforecast
    Naamruimtenaam voor functions-project Contoso.Enterprise
    Werkstroomsjabloon:
    - Stateful werkstroom
    - Staatloze werkstroom    		 Stateful werkstroom
    Werkstroomnaam MyWorkflow

  7. Selecteer Openen in het huidige venster.

    Nadat u deze stap hebt voltooid, maakt Visual Studio Code uw werkruimte, die standaard een functions-project en een logic app-project bevat, bijvoorbeeld:

    Screenshot shows Visual Studio Code with created workspace.

    Knooppunt Omschrijving
    <werkruimtenaam> Bevat zowel uw functieproject als het werkstroomproject van de logische app.
    Functies Bevat de artefacten voor uw functieproject. Het bestand function-name.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

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

  2. Open het <bestand function-name.cs>, met de naam WeatherForecast.cs in dit voorbeeld.

    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
    • Resultaattype
    • 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.

    Het <bestand function-name.cs> bevat ook de ILogger interface, die ondersteuning biedt voor het registreren van gebeurtenissen naar 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);

    <...>

}

  3. 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 functieproject 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 geplaatst.

  1. Selecteer in Visual Studio Code in het menu Terminal de optie Nieuwe terminal.

  2. Selecteer Functies in de lijst met werkmapen die wordt weergegeven als uw huidige werkmap voor de nieuwe terminal.

    Screenshot shows Visual Studio Code, prompt for current working directory, and selected Functions directory.

    Visual Studio Code opent een terminalvenster met een opdrachtprompt.

  3. 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.

    Screenshot shows Visual Studio Code, Terminal window, and completed dotnet restore command.

  4. 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.

  5. Controleer of de volgende items aanwezig zijn in uw logische app-project:

    • Vouw in uw werkruimte de volgende mappen uit: LogicApp>lib\custom>net472. Controleer of de submap met de naam net472 de meerdere ASSEMBLY-bestanden (DLL) bevat die nodig zijn om uw code uit te voeren, inclusief een bestand met de naam< function-name.dll>.

    • Vouw in uw werkruimte de volgende mappen uit: LogicApp>lib\custom<>function-name.> Controleer of de submap met de naam <function-name> een function.json-bestand bevat, dat de metagegevens bevat 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:

    Screenshot shows Visual Studio Code and logic app workspace with function project and logic app project, now with the generated assemblies and other required files.

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.

  1. 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:

  2. Selecteer de actie met de naam Een lokale functie aanroepen in deze logische app.

    Het informatievenster van de actie wordt aan de rechterkant geopend.

    Screenshot shows Visual Studio Code, workflow designer, and default workflow with trigger and actions.

  3. 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

  1. 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:

    Screenshot shows Visual Studio Code taskbar with Azure Blob Service, Azure Queue Service, and Azure Table Service running.

  2. Selecteer Uitvoeren en fouten opsporen op de activiteitenbalk van Visual Studio Code. (Toetsenbord: Ctrl+Shift+D)

    Screenshot shows Visual Studio Code Activity Bar with Run and Debug selected.

  3. 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).

    Screenshot shows Run and Debug list with Attach to logic app selected and Play button selected.

    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.

  4. Selecteer In de lijst Uitvoeren en fouten opsporen de optie Koppelen aan .NET-functies (functies) en selecteer vervolgens Afspelen (groene pijl).

    Screenshot shows Run and Debug list with Attach to NET Functions selected and Play button selected.

  5. Als u onderbrekingspunten wilt instellen, zoekt u in uw functiedefinitie (<function-name.cs>) of werkstroomdefinitie (workflow.json) het regelnummer op de gewenste positie en selecteert u de kolom links, bijvoorbeeld:

    Screenshot shows Visual Studio Code and the open function code file with a breakpoint set for a line in code.

  6. 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 bestand workflow.json 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.

      Screenshot shows Visual Studio Code and workflow's Overview page opened.

  7. Selecteer Op de werkbalk Overzichtspagina de optie Trigger Uitvoeren.

    Nadat uw werkstroom is gestart, activeert het foutopsporingsprogramma uw eerste onderbrekingspunt.

  8. 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.

  9. 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.

    Screenshot shows Visual Studio Code and finished workflow run.

Uw code implementeren

U kunt uw aangepaste functies op dezelfde manier implementeren als uw logische app-project. Of u nu implementeert vanuit Visual Studio Code of een CI/CD DevOps-proces gebruikt, zorg ervoor dat u uw code bouwt en dat alle afhankelijke assembly's aanwezig zijn in de lib/custom/net472-map van het logische app-project voordat u implementeert. 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 .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.

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]

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