Udostępnij za pośrednictwem


Tworzenie i uruchamianie kodu platformy .NET na podstawie standardowych przepływów pracy w usłudze Azure Logic Apps

Dotyczy: Azure Logic Apps (Standardowa)

W przypadku rozwiązań integracji, w których musisz tworzyć i uruchamiać kod .NET z przepływu pracy aplikacji logiki w warstwie Standardowa, możesz użyć programu Visual Studio Code z rozszerzeniem Azure Logic Apps (Standard). To 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 programie Visual Studio Code. Wykonaj kroki kodu i przepływów 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 programu BizTalk Server, dzięki czemu można przenieść niestandardowe inwestycje platformy .NET ze środowiska lokalnego do chmury.

Dzięki możliwości pisania własnego kodu można wykonać scenariusze, takie jak:

  • Niestandardowa implementacja logiki biznesowej
  • Analizowanie niestandardowe w celu wyodrębnienia informacji z komunikatu przychodzącego
  • Walidacja danych i proste przekształcenia
  • Kształtowanie komunikatów dla komunikatów wychodzących do innego systemu, takiego jak interfejs API
  • Obliczenia

Ta funkcja nie jest odpowiednia w scenariuszach, takich jak następujące:

  • Uruchamianie procesów, które potrwają ponad 10 minut
  • Duże przekształcenia komunikatów i danych
  • Złożone scenariusze przetwarzania wsadowego i debatowania
  • Składniki potoku programu BizTalk Server implementujące przesyłanie strumieniowe

Aby uzyskać więcej informacji na temat ograniczeń w usłudze Azure Logic Apps, zobacz Limity i konfiguracja — Azure Logic Apps.

Wymagania wstępne

Ograniczenia

  • Tworzenie funkcji niestandardowych nie jest obecnie dostępne w witrynie Azure Portal. Jednak po wdrożeniu funkcji z programu Visual Studio Code na platformę Azure wykonaj kroki opisane w temacie Wywoływanie kodu z przepływu pracy dla witryny Azure Portal. Możesz użyć wbudowanej akcji o nazwie Wywołaj funkcję lokalną w tej aplikacji logiki, aby wybrać z wdrożonych funkcji niestandardowych i uruchomić kod. Kolejne akcje w przepływie pracy mogą odwoływać się do danych wyjściowych z tych funkcji, tak jak w każdym innym przepływie pracy. Możesz wyświetlić wbudowaną historię uruchamiania, dane wejściowe i wyjściowe akcji wbudowanej.

  • Funkcje niestandardowe używają izolowanego procesu roboczego do wywoływania kodu w przepływie pracy aplikacji logiki. Aby uniknąć konfliktów odwołań do pakietu między własnym kodem funkcji a procesem roboczym, użyj tych samych wersji pakietu, do których odwołuje się proces roboczy. Aby uzyskać pełną listę pakietów i wersje, do których odwołuje się proces roboczy, zobacz Zależności procesu roboczego i pakietu.

Tworzenie projektu kodu

Najnowsze rozszerzenie usługi Azure Logic Apps (Standard) dla programu 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, drugi projekt do tworzenia przepływów pracy.

Uwaga

