Tworzenie i uruchamianie kodu .NET z przepływów pracy Standard w Azure Logic Apps za pomocą Visual Studio Code

Dotyczy: Azure Logic Apps (Standard)

Gdy scenariusz integracji wymaga niestandardowych zadań lub logiki, które wychodzą poza wbudowane operacje i łączniki w Azure Logic Apps, utwórz i uruchom kod .NET jako funkcje niestandardowe w przepływach pracy w ramach edycji Standard. Przepływ pracy może następnie wykonywać zadania, takie jak niestandardowe analizowanie, walidacja, a nawet stosowanie reguł biznesowych. Korzystając z tej możliwości, można zaimplementować scenariusze, takie jak następujące zadania:

• Dostosowywanie implementacji logiki biznesowej.
• Dostosuj analizowanie w celu wyodrębnienia informacji z komunikatu przychodzącego.
• Przeprowadzanie walidacji danych i prostych przekształceń.
• Wykonywanie obliczeń.
• Konfigurowanie komunikatów wychodzących wysyłanych do innego systemu, takiego jak API.

W tym przewodniku pokazano, jak napisać i uruchomić własny kod .NET bezpośrednio w standardowych przepływach pracy przy użyciu Visual Studio Code. Dowiesz się, jak tworzyć, debugować i wdrażać funkcje lokalne przy użyciu Visual Studio Code, aby można było zachować niestandardową aranżację kodu i przepływu pracy, debugować je w jednej sesji i wdrażać je jako pojedyncze rozwiązanie.

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

• Funkcji niestandardowych można używać tylko w Visual Studio Code uruchomionym na Windows. Ta funkcja obsługuje używanie platformy .NET Framework i .NET 8 dla standardowych przepływów pracy aplikacji logiki wdrożonych i hostowanych w Azure.

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

   

   W tym przykładzie użyto weather-project 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
   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 istnieją żadne błędy kompilacji. Projekt funkcji .NET automatycznie obejmuje zadania kompilacji, które kompilują i dodają kod do folderu lib\custom w projekcie aplikacji logicznej, w którym przepływy pracy szukają niestandardowych funkcji do uruchomienia. 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. Upewnij się, że podfolder o nazwie net472 lub net8 zawiera pliki zestawu (DLL) wymagane do uruchomienia kodu, w tym plik o nazwie <nazwa-funkcji>.dll.

   • W obszarze roboczym rozwiń następujące foldery: <twoja aplikacja logiki>>lib\custom><function-name>. Upewnij się, że podfolder o nazwie <function-name> zawiera plik function.json zawierający metadane dotyczące napisanego kodu funkcji. 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.
      • Zostanie otwarte okno Konsola debugowania i zostanie wyświetlony stan 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 używasz procesu DevOps ciągłej integracji/ciągłego wdrażania, przed wdrożeniem kodu upewnij się, że kod został skompilowany. Przed wdrożeniem upewnij się również, że wszystkie zależne zestawy istnieją w następującym folderze projektu aplikacji logiki:

• .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. Z wstrzykiwaniem zależności można:

• 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 kod niestandardowy ma następujące wymagania, może być konieczne użycie iniekcji 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.Extensions.DependencyInjection. Aby uzyskać więcej informacji, zobacz 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.

Przynieś własne pakiety NuGet

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]

Błędy kompilacji

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