Tworzenie i uruchamianie lokalnych funkcji w standardowych workflowach dla Azure Logic Apps

Dotyczy: Azure Logic Apps (Standard)

Gdy Twój workflow integracyjny potrzebuje logiki wykraczającej poza wbudowane operacje i gotowe złącza, stwórz lokalną funkcję , w której kod pozostaje specyficzny dla Twojego rozwiązania aplikacji logicznej. Ta funkcja lokalna to niestandardowy kod platformy .NET, który tworzysz, uruchamiasz, debugujesz i wdrażasz w tym samym projekcie Azure Logic Apps Standard co przepływy pracy wywołujące tę funkcję. Utrzymując funkcję lokalną, możesz rozwijać, zabezpieczać, wdrażać, skalować i obsługiwać workflow oraz jego własny kod jako jedną aplikację.

Funkcje lokalne pomagają Twoim procesom wykonywania takich zadań jak:

• Wprowadź niestandardową logikę biznesową i obliczenia.
• Analizuj zastrzeżone lub złożone wiadomości przychodzące.
• Walidacja, wzbogacanie lub wykonywanie prostych transformacji danych.
• Kształtuj wiadomości wychodzące dla API, łącznika lub systemu partnerskiego.
• Wykorzystaj odpowiednią logikę pomocniczą .NET z istniejących rozwiązań integracyjnych, w tym scenariuszy migracji na BizTalk Server.

Dzięki lokalnym funkcjom możesz osiągnąć następujące cele:

Funkcja lokalna różni się od funkcji hostowanej w osobnej aplikacji funkcjonalnej w Azure Functions. Azure Functions działa najlepiej, gdy Twój kod musi udostępniać niezależny punkt końcowy, być współdzielony między aplikacjami, podążać za własnym cyklem wdrożenia i wersjonowania lub skalować się niezależnie. Gdy kod musi działać w określonym rozwiązaniu Azure Logic Apps Standard i współdzielić cykl życia aplikacji z wywołującymi przepływami pracy, użyj funkcji lokalnej.

Ten przewodnik pokazuje, jak tworzyć, budować, wywoływać, debugować i wdrażać lokalne funkcje .NET dla standardowych workflow za pomocą Visual Studio Code.

Wymagania wstępne

• Konto i subskrypcja Azure. Pobierz bezpłatne konto Azure.

• Najnowsza wersja Visual Studio Code z rozszerzeniem Azure Logic Apps (Standard).

  Aby zapoznać się z wymaganiami wstępnymi, zobacz Utwórz standardowe przepływy pracy w jednodzierżawcowych Azure Logic Apps przy użyciu Visual Studio Code.

  Rozszerzenie zapewnia następujące możliwości i korzyści:

  • Napisz własny kod, tworząc funkcje, które mają elastyczność i kontrolę w celu rozwiązania najbardziej trudnych problemów z integracją.
  • Lokalne debugowanie kodu w Visual Studio Code. Przejdź przez kod i przepływy pracy w tej samej sesji debugowania.
  • Wdróż kod obok przepływów pracy. Nie są potrzebne żadne inne plany usług.
  • Obsługa scenariuszy migracji dla serwera BizTalk, umożliwiając przeniesienie niestandardowych inwestycji .NET z infrastruktury lokalnej do chmury.

• Folder lokalny do użycia w projekcie kodu.

Ograniczenia

• Możesz tworzyć funkcje lokalne tylko w Visual Studio Code działającym na Windows. Ta funkcja obsługuje .NET Framework i .NET 8 dla standardowych przepływów pracy hostowanych na Workflow Service Plan, App Service Environment v3 (ASE v3) lub Hybrid.

• Nie można używać tworzenia funkcji niestandardowych w portalu Azure. Jednak aby pracować z danymi wyjściowymi z funkcji niestandardowych w przepływie pracy, wykonaj następujące kroki:

  1. Po wdrożeniu funkcji w Azure, wykonaj kroki opisane w Wywołaj swój kod z przepływu pracy w portalu Azure.

  2. Dodaj wbudowaną akcję o nazwie Wywołaj funkcję lokalną w tej aplikacji logiki do przepływu pracy. Wybierz wdrożone funkcje niestandardowe i uruchom kod.

  3. Użyj kolejnych akcji przepływu pracy, aby odwołać się do danych wyjściowych funkcji niestandardowych, podobnie jak w każdym innym przepływie pracy. Możesz wyświetlić historię uruchamiania, dane wejściowe i wyjściowe wbudowanej akcji.