Nie można użyć tego samego folderu projektu zarówno dla kodu, jak i przepływów pracy.

  1. Otwórz Visual Studio Code. Na pasku działań wybierz ikonę platformy Azure . (Klawiatura: Shift+Alt+A)

  2. W wyświetlonym oknie platformy Azure na pasku narzędzi sekcji Obszar roboczy z menu Azure Logic Apps wybierz pozycję Utwórz nowy obszar roboczy aplikacji logiki.

    Zrzut ekranu przedstawiający program Visual Studio Code, okno platformy Azure, pasek narzędzi sekcji obszaru roboczego i wybraną opcję Utwórz nowy obszar roboczy aplikacji logiki.

  3. W polu Wybierz folder przejdź do folderu lokalnego utworzonego dla projektu i wybierz go.

  4. Po wyświetleniu okna monitu Tworzenie nowego obszaru roboczego aplikacji logiki podaj nazwę obszaru roboczego:

    Zrzut ekranu przedstawiający program Visual Studio Code z monitem o wprowadzenie nazwy obszaru roboczego.

    Ten przykład jest kontynuowany w usłudze MyLogicAppWorkspace.

  5. Po wyświetleniu okna monitu Wybieranie szablonu projektu dla obszaru roboczego aplikacji logiki wybierz pozycję Aplikacja logiki z niestandardowym projektem kodu.

    Zrzut ekranu przedstawiający program Visual Studio Code z monitem o wybranie szablonu projektu dla obszaru roboczego aplikacji logiki.

  6. W przypadku przepływów pracy aplikacji logiki hostowanej w warstwie Standardowa platformy Azure postępuj zgodnie z monitem, aby wybrać program .NET Framework lub .NET 8.

  7. Postępuj zgodnie z kolejnymi monitami, aby podać następujące przykładowe wartości:

    Towar Przykładowa wartość
    Nazwa funkcji projektu funkcji platformy .NET WeatherForecast
    Nazwa przestrzeni nazw projektu funkcji platformy .NET Contoso.Enterprise
    Szablon przepływu pracy:
    - Stanowy przepływ pracy
    - Przepływ pracy bezstanowy
    Stanowy przepływ pracy
    Nazwa przepływu pracy MyWorkflow
  8. Wybierz pozycję Otwórz w bieżącym oknie.

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

    Zrzut ekranu przedstawiający program Visual Studio Code z utworzonym obszarem roboczym.

    Węzeł opis
    <nazwa obszaru roboczego> Zawiera zarówno projekt funkcji platformy .NET, jak i projekt przepływu pracy aplikacji logiki.
    Funkcje Zawiera artefakty projektu funkcji platformy .NET. Na przykład <plik nazwa-funkcji>.cs to plik kodu, w którym można utworzyć kod.
    LogicApp Zawiera artefakty dla projektu aplikacji logiki, w tym pusty przepływ pracy.

Pisanie kodu

  1. W obszarze roboczym rozwiń węzeł Funkcje , jeśli jeszcze nie został rozszerzony.

  2. <Otwórz plik function-name>.cs o nazwie WeatherForecast.cs w tym przykładzie.

    Domyślnie ten plik zawiera przykładowy kod, który zawiera następujące elementy kodu wraz z wcześniej podanymi przykładowymi wartościami w odpowiednich przypadkach:

    • Nazwa przestrzeni nazw
    • Nazwa klasy
    • Nazwa funkcji
    • Parametry funkcji
    • Typ zwracany
    • Typ złożony

    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 Run metoda 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 platformy .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 wraz z informacjami ś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);
    
        <...>
    
    }
    
  3. Zastąp przykładowy kod funkcji własnym kodem i zmodyfikuj domyślną Run metodę dla własnych 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 kod przykładowy jest kontynuowany bez żadnych zmian.

Kompilowanie i kompilowanie kodu

