Skapa och köra .NET-kod från Standard-arbetsflöden i Azure Logic Apps

Artikel
09/06/2024

Gäller för: Azure Logic Apps (Standard)

För integreringslösningar där du måste skapa och köra .NET-kod från ditt standardarbetsflöde för logikappar kan du använda Visual Studio Code med tillägget Azure Logic Apps (Standard). Det här tillägget innehåller följande funktioner och fördelar:

Skriv din egen kod genom att skapa funktioner som har flexibilitet och kontroll för att lösa dina mest utmanande integreringsproblem.
Felsöka kod lokalt i Visual Studio Code. Gå igenom din kod och dina arbetsflöden i samma felsökningssession.
Distribuera kod tillsammans med dina arbetsflöden. Inga andra tjänstplaner krävs.
Stöd för BizTalk Server-migreringsscenarier så att du kan lyfta och flytta anpassade .NET-investeringar lokalt till molnet.

Med möjligheten att skriva din egen kod kan du utföra scenarier som följande:

Anpassad implementering av affärslogik
Anpassad parsning för att extrahera information från ett inkommande meddelande
Dataverifiering och enkla transformeringar
Meddelandeformning för utgående meddelanden till ett annat system, till exempel ett API
Beräkningar

Den här funktionen är inte lämplig för scenarier som följande:

Processer som tar mer än 10 minuter att köra
Stora meddelande- och datatransformeringar
Komplexa scenarier för batchbearbetning och diskussion
BizTalk Server-pipelinekomponenter som implementerar direktuppspelning

Mer information om begränsningar i Azure Logic Apps finns i Gränser och konfiguration – Azure Logic Apps.

Förutsättningar

Ett Azure-konto och prenumeration. Om du inte har någon prenumeration kan du registrera ett kostnadsfritt Azure-konto.
Den senaste Visual Studio Code med Tillägget Azure Logic Apps (Standard). Om du vill uppfylla dessa krav kan du läsa kraven för att skapa standardarbetsflöden i Azure Logic Apps med en enda klientorganisation med Visual Studio Code.
- Funktionen för anpassade funktioner är för närvarande endast tillgänglig i Visual Studio Code, som körs på ett Windows-operativsystem.
- Funktionen anpassade funktioner stöder för närvarande anrop av .NET Framework och .NET 8 för Azure-värdbaserade logikapparbetsflöden.
En lokal mapp som ska användas för att skapa kodprojektet

Begränsningar

Redigering av anpassade funktioner är för närvarande inte tillgängligt i Azure Portal. Men när du har distribuerat dina funktioner från Visual Studio Code till Azure följer du stegen i Anropa koden från ett arbetsflöde för Azure Portal. Du kan använda den inbyggda åtgärden Anropa en lokal funktion i den här logikappen för att välja bland dina distribuerade anpassade funktioner och köra koden. Efterföljande åtgärder i arbetsflödet kan referera till utdata från dessa funktioner, som i andra arbetsflöden. Du kan visa den inbyggda åtgärdens körningshistorik, indata och utdata.
Anpassade funktioner använder en isolerad arbetare för att anropa koden i logikappens arbetsflöde. Om du vill undvika paketreferenser mellan din egen funktionskod och arbetaren använder du samma paketversioner som refereras av arbetaren. Den fullständiga paketlistan och versionerna som refereras av arbetaren finns i Beroenden för arbetare och paket.

Skapa ett kodprojekt

Det senaste Azure Logic Apps-tillägget (Standard) för Visual Studio Code innehåller en kodprojektmall som ger en smidig upplevelse för att skriva, felsöka och distribuera din egen kod med dina arbetsflöden. Den här projektmallen skapar en arbetsytefil och två exempelprojekt: ett projekt för att skriva koden, det andra projektet för att skapa dina arbetsflöden.

Kommentar

Du kan inte använda samma projektmapp för både din kod och dina arbetsflöden.