Aby uzyskać ogólne ograniczenia, zobacz Ograniczenia i odniesienia do konfiguracji dla Azure Logic Apps.

1: Tworzenie projektu kodu

Rozszerzenie Azure Logic Apps (Standardowa) dla Visual Studio Code zawiera szablon projektu kodu, który zapewnia usprawnione środowisko pisania, debugowania i wdrażania własnego kodu przy użyciu przepływów pracy. Ten szablon projektu tworzy plik obszaru roboczego i dwa przykładowe projekty: jeden projekt do pisania kodu i inny projekt w celu utworzenia przepływów pracy.

Aby utworzyć projekt kodu, wykonaj następujące kroki:

1. W Visual Studio Code przypisz się do konta Azure.

   Jeśli logowanie trwa dłużej niż zwykle, Visual Studio Code monituje o zalogowanie się za pośrednictwem witryny internetowej uwierzytelniania Microsoft, podając kod urządzenia. Aby zalogować się przy użyciu kodu, wykonaj następujące kroki:

   1. Wybierz pozycję Użyj kodu urządzenia, a następnie wybierz pozycję Kopiuj i otwórz.

   2. Wybierz pozycję Otwórz link, aby otworzyć nowe okno przeglądarki i przejść do witryny internetowej uwierzytelniania.

   3. Na stronie Zaloguj się do konta wprowadź kod uwierzytelniania, a następnie wybierz pozycję Dalej.

2. Na pasku działań wybierz ikonę Azure.

3. W oknie Azure przejdź do sekcji Workspace. Przenieś wskaźnik nad obszarem tytułu, aby pasek narzędzi był wyświetlany.

4. Z menu Azure Logic Apps wybierz pozycję Utwórz nowy obszar roboczy aplikacji logiki.

   

5. W oknie Wybieranie folderu przejdź do folderu projektu lokalnego, wybierz folder, a następnie wybierz pozycję Wybierz.

6. W oknie Tworzenie nowego obszaru roboczego aplikacji logiki w wierszu polecenia Nazwa obszaru roboczego wprowadź nazwę obszaru roboczego, a następnie naciśnij klawisz Enter.

   W tym przykładzie użyto weather-app nazwy obszaru roboczego:

   

7. Dla monitu Wybierz szablon dla nowego projektu wybierz pozycję Aplikacja logiki z niestandardowym projektem kodu.

   

8. W przypadku monitu Wybierz strukturę docelową wybierz .NET Framework lub .NET 8.

9. Postępuj zgodnie z kolejnymi monitami, aby podać następujące informacje:

   Podpowiedź	Przykładowa wartość
   Nazwa aplikacji logiki	weather-logic-app
   Nazwa funkcji dla projektu funkcji .NET	WeatherForecast
   Namespace dla projektu funkcji .NET	Contoso.Enterprise
   Wybierz szablon pierwszego przepływu pracy projektu: - Stanowy przepływ pracy - Przepływ bezstanowy - Agent autonomiczny - Agent konwersacyjny - Pomiń na razie	Stanowy przepływ pracy
   Nazwa przepływu pracy	weather-workflow

10. W Wybierz sposób, w jaki chcesz otworzyć projekt, wybierz Otwórz w bieżącym oknie.

    Po zakończeniu tego kroku Visual Studio Code utworzy obszar roboczy, który obejmuje projekt funkcji .NET i projekt aplikacji logiki, na przykład:

    

    W oknie Eksplorator zanotuj następujące foldery w obszarze roboczym:

    Folder	opis
    < nazwa obszaru roboczego>	Zawiera zarówno projekt funkcji .NET, jak i projekt przepływu pracy aplikacji Logic Apps.
    < nazwa-aplikacji-logicznej>	Zawiera pliki i inne artefakty dla projektu aplikacji logiki. Na przykład plik workflow.json to plik definicji przepływu pracy, w którym można utworzyć przepływ pracy.
    < nazwa funkcji>	Zawiera pliki i inne artefakty dla projektu funkcji .NET. Na przykład <plik nazwa-funkcji>.cs to plik kodu, w którym można utworzyć kod.

11. W przypadku monitów Włącz łączniki z Azure dla Logic Apps <logic-app-name> wybierz Użyj łączników z Azure.

12. W przypadku monitu Wybierz subskrypcję wybierz odpowiednią subskrypcję Azure.