Po zakończeniu pisania kodu skompiluj, aby upewnić się, że nie istnieją żadne błędy kompilacji. Projekt funkcji platformy .NET automatycznie zawiera zadania kompilacji, które kompilują, a następnie dodają kod do folderu lib\custom w projekcie aplikacji logiki, w którym przepływy pracy szukają funkcji niestandardowych do uruchomienia. Te zadania umieszczają zestawy w folderze lib\custom\net472 lub lib\custom\net8 na podstawie wersji platformy .NET.

  1. W programie Visual Studio Code z menu Terminal wybierz pozycję Nowy terminal.

  2. Z wyświetlonej listy katalogów roboczych wybierz pozycję Funkcje jako bieżący katalog roboczy dla nowego terminalu.

    Zrzut ekranu przedstawiający program Visual Studio Code, monit o bieżący katalog roboczy i wybrany katalog usługi Functions.

    Program Visual Studio Code otwiera okno terminalu z wierszem polecenia.

  3. W oknie Terminal w wierszu polecenia wprowadź polecenie dotnet restore.

    Program Visual Studio Code analizuje projekty i określa, czy są aktualne.

    Zrzut ekranu przedstawiający program Visual Studio Code, okno terminalu i ukończone polecenie dotnet restore.

  4. Po ponownym wyświetleniu wiersza polecenia wprowadź polecenie dotnet build. Z menu Terminal wybierz pozycję Uruchom zadanie. Z listy zadań wybierz pozycję Build (Functions).

    Jeśli kompilacja zakończy się pomyślnie, okno terminalu zgłosi, że kompilacja zakończyła się pomyślnie.

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

    • W obszarze roboczym rozwiń następujące foldery: LogicApp>lib\custom>net472 lub net8 na podstawie wersji platformy .NET. Upewnij się, że podfolder o nazwie net472 lub net8 zawiera odpowiednio pliki zestawu (DLL) wymagane do uruchomienia kodu, w tym plik o nazwie< nazwa-funkcji>.dll.

    • W obszarze roboczym rozwiń następujące foldery: LogicApp>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:

    Zrzut ekranu przedstawiający program Visual Studio Code i obszar roboczy aplikacji logiki z projektem funkcji platformy .NET i projektem aplikacji logiki, teraz z wygenerowanymi zestawami i innymi wymaganymi plikami.

Wywoływanie kodu z przepływu pracy

Po potwierdzeniu, że kod zostanie skompilowany i że projekt aplikacji logiki zawiera niezbędne pliki do uruchomienia kodu, otwórz domyślny przepływ pracy dołączony do projektu aplikacji logiki.

  1. W obszarze roboczym w obszarze LogicApp rozwiń <węzeł nazwa> przepływu pracy, otwórz menu skrótów dla workflow.json, a następnie wybierz pozycję Otwórz projektanta.

    W wyświetlonym projektancie przepływu pracy domyślny przepływ pracy dołączony do projektu aplikacji logiki jest wyświetlany z następującym wyzwalaczem i akcjami:

  2. Wybierz akcję o nazwie Wywołaj funkcję lokalną w tej aplikacji logiki.

    Okienko informacji o akcji zostanie otwarte po prawej stronie.

    Zrzut ekranu przedstawiający program Visual Studio Code, projektant przepływu pracy i domyślny przepływ pracy z wyzwalaczem i akcjami.

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