Öppna Visual Studio Code. I aktivitetsfältet väljer du Azure-ikonen. (Tangentbord: Skift+Alt+A)
I azure-fönstret som öppnas går du till verktygsfältet Arbetsyta i Azure Logic Apps-menyn och väljer Skapa ny arbetsyta för logikappar.
I rutan Välj mapp bläddrar du till och väljer den lokala mapp som du skapade för projektet.
När promptrutan Skapa ny logikappsarbetsyta visas anger du ett namn på din arbetsyta:

Det här exemplet fortsätter med MyLogicAppWorkspace.
När rutan Välj en projektmall för arbetsytans logikapp visas väljer du Logikapp med anpassat kodprojekt.
För Azure-värdbaserade standardlogikapparbetsflöden följer du uppmaningen för att välja antingen .NET Framework eller .NET 8.

Följ de efterföljande anvisningarna för att ange följande exempelvärden:

Artikel	Exempelvärde
Funktionsnamn för .NET-funktionsprojektet	WeatherForecast
Namnområdesnamn för .NET-funktionsprojektet	Contoso.Enterprise
Arbetsflödesmall: - Tillståndskänsligt arbetsflöde - Tillståndslöst arbetsflöde	Tillståndskänsligt arbetsflöde
Arbetsflödesnamn	MyWorkflow

Välj Öppna i aktuellt fönster.

När du har slutfört det här steget skapar Visual Studio Code din arbetsyta, som innehåller ett .NET-funktionsprojekt och ett logikappsprojekt, som standard, till exempel:

Skärmbild som visar Visual Studio Code med den skapade arbetsytan.

Nod	beskrivning
*<arbetsytans namn>*	Innehåller både ditt .NET-funktionsprojekt och logikappens arbetsflödesprojekt.
Funktioner	Innehåller artefakterna för .NET-funktionsprojektet. Till exempel är funktionsnamnet><.cs filen den kodfil där du kan skapa din kod.
LogicApp	Innehåller artefakterna för ditt logikappsprojekt, inklusive ett tomt arbetsflöde.

Skriv din kod

På arbetsytan expanderar du noden Functions, om den inte redan har expanderats.

<Öppna filen function-name>.cs som heter WeatherForecast.cs i det här exemplet.

Som standard innehåller den här filen exempelkod som har följande kodelement tillsammans med tidigare angivna exempelvärden där det är lämpligt:

Namn på namnområde
Klassnamn
Funktionsnamn
Funktionsparametrar
Returtyp
Komplex typ

I följande exempel visas den fullständiga exempelkoden:

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

Funktionsdefinitionen innehåller en standardmetod Run som du kan använda för att komma igång. Den här exempelmetoden Run visar några av de funktioner som är tillgängliga med funktionen anpassade funktioner, till exempel att skicka olika indata och utdata, inklusive komplexa .NET-typer.

Funktionsnamnet><.cs filen innehåller ILogger även gränssnittet, som ger stöd för loggningshändelser till en Application Insights-resurs. Du kan skicka spårningsinformation till Application Insights och lagra den informationen tillsammans med spårningsinformationen från dina arbetsflöden, till exempel:

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

    <...>

}

Ersätt exempelfunktionskoden med din egen och redigera standardmetoden Run för dina egna scenarier. Eller så kan du kopiera funktionen, inklusive deklarationen [FunctionName("<*function-name*>")] , och sedan byta namn på funktionen med ett unikt namn. Du kan sedan redigera den omdöpta funktionen för att uppfylla dina behov.

Det här exemplet fortsätter med exempelkoden utan ändringar.

Kompilera och skapa din kod

När du har skrivit koden kompilerar du för att se till att det inte finns några byggfel. .NET-funktionsprojektet innehåller automatiskt bygguppgifter, som kompilerar och sedan lägger till koden i mappen lib\custom i logikappsprojektet där arbetsflöden letar efter anpassade funktioner som ska köras. Dessa uppgifter placerar sammansättningarna i mappen lib\custom\net472 eller lib\custom\net8 baserat på din .NET-version.

I Visual Studio Code går du till terminalmenyn och väljer Ny terminal.
I arbetskataloglistan som visas väljer du Functions som din aktuella arbetskatalog för den nya terminalen.