13. Dla komunikatu Wybierz grupę zasobów dla nowych zasobów, wybierz grupę zasobów, którą chcesz lub Utwórz nową grupę zasobów.

14. W przypadku Wybierz lokalizację dla nowych zasobów monitu wybierz region Azure do wdrożenia.

15. Dla Wybierz metodę uwierzytelniania dla łączników Azure wybierz typ uwierzytelniania, który ma być używany dla połączeń wymagających uwierzytelniania.

    Typ uwierzytelniania	opis
    Tożsamość zarządzana	Wybierz Tożsamość usługi zarządzanej aby użyć tożsamości przypisanej przez system lub przypisanej przez użytkownika w zasobie aplikacji logicznej. Domyślnie zasoby aplikacji logicznych w warstwie Standard mają już włączoną tożsamość przypisaną przez system. Należy jednak skonfigurować tożsamość z dostępem do roli w zasobie docelowym oraz wszelkie inne wymagania. Aby uzyskać więcej informacji, zobacz Przypisywanie dostępu opartego na rolach do tożsamości zarządzanej.
    Klucze połączenia	Skonfiguruj dostęp do zasobu docelowego przy użyciu parametrów połączeń i kluczy dostępu.

Po wykonaniu tych kroków przejdź do następnej sekcji, aby móc utworzyć kod.

2: Pisanie kodu

1. W oknie Eksplorator rozwiń folder projektu funkcji i otwórz < plik nazwa-funkcji>.cs.

   Ten plik zawiera przykładowy kod i określone elementy kodu z podanymi wcześniej wartościami.

   W tym przykładzie plik funkcji WeatherForecast.cs zawiera następujące elementy kodu z przykładowymi wartościami:

   Element kodu	Wartość
   Nazwa przestrzeni nazw	Contoso.Enterprise
   Nazwa klasy	WeatherForecast
   Nazwa funkcji	WeatherForecast
   Parametry funkcji	zipCode, temperatureScale
   Typ zwracany	Task<Weather>
   Typ złożony	Weather

   Poniższy przykład przedstawia kompletny przykładowy kod:

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

   Definicja funkcji zawiera domyślną Run metodę, której można użyć do rozpoczęcia pracy. Ta przykładowa metoda Run demonstruje niektóre funkcje dostępne w funkcji niestandardowych, takie jak przekazywanie różnych danych wejściowych i wyjściowych, w tym złożonych typów .NET.

   Plik <nazwa-funkcji>.cs zawiera ILogger również interfejs, który zapewnia obsługę rejestrowania zdarzeń do zasobu usługi Application Insights. Możesz wysyłać informacje śledzenia do usługi Application Insights i przechowywać te informacje przy użyciu informacji śledzenia z przepływów pracy, na przykład:

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

2. Zastąp przykładowy kod funkcji własnym kodem i zmodyfikuj domyślną Run metodę dla określonych scenariuszy. Możesz też skopiować funkcję, w tym deklarację [FunctionName("<function-name>")] , a następnie zmienić nazwę funkcji na unikatową nazwę. Następnie możesz edytować zmienioną nazwę funkcji w celu spełnienia Twoich potrzeb.

W tym przykładzie jest kontynuowany oryginalny przykładowy kod, przy założeniu, że nie wprowadzono żadnych zmian.

3. Kompilowanie i budowanie kodu

Po zakończeniu pisania kodu skompiluj go, aby upewnić się, że nie ma błędów w budowaniu. Projekt funkcji platformy .NET automatycznie zawiera zadania kompilacji, które kompilują kod i dodają go do folderu lib\custom w projekcie aplikacji logiki. Workflowy szukają niestandardowych funkcji w tym folderze. W zależności od wersji .NET te zadania umieszczają zestawy w folderze lib\custom\net472 lub lib\custom\net8.

Wykonaj te kroki:

1. W Visual Studio Code na pasku działań wybierz pozycję Explorer.

2. W oknie Eksplorator otwórz menu skrótów dla folderu projektu functions i wybierz pozycję Kompiluj projekt funkcji.

   

   Zadanie kompilacji jest uruchamiane dla projektu funkcji. Jeśli kompilacja zakończy się pomyślnie, w oknie terminalu zostanie wyświetlony komunikat Kompilacja powiodła się .