Debugowanie kodu i przepływu pracy

  1. Powtórz następujące kroki, aby uruchomić emulator magazynu Azurite trzy razy: jeden raz dla następujących usług Azure Storage:

    • Azure Blob Service
    • Usługa kolejek systemu Azure
    • Azure Table Service
    1. Z menu Widok programu Visual Studio Code wybierz pozycję Paleta poleceń.

    2. Po wyświetleniu monitu znajdź i wybierz pozycję Azurite: Uruchom usługę Blob Service.

    3. Z wyświetlonej listy katalogów roboczych wybierz pozycję LogicApp.

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

    Po pomyślnym zakończeniu działania paska zadań programu Visual Studio Code w dolnej części ekranu są wyświetlane trzy uruchomione usługi magazynu, na przykład:

    Zrzut ekranu przedstawiający pasek zadań programu Visual Studio Code z uruchomioną usługą Azure Blob Service, usługą Azure Queue Service i usługą Azure Table Service.

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

    1. Na pasku działań programu Visual Studio Code wybierz pozycję Uruchom i debuguj. (Klawiatura: Ctrl+Shift+D)

      Zrzut ekranu przedstawiający pasek działań programu Visual Studio Code z wybraną funkcją Uruchom i Debuguj.

    2. Z listy Uruchamianie i debugowanie wybierz pozycję Dołącz do aplikacji logiki (LogicApp), jeśli nie została jeszcze wybrana, a następnie wybierz pozycję Odtwórz (zielona strzałka).

      Zrzut ekranu przedstawiający listę Uruchom i Debuguj z wybraną pozycją Dołącz do aplikacji logiki i wybraną pozycją Odtwórz.

      Zostanie otwarte okno Terminal i zostanie wyświetlone rozpoczęty proces debugowania. Zostanie wyświetlone okno Konsola debugowania i zostanie wyświetlone stany debugowania. W dolnej części programu Visual Studio Code pasek zadań zmieni kolor pomarańczowy, co oznacza, że debuger platformy .NET jest ładowany.

  3. Dołącz debuger do projektu funkcji platformy .NET, wykonując następujące kroki na podstawie kodu:

    Projekty platformy .NET 8

    1. Z menu Widok programu Visual Studio Code wybierz pozycję Paleta poleceń.

    2. Z palety poleceń znajdź i wybierz pozycję Debuguj: Dołącz do procesu .NET 5 lub .NET Core.

      Zrzut ekranu przedstawiający listę Uruchom i Debuguj z wybraną pozycję Dołącz do funkcji NET i wybraną przyciskiem Odtwarzania.

    3. Z listy znajdź i wybierz proces dotnet.exe . Jeśli istnieje wiele procesów dotnet.exe , wybierz proces, który ma następującą ścieżkę:

      <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

    Projekty programu .NET Framework

    Z listy Uruchamianie i debugowanie wybierz pozycję Dołącz do funkcji platformy .NET (Funkcje), jeśli nie została jeszcze wybrana, a następnie wybierz pozycję Odtwórz (zielona strzałka).

    Zrzut ekranu przedstawiający listę Uruchom i Debuguj z wybraną funkcją Dołącz do funkcji platformy NET (Functions) i wybranym przyciskiem Odtwarzania.

  4. 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, a następnie wybierz kolumnę z lewej strony, na przykład:

    Zrzut ekranu przedstawia program Visual Studio Code i otwarty plik kodu funkcji z punktem przerwania ustawionym dla wiersza w kodzie.

  5. 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 i 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.

      Zrzut ekranu przedstawiający otwartą stronę Przegląd programu Visual Studio Code i przepływu pracy.

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

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

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

  8. Aby przejrzeć więcej informacji na temat przebiegu przepływu pracy, wybierz ukończone uruchomienie. Lub z listy obok kolumny Czas trwania wybierz pozycję Pokaż przebieg.

    Zrzut ekranu przedstawiający program Visual Studio Code i zakończone uruchomienie przepływu pracy.

Wdrażanie kodu

Funkcje niestandardowe można wdrożyć w taki sam sposób, jak w przypadku wdrażania projektu aplikacji logiki. Niezależnie od tego, czy wdrażasz program Visual Studio Code, czy korzystasz z procesu ciągłej integracji/ciągłego wdrażania DevOps, przed wdrożeniem upewnij się, że kod jest kompilowany i ż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 Wdrażanie standardowych przepływów pracy z programu Visual Studio Code na platformę Azure.

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 pusty, w menu Terminal wybierz pozycję Uruchom funkcje kompilacji zadania>.

Brak procesu o określonej nazwie jest obecnie uruchomiony

Jeśli ten komunikat o błędzie zostanie wyświetlony podczas uruchamiania przepływu pracy, prawdopodobnie masz proces debugera 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 Dane wyjściowe zostanie wyświetlony błąd podobny do poniższego komunikatu, upewnij się, że zainstalowano co najmniej platformę .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 kodu Run dołącz następujący parametr:

string parameter1 = null

W poniższym przykładzie pokazano, jak Run pojawia się podpis metody:

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

Następne kroki

Tworzenie standardowych przepływów pracy za pomocą programu Visual Studio Code