Visual Studio Code öppnar ett terminalfönster med en kommandotolk.
I terminalfönstret går du till kommandotolken och anger dotnet-återställning.

Visual Studio Code analyserar dina projekt och avgör om de är uppdaterade.
När kommandotolken visas igen anger du dotnet build. Eller så väljer du Kör aktivitet på terminalmenyn. I uppgiftslistan väljer du build (Functions).

Om bygget lyckas rapporterar terminalfönstret att bygget lyckades.
Bekräfta att följande objekt finns i logikappprojektet:
- På din arbetsyta expanderar du följande mappar: LogicApp>lib\custom>net472 eller net8, baserat på din .NET-version. Bekräfta att undermappen med namnet net472 respektive net8 innehåller de sammansättningsfiler (DLL) som krävs för att köra koden, inklusive en fil med namnet< function-name>.dll.
- På arbetsytan expanderar du följande mappar: LogicApp>lib\custom<>function-name.> Bekräfta att undermappen med namnet <function-name> innehåller en function.json fil, som innehåller metadata om funktionskoden som du skrev. Arbetsflödesdesignern använder den här filen för att fastställa nödvändiga indata och utdata när du anropar koden.
I följande exempel visas exempelgenererade sammansättningar och andra filer i logikappprojektet:

Anropa koden från ett arbetsflöde

När du har bekräftat att koden kompileras och att logikappsprojektet innehåller de filer som krävs för att koden ska kunna köras öppnar du standardarbetsflödet som ingår i logikappsprojektet.

Under LogicApp på arbetsytan expanderar <du noden arbetsflödesnamn>, öppnar snabbmenyn för workflow.json och väljer Öppna designer.

I arbetsflödesdesignern som öppnas visas standardarbetsflödet, som ingår i ditt logikappsprojekt, med följande utlösare och åtgärder:
- Den inbyggda utlösaren för begäran med namnet När en HTTP-begäran tas emot
- Den inbyggda åtgärden med namnet Anropa en lokal funktion i den här logikappen
- Den inbyggda svarsåtgärden med namnet Svar, som du använder för att svara anroparen endast när du använder utlösaren Förfrågning
Välj åtgärden Anropa en lokal funktion i den här logikappen.

Åtgärdens informationsfönster öppnas till höger.
Granska och bekräfta att parametervärdet funktionsnamn är inställt på den funktion som du vill köra. Granska eller ändra andra parametervärden som din funktion använder.

Felsöka din kod och ditt arbetsflöde

Upprepa följande steg för att starta Azurite Storage-emulatorn tre gånger: en gång var för följande Azure Storage-tjänster:
- Azure Blob Service
- Azure Kötjänst
- Azure Table Service
1. Välj Kommandopalett på menyn i Visual Studio Code-vyn.
2. I kommandotolken som visas letar du upp och väljer Azurite: Starta Blob Service.
3. I arbetskataloglistan som visas väljer du LogicApp.
4. Upprepa de här stegen för Azurite: Start Queue Service och Azurite: Start Table Service.
Du lyckas när Aktivitetsfältet i Visual Studio Code längst ned på skärmen visar de tre lagringstjänster som körs, till exempel:
Koppla felsökningsprogrammet till logikappprojektet genom att följa dessa steg:
1. I aktivitetsfältet i Visual Studio Code väljer du Kör och Felsöka. (Tangentbord: Ctrl+Skift+D)
2. I listan Kör och felsök väljer du Anslut till logikappen (LogicApp), om den inte redan är markerad, och väljer sedan Spela upp (grön pil).
  
  Terminalfönstret öppnas och visar den startade felsökningsprocessen. Fönstret Felsökningskonsol visas sedan och visar felsökningsstatusen. Längst ned i Visual Studio Code blir aktivitetsfältet orange, vilket anger att .NET-felsökningsprogrammet läses in.
Koppla felsökningsprogrammet till .NET-funktionsprojektet genom att följa dessa steg baserat på din kod:

.NET 8-projekt
1. Välj Kommandopalett på menyn i Visual Studio Code-vyn.
2. Från kommandopaletten letar du upp och väljer Felsök: Anslut till en .NET 5+ eller .NET Core-process.
3. Leta upp och välj den dotnet.exe processen i listan. Om det finns flera dotnet.exe processer väljer du den process som har följande sökväg:
  
  <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-projekt

I listan Kör och felsök väljer du Anslut till .NET Functions (Functions), om den inte redan är markerad, och väljer sedan Spela upp (grön pil).
Om du vill ange brytpunkter i funktionsdefinitionen (<funktionsnamn>.cs) eller arbetsflödesdefinitionen (workflow.json) letar du reda på radnumret där du vill ha brytpunkten och väljer kolumnen till vänster, till exempel:
Om du vill köra utlösaren Begäran manuellt i arbetsflödet öppnar du arbetsflödets översiktssida.
1. Öppna workflow.json-filens snabbmeny i logikappsprojektet och välj Översikt.
  
  På arbetsflödets översiktssida är knappen Kör utlösare tillgänglig för när du vill starta arbetsflödet manuellt. Under Arbetsflödesegenskaper är värdet för återanrops-URL:en URL:en för en anropsbar slutpunkt som skapas av utlösaren Förfrågning i arbetsflödet. Du kan skicka begäranden till den här URL:en för att utlösa arbetsflödet från andra appar, inklusive andra arbetsflöden för logikappar.
I verktygsfältet Översikt väljer du Kör utlösare.

När arbetsflödet har börjat köras aktiverar felsökningsprogrammet din första brytpunkt.
I verktygsfältet Kör eller felsökaren väljer du en felsökningsåtgärd.

När arbetsflödeskörningen har slutförts visar sidan Översikt den färdiga körningen och grundläggande information om den körningen.
Om du vill granska mer information om arbetsflödeskörningen väljer du den färdiga körningen. I listan bredvid kolumnen Varaktighet väljer du Visa körning.

Distribuera din kod

Du kan distribuera dina anpassade funktioner på samma sätt som du distribuerar ditt logikappsprojekt. Oavsett om du distribuerar från Visual Studio Code eller använder en CI/CD DevOps-process ska du se till att du skapar koden och att alla beroende sammansättningar finns i följande logikappsprojektmapp innan du distribuerar:

.NET 4.7.2: mappen lib/custom/net472
.NET 8: lib/custom/net8-mapp

Mer information finns i Distribuera standardarbetsflöden från Visual Studio Code till Azure.

Felsöka problem

Fel i åtgärdsinformationsfönstret

När du väljer den inbyggda åtgärden Anropa en lokal funktion i den här logikappen i arbetsflödesdesignern visas följande meddelande i åtgärdsfönstret:

Failed to retrieve dynamic inputs. Error details:

I det här scenariot undersöker du logikappprojektet för att kontrollera om mappen LogicApp\lib\custom är tom. Om det är tomt går du till terminalmenyn och väljer Kör aktivitetsversionsfunktioner>.

Ingen process med det angivna namnet körs för närvarande

Om du får det här felmeddelandet när du kör arbetsflödet har du förmodligen felsökningsprocessen kopplad till .NET Functions i stället för till logikappen.

Lös problemet genom att i listan Kör och felsöka väljer du Anslut till logikapp (LogicApp) och väljer sedan Spela upp (grön triangel).

Paketet har inte importerats korrekt

Om utdatafönstret visar ett fel som liknar följande meddelande kontrollerar du att du har minst .NET 6.0 installerat. Om du har den här versionen installerad kan du prova att avinstallera och sedan installera om.

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]

Build-fel

Om funktionen inte innehåller variabler och du skapar koden kan följande felmeddelanden visas i utdatafönstret:

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)

Åtgärda problemet genom att lägga till följande parameter i kodens Run metod:

string parameter1 = null

I följande exempel visas hur metodsignaturen Run visas:

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

Nästa steg

Skapa standardarbetsflöden med Visual Studio Code

Dela via