3. Upewnij się, że w projekcie aplikacji logiki istnieją następujące elementy:

   • W obszarze roboczym rozwiń następujące foldery: <your-logic-app>>lib\custom>net472 lub net8, na podstawie wersji .NET. Potwierdź, że podfolder net472 lub net8 zawiera pliki assembly (DLL) potrzebne do uruchomienia kodu, w tym plik o nazwie <funkcji-.dll>.

   • W obszarze roboczym rozwiń następujące foldery: <twoja aplikacja logiki>>lib\custom><function-name>. Potwierdź, że < podfolder z nazwą> funkcji zawiera plik function.json, który zawiera metadane dotyczące kodu funkcji, który napisałeś. Projektant przepływu pracy używa tego pliku do określenia niezbędnych danych wejściowych i wyjściowych podczas wywoływania kodu.

   W poniższym przykładzie pokazano przykładowe wygenerowane zestawy i inne pliki w projekcie aplikacji logiki:

   

4. Wywołaj swój kod z przepływu pracy

Po potwierdzeniu, że kod zostanie skompilowany, a projekt aplikacji logiki zawiera niezbędne pliki do uruchomienia kodu, skonfiguruj przepływ pracy w celu wywołania kodu.

1. W oknie Eksplorator rozwiń węzeł <workspace-name>, <logic-app-name>, a następnie <workflow-name>.

2. Otwórz menu skrótów dla workflow.jsoni wybierz pozycję Otwórz projektanta.

   Zostanie otwarty projektant przepływu pracy i zostanie wyświetlony domyślny przepływ pracy z następującym wyzwalaczem i akcjami:

   Operation	opis
   Wyzwalacz	Wbudowany wyzwalacz o nazwie Kiedy otrzymano żądanie HTTP.
   Action	Wbudowana akcja o nazwie Wywołaj funkcję lokalną w tej aplikacji logiki.
   Action	Wbudowana akcja Odpowiedź o nazwie Odpowiedź używana do odpowiadania dzwoniącemu tylko wtedy, gdy używasz wyzwalacza Żądanie.

3. W środowisku projektanta wybierz akcję o nazwie Wywołaj funkcję lokalną w tej aplikacji logicznej.

   Zostanie otwarte okienko informacji o akcji, aby można było skonfigurować wywołanie funkcji niestandardowej, na przykład:

   

4. Przejrzyj i upewnij się, że wartość parametru Nazwa funkcji jest ustawiona na funkcję, którą chcesz uruchomić. Przejrzyj lub zmień inne wartości parametrów używane przez funkcję.

5. Debugowanie kodu i przepływu pracy

1. Dla każdej z następujących usług Azure Storage uruchom emulator magazynu Azurite:

   • Azure Blob Service
   • Azure Queue Service
   • Usługa tabelowa platformy Azure

   1. W menu Visual Studio Code View wybierz pozycję Paleta poleceń.

   2. Po wyświetleniu monitu wybierz pozycję Azurite: Uruchom usługę Blob Service z listy.

   3. Z wyświetlonej listy katalogów roboczych wybierz aplikację logiczną.

   4. Powtórz następujące kroki dla Azurite: Uruchom usługę Kolejki i Azurite: Uruchom usługę Tabeli.

   Jeśli uda ci się, na pasku zadań w Visual Studio Code w dolnej części ekranu zostaną wyświetlone trzy uruchomione usługi magazynowe.

2. Dołącz debuger do projektu aplikacji logiki i projektu funkcji .NET, wykonując następujące kroki:

   1. W Visual Studio Code na pasku działań wybierz pozycję Uruchom i Debuguj (klawiatura: Ctrl+Shift+D).

      

   2. Z listy Uruchamianie i debugowanie wybierz pozycję Uruchom/Debuguj aplikację logiczną z funkcją lokalną (<aplikacja logiczna>), a następnie wybierz pozycję Uruchom (zielona strzałka).

      

      Występują następujące zdarzenia:

      • Okno Terminala zostanie otwarte, a rozpoczęty proces debugowania zostanie wyświetlony.
      • Okno konsoli Debug otwiera się i pokazuje status debugowania.
      • W dolnej części Visual Studio Code pasek zadań zmienia kolor pomarańczowy, co wskazuje, że .NET debuger jest ładowany.

3. Aby ustawić wszystkie punkty przerwania, w definicji funkcji (<nazwa-funkcji>.cs) lub definicji przepływu pracy (workflow.json), znajdź numer wiersza, w którym chcesz punkt przerwania, i wybierz sąsiadującą kolumnę, na przykład:

   

4. Aby ręcznie uruchomić wyzwalacz żądania w przepływie pracy, otwórz stronę Przegląd przepływu pracy:

   1. W projekcie aplikacji logiki otwórz menu skrótów pliku workflow.json , a następnie wybierz pozycję Przegląd.

      Na stronie Przegląd przepływu pracy przycisk Uruchom wyzwalacz jest dostępny, gdy chcesz ręcznie uruchomić przepływ pracy. W obszarze Właściwości przepływu pracy wartość adresu URL wywołania zwrotnego to adres URL punktu końcowego z możliwością wywołania, który jest tworzony przez wyzwalacz Żądania w przepływie pracy. Możesz wysyłać żądania do tego adresu URL w celu wyzwolenia przepływu pracy z innych aplikacji, w tym innych przepływów pracy aplikacji logiki.

   2. Na pasku narzędzi strony Przegląd wybierz pozycję Uruchom wyzwalacz.

      

      Po uruchomieniu przepływu pracy debuger aktywuje swój pierwszy punkt przerwania.

   3. Na pasku narzędzi Uruchom menu lub debugera wybierz akcję debugowania.

   Po zakończeniu przebiegu przepływu pracy na stronie Przegląd zostanie wyświetlony ukończony przebieg i podstawowe informacje o tym przebiegu.

5. Aby przejrzeć więcej informacji na temat przebiegu pracy, wybierz zakończony przebieg. Lub z listy obok kolumny Czas trwania wybierz pozycję Pokaż przebieg.

   

6. Wdrażanie kodu

Wdróż funkcje niestandardowe w taki sam sposób, jak w przypadku wdrażania projektu aplikacji logiki. Niezależnie od tego, czy wdrażasz z Visual Studio Code, czy korzystasz z procesu CI/CD DevOps, upewnij się, że zbudujesz kod przed wdrożeniem. Upewnij się też, że wszystkie zależne zespoły znajdują się w następujących folderach projektów aplikacji logicznych przed wdrożeniem:

• .NET 4.7.2: folder lib/custom/net472

• .NET 8: folder lib/custom/net8

Aby uzyskać więcej informacji, zobacz Deploy Standard workflows from Visual Studio Code to Azure (

Wstrzykiwanie zależności

Po wybraniu .NET 8 niestandardowy kod .NET w standardowych przepływach pracy obsługuje wstrzykiwanie zależności (DI). Ta funkcja umożliwia rejestrowanie usług raz, co sprawia, że są one automatycznie dostępne dla niestandardowych funkcji kodu w czasie wykonywania, zamiast tworzyć zależności wewnątrz każdej funkcji.

Bez wstrzykiwania zależności niestandardowe funkcje kodu często:

• Tworzenie wystąpień usługi bezpośrednio w funkcji.
• Duplikowanie logiki w wielu funkcjach lub procesach.
• Wymieszaj logikę biznesową z kodem instalacyjnym i konfiguracyjnym.

W miarę zwiększania się przepływów pracy kod niestandardowy staje się trudniejszy do testowania, ponownego użycia i konserwacji. Korzystając z wstrzyknięcia zależności, możesz:

• Oddziel logikę biznesową od wykonywania przepływu pracy.
• Wykorzystuj usługi współdzielone w różnych niestandardowych funkcjach kodowych.
• Dopasuj kod niestandardowy do standardowych wzorców programowania .NET.

Kod niestandardowy staje się bardziej zarządzany w produkcyjnych przepływach pracy, zwłaszcza gdy wiele przepływów pracy opiera się na tej samej logice.

Kiedy należy używać wstrzykiwania zależności

Jeśli masz proste lub jednorazowe funkcje kodu niestandardowego, prawdopodobnie nie potrzebujesz iniekcji zależności. Jeśli jednak Twój kod niestandardowy ma następujące wymagania, rozważ użycie wstrzyknięcia zależności:

• Wiele przepływów pracy używa lub współużytkuje te same niestandardowe funkcje kodu.
• Niestandardowe funkcje kodu zawierają logikę biznesową lub routingu, która zmienia się w czasie.
• Wymagana jest lepsza możliwość testowania lub długoterminowa konserwacja.

Jak wstrzykiwanie zależności wpływa na niestandardowe funkcje .NET

Wstrzykiwanie zależności nie zmienia sposobu wywoływania niestandardowych funkcji .NET ani zachowania przepływu pracy. Ta funkcja zmienia tylko podstawową niestandardową strukturę kodu, ale generuje ten sam wynik. W poniższych krokach opisano ten proces:

1. Azure Logic Apps ładuje niestandardowy projekt kodu.
2. Azure Logic Apps inicjuje, rejestruje i wstrzykuje wymagane usługi do danej funkcji.
3. Funkcja działa przy użyciu wstrzykiwanych zależności.

Włącz wstrzykiwanie zależności

Aby użyć iniekcji zależności z niestandardowym kodem .NET, wykonaj następujące wymagania:

1. Podczas tworzenia niestandardowego projektu kodu wybierz pozycję .NET 8.

   Tylko projekty z niestandardowym kodem w .NET 8 obsługują wstrzykiwanie zależności.

2. W projekcie dodaj klasę StartupConfiguration , aby zdefiniować listę zależności. Zaimplementuj IConfigureStartup interfejs i zarejestruj zależności przy użyciu metody IServiceCollection, na przykład:

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

   Interfejs IConfigureStartup jest zdefiniowany w Microsoft.Azure.Functions.Extensions.Workflows, natomiast IServiceCollection w Microsoft.Extensions.DependencyInjection. Więcej informacji można znaleźć w StartupConfiguration.cs.

3. W niestandardowym konstruktorze klasy funkcji kodu zainicjuj zarejestrowane usługi, definiując je jako parametry konstruktora, zamiast tworzyć je wewnątrz funkcji, na przykład:

   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
   
   } 
   

Poza kompilowaniem i wdrażaniem niestandardowego projektu kodu nie trzeba wykonywać żadnych innych kroków, edytować przepływ pracy ani wprowadzać żadnych innych zmian konfiguracji w Azure Logic Apps w celu włączenia iniekcji zależności.

Aby uzyskać więcej informacji, zobacz przykład Niestandardowego wstrzykiwania zależności w kodzie.

Dodaj własne pakiety NuGet do projektów z kodem niestandardowym

W przypadku niestandardowych projektów kodu opartych na nuGet korzystających z .NET 8 można dołączać własne pakiety NuGet i zarządzać nimi bez konieczności rozwiązywania konfliktów z zależnościami używanymi przez hosta procesu roboczego języka. Wystarczy bezpośrednio dodać zależności zestawu do oddzielnej lokalizacji zestawu w projekcie. W przypadku następujących wyjątków można wprowadzić dowolne wersje zestawów zależnych zgodne z .NET 8, których potrzebuje projekt:

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

Rozwiązywanie problemów

Błąd okienka informacji o akcjach

W projektancie przepływu pracy po wybraniu wbudowanej akcji o nazwie Wywołaj funkcję lokalną w tej aplikacji logiki okienko informacji akcji wyświetla następujący komunikat:

Failed to retrieve dynamic inputs. Error details:

W tym scenariuszu sprawdź projekt aplikacji logiki, aby sprawdzić, czy folder LogicApp\lib\custom jest pusty. Jeśli jest on pusty, w menu Terminal wybierz pozycję Uruchom Zadanie>build Functions.

Nie ma uruchomionego procesu o określonej nazwie.

Jeśli ten komunikat o błędzie zostanie wyświetlony podczas uruchamiania przepływu pracy, prawdopodobnie proces debugera został dołączony do usługi .NET Functions, a nie do aplikacji logiki.

Aby rozwiązać ten problem, z listy Uruchamianie i debugowanie wybierz pozycję Dołącz do aplikacji logiki (LogicApp),a następnie wybierz pozycję Odtwórz (zielony trójkąt).

Pakiet nie został poprawnie zaimportowany

Jeśli w oknie wyjściowym zostanie wyświetlony błąd podobny do poniższej wiadomości, upewnij się, że masz zainstalowaną przynajmniej wersję .NET 6.0. Jeśli masz zainstalowaną tę wersję, spróbuj odinstalować, a następnie zainstalować ponownie.

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]

Niepowodzenia buildów z błędami CS1031 i CS1001

Jeśli funkcja nie zawiera zmiennych i skompilujesz kod, w oknie Dane wyjściowe mogą być wyświetlane następujące komunikaty o błędach:

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)

Aby rozwiązać ten problem, w metodzie Run kodu dodaj następujący parametr:

string parameter1 = null

W poniższym przykładzie pokazano, jak wygląda sygnatura metody Run.

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

Treści powiązane

Utwórz standardowe przepływy pracy aplikacji logiki za pomocą Visual Studio Code