Utveckla Azure Functions med hjälp av Visual Studio

  • Artikel
  • 21 minuter för att läsa

Med Visual Studio kan du utveckla, testa och distribuera C#-klassbiblioteksfunktioner till Azure. Om den här upplevelsen är din första med Azure Functions kan du läsa En introduktion till Azure Functions.

Visual Studio ger följande fördelar när du utvecklar dina funktioner:

  • Redigera, skapa och köra funktioner på din lokala utvecklingsdator.
  • Publicera ditt Azure Functions projekt direkt till Azure och skapa Azure-resurser efter behov.
  • Använd C#-attribut för att deklarera funktionsbindningar direkt i C#-koden.
  • Utveckla och distribuera förkompilerade C#-funktioner. I förväg ställda funktioner ger bättre kallstartsprestanda än C#-skriptbaserade funktioner.
  • Koda dina funktioner i C# samtidigt som du har alla fördelar med Visual Studio-utveckling.

Den här artikeln innehåller information om hur du använder Visual Studio för att utveckla C#-klassbiblioteksfunktioner och publicera dem i Azure. Innan du läser den här artikeln bör du överväga att slutföra functions-snabbstarten för Visual Studio.

Om inget annat anges är procedurer och exempel som visas för Visual Studio 2022. Mer information om Visual Studio 2022-versioner finns i viktig information eller viktig information om förhandsversionen.

Förutsättningar

  • Azure Functions Tools. Om du vill lägga till Azure-funktionsverktyg inkluderar du arbetsbelastningen Azure-utveckling i Visual Studio-installationen. Om du använder Visual Studio 2017 kan du behöva följa några extra installationssteg.

  • Andra resurser som du behöver, till exempel ett Azure Storage-konto, skapas i din prenumeration under publiceringsprocessen.

  • Om du inte har en Azure-prenumeration kan du skapa ett kostnadsfritt Azure-konto innan du börjar.

Skapa ett Azure Functions-projekt

Den Azure Functions projektmallen i Visual Studio skapar ett C#-klassbiblioteksprojekt som du kan publicera till en funktionsapp i Azure. Du kan använda en funktionsapp för att gruppera funktioner som en logisk enhet för enklare hantering, distribution, skalning och delning av resurser.

  1. På Visual Studio-menyn väljer du Arkiv>Nytt>projekt.

  2. I Skapa ett nytt projekt anger du funktioner i sökrutan, väljer mallen Azure Functions och väljer sedan Nästa.

  3. I Konfigurera det nya projektet anger du ett projektnamn för projektet och väljer sedan Skapa. Funktionsappens namn måste vara ett giltigt C#-namnområde. Du kan inte använda understreck, bindestreck eller andra icke-alfanumeriska tecken.

  4. För inställningarna skapa en ny Azure Functions program använder du värdena i följande tabell:

    Inställningen Värde Beskrivning
    .NET-version .NET 6 Det här värdet skapar ett funktionsprojekt som körs i processen med version 4.x av Azure Functions-körningen. Azure Functions 1.x har stöd för .NET Framework. Mer information finns i översikten över Azure Functions körningsversioner.
    Funktionsmall HTTP-utlösare Det här värdet skapar en funktion som utlöses av en HTTP-begäran.
    Lagringskonto (AzureWebJobsStorage) Lagringsemulator Eftersom en funktionsapp i Azure kräver ett lagringskonto tilldelas eller skapas ett när du publicerar projektet till Azure. En HTTP-utlösare använder inte en anslutningssträng för Azure Storage-kontot. alla andra utlösartyper kräver en giltig anslutningssträng för Azure Storage-kontot.
    Auktoriseringsnivå Anonym Funktionen som skapats kan utlösas av alla klienter utan att en nyckel anges. Den här auktoriseringsinställningen gör det enkelt att testa den nya funktionen. Mer information om nycklar och auktorisering finns i Auktoriseringsnycklar och HTTP- och webhook-bindningar.

    Azure Functions projektinställningar

    Se till att du ställer in auktoriseringsnivånpå Anonym. Om du väljer standardnivå för Funktion måste du presentera funktionsnyckeln i begäranden om åtkomst till funktionsslutpunkten.

  5. Välj Skapa för att skapa funktionsprojektet och HTTP-utlösarfunktionen.

När du har skapat ett Azure Functions projekt skapar projektmallen ett C#-projekt, installerar Microsoft.NET.Sdk.Functions NuGet-paketet och anger målramverket. Det nya projektet har följande filer:

  • host.json: Gör att du kan konfigurera Functions-värden. De här inställningarna gäller både när du kör lokalt och i Azure. Mer information finns i host.json-referens.

  • local.settings.json: Upprätthåller inställningar som används när funktioner körs lokalt. De här inställningarna används inte när du kör i Azure. Mer information finns i Filen Lokala inställningar.

    Viktigt

    Eftersom filen local.settings.json kan innehålla hemligheter måste du undanta den från projektkällans kontroll. Kontrollera att inställningen Kopiera till utdatakatalog för den här filen är inställd på Kopiera om nyare.

Mer information finns i Functions-klassbiblioteksprojekt.

Lokala inställningar

När du kör i en funktionsapp i Azure lagras de inställningar som krävs av dina funktioner på ett säkert sätt i appinställningarna. Under den lokala utvecklingen läggs de här inställningarna i stället till i Values objektet i filen local.settings.json. Filen local.settings.json lagrar även inställningar som används av lokala utvecklingsverktyg.

Eftersom local.settings.json kan innehålla hemligheter, till exempel anslutningssträngar, bör du aldrig lagra den på en fjärrlagringsplats. Mer information om lokala inställningar finns i Filen Lokala inställningar.

Visual Studio laddar inte automatiskt upp inställningarna i local.settings.json när du publicerar projektet. För att säkerställa att de här inställningarna också finns i funktionsappen i Azure laddar du upp dem när du har publicerat projektet. Mer information finns i Funktionsappinställningar. Värdena i en ConnectionStrings samling publiceras aldrig.

Koden kan också läsa funktionsappens inställningsvärden som miljövariabler. Mer information finns i Miljövariabler.

Konfigurera projektet för lokal utveckling

Functions-körningen använder ett Azure Storage-konto internt. För alla andra utlösartyper än HTTP och webhooks anger du Values.AzureWebJobsStorage nyckeln till en giltig anslutningssträng för Azure Storage-kontot. Funktionsappen kan också använda Azurite-emulatorn för den AzureWebJobsStorage anslutningsinställning som krävs av projektet. Om du vill använda emulatorn anger du värdet AzureWebJobsStorage för till UseDevelopmentStorage=true. Ändra den här inställningen till en faktisk anslutningssträng för lagringskontot före distributionen. Mer information finns i Lokal lagringsemulator.

Så här anger du anslutningssträngen för lagringskontot:

  1. Navigera till ditt lagringskonto i Azure Portal.

  2. På fliken Åtkomstnycklar under Säkerhet + nätverk kopierar du anslutningssträngenför key1.

  3. I projektet öppnar du filen local.settings.json och anger värdet AzureWebJobsStorage för nyckeln till anslutningssträngen som du kopierade.

  4. Upprepa föregående steg för att lägga till unika nycklar i matrisen Values för alla andra anslutningar som krävs av dina funktioner.

Lägga till en funktion i projektet

I C#-klassbiblioteksfunktioner definieras de bindningar som används av funktionen genom att använda attribut i koden. När du skapar funktionsutlösare från de angivna mallarna tillämpas utlösarattributen åt dig.

  1. I Solution Explorer högerklickar du på projektnoden och väljer Lägg till>nytt objekt.

  2. Välj Azure-funktion, ange ett namn för klassen och välj sedan Lägg till.

  3. Välj utlösaren, ange bindningsegenskaperna och välj sedan Lägg till. I följande exempel visas inställningarna för att skapa en utlösarfunktion för Queue Storage.

    Skapa en queue storage-utlösarfunktion

    Sedan uppmanas du att välja mellan Azurite Storage-emulatorn eller att referera till ett etablerat Azure Storage-konto.

    I det här utlösarexemplet används en anslutningssträng med en nyckel med namnet QueueStorage. Den här nyckeln, som lagras i filen local.settings.json, refererar antingen till Azurite-emulatorn eller ett Azure Storage-konto.

  4. Granska den nyligen tillagda klassen. Du ser en statisk Run() metod som tilldelas attributet FunctionName . Det här attributet anger att metoden är startpunkten för funktionen.

    Följande C#-klass representerar till exempel en grundläggande utlösarfunktion för Queue Storage:

    using System;
using Microsoft.Azure.WebJobs;
using Microsoft.Azure.WebJobs.Host;
using Microsoft.Extensions.Logging;

namespace FunctionApp1
{
    public static class Function1
    {
        [FunctionName("QueueTriggerCSharp")]
        public static void Run([QueueTrigger("myqueue-items", 
            Connection = "QueueStorage")]string myQueueItem, ILogger log)
        {
            log.LogInformation($"C# Queue trigger function processed: {myQueueItem}");
        }
    }
}

Ett bindningsspecifikt attribut tillämpas på varje bindningsparameter som skickas till startpunktsmetoden. Attributet tar bindningsinformationen som parametrar. I föregående exempel har den första parametern ett QueueTrigger -attribut som anger en utlösarfunktion för Queue Storage. Könamnet och anslutningssträngens inställningsnamn skickas som parametrar till attributet QueueTrigger . Mer information finns i Azure Queue Storage-bindningar för Azure Functions.

Använd proceduren ovan för att lägga till fler funktioner i funktionsappsprojektet. Varje funktion i projektet kan ha en annan utlösare, men en funktion måste ha exakt en utlösare. Mer information finns i Azure Functions utlösare och bindningar.

Lägga till bindningar

Precis som med utlösare läggs indata- och utdatabindningar till i funktionen som bindningsattribut. Lägg till bindningar i en funktion på följande sätt:

  1. Kontrollera att du har konfigurerat projektet för lokal utveckling.

  2. Lägg till lämpligt NuGet-tilläggspaket för den specifika bindningen genom att hitta de bindningsspecifika NuGet-paketkraven i referensartikeln för bindningen. Du kan till exempel hitta paketkrav för Event Hubs-utlösaren i artikeln Referens för Event Hubs-bindning.

  3. Använd följande kommando i Package Manager-konsolen för att installera ett specifikt paket:

    Install-Package Microsoft.Azure.WebJobs.Extensions.<BINDING_TYPE> -Version <TARGET_VERSION>

    I det här exemplet ersätter <BINDING_TYPE> du med namnet som är specifikt för bindningstillägget och <TARGET_VERSION> med en specifik version av paketet, till exempel 3.0.0-beta5. Giltiga versioner visas på de enskilda paketsidorna på NuGet.org. De huvudversioner som motsvarar Functions runtime 1.x eller 2.x anges i referensartikeln för bindningen.

  4. Om det finns appinställningar som bindningen behöver lägger du till Values dem i samlingen i den lokala inställningsfilen.

    Funktionen använder dessa värden när den körs lokalt. När funktionen körs i funktionsappen i Azure används inställningarna för funktionsappen.

  5. Lägg till lämpligt bindningsattribut i metodsignaturen. I följande exempel utlöser ett kömeddelande funktionen och utdatabindningen skapar ett nytt kömeddelande med samma text i en annan kö.

    public static class SimpleExampleWithOutput
{
    [FunctionName("CopyQueueMessage")]
    public static void Run(
        [QueueTrigger("myqueue-items-source", Connection = "AzureWebJobsStorage")] string myQueueItem, 
        [Queue("myqueue-items-destination", Connection = "AzureWebJobsStorage")] out string myQueueItemCopy,
        ILogger log)
    {
        log.LogInformation($"CopyQueueMessage function processed: {myQueueItem}");
        myQueueItemCopy = myQueueItem;
    }
}

    Anslutningen till Queue Storage hämtas från inställningen AzureWebJobsStorage . Mer information finns i referensartikeln för den specifika bindningen.

En fullständig lista över bindningar som stöds av Functions finns i Bindningar som stöds.

Köra funktioner lokalt

Med Azure Functions Core Tools kan du köra Azure Functions-projekt på din lokala utvecklingsdator. När du trycker på F5 för att felsöka ett Functions-projekt börjar den lokala Functions-värden (func.exe) lyssna på en lokal port (vanligtvis 7071). Alla anropbara funktionsslutpunkter skrivs till utdata och du kan använda dessa slutpunkter för att testa dina funktioner. Mer information finns i Arbeta med Azure Functions Core Tools. Du uppmanas att installera dessa verktyg första gången du startar en funktion från Visual Studio.

Så här startar du funktionen i Visual Studio i felsökningsläge:

  1. Tryck på F5. Acceptera begäran från Visual Studio för att ladda ned och installera Azure Functions Core (CLI)-verktyg. Du kan också behöva aktivera ett brandväggsfel så att verktygen kan hantera HTTP-begäranden.

  2. När projektet körs testar du koden på samma sätt som du testar en distribuerad funktion.

    När du kör Visual Studio i felsökningsläge uppnås brytpunkterna som förväntat.

Ett mer detaljerat testscenario med Visual Studio finns i Testa funktioner.

Publicera till Azure

När du publicerar från Visual Studio används en av de två distributionsmetoderna:

Använd följande steg för att publicera projektet till en funktionsapp i Azure.

  1. I Solution Explorer högerklickar du på projektet och väljer Publicera. I Mål väljer du Azure och sedan Nästa.

    Skärmbild av publiceringsfönstret.

  2. Välj Azure-funktionsapp (Windows) som Specifikt mål, som skapar en funktionsapp som körs i Windows och välj sedan Nästa.

    Skärmbild av publiceringsfönstret med ett specifikt mål.

  3. I funktionsinstansen väljer du Skapa en ny Azure-funktion...

    Skärmbild av att skapa en ny funktionsappinstans.

  4. Skapa en ny instans med de värden som anges i följande tabell:

    Inställningen Värde Beskrivning
    Namn Globalt unikt namn Namn som unikt identifierar din nya funktionsapp. Acceptera det här namnet eller ange ett nytt namn. Giltiga tecken är: a-z, 0-9och -.
    Prenumeration Din prenumeration Den Azure-prenumeration som ska användas. Acceptera den här prenumerationen eller välj en ny i listrutan.
    Resursgrupp Namnet på resursgruppen Den resursgrupp där du vill skapa funktionsappen. Välj en befintlig resursgrupp i listrutan eller välj Ny för att skapa en ny resursgrupp.
    Plantyp Förbrukning När du publicerar projektet till en funktionsapp som körs i en förbrukningsplan betalar du bara för körningar av funktionsappen. Andra värdplaner medför högre kostnader.
    Plats Apptjänstens plats Välj en plats i en region nära dig eller andra tjänster som dina funktioner har åtkomst till.
    Azure Storage Allmänt lagringskonto Azure Functions-körmiljön kräver ett Azure Storage-konto. Välj Ny för att konfigurera ett allmänt lagringskonto. Du kan också välja ett befintligt konto som uppfyller kraven för lagringskontot.

    Skärmbild av dialogrutan Skapa App Service.

  5. Välj Skapa för att skapa en funktionsapp och dess relaterade resurser i Azure. Statusen för resursskapande visas längst ned till vänster i fönstret.

  6. I Functions-instansen kontrollerar du att paketfilen Kör från är markerad. Funktionsappen distribueras med zip-distribution med Läget Kör från paket aktiverat. Zip Deploy är den rekommenderade distributionsmetoden för ditt funktionsprojekt som ger bättre prestanda.

    Skärmbild av skapande av slutförd profil.

  7. Välj Slutför och på sidan Publicera väljer du Publicera för att distribuera paketet som innehåller dina projektfiler till din nya funktionsapp i Azure.

    När distributionen är klar visas rot-URL:en för funktionsappen i Azure på fliken Publicera .

  8. På fliken Publicera i avsnittet Värd väljer du Öppna i Azure Portal. Då öppnas den nya funktionsappens Azure-resurs i Azure Portal.

    Skärmbild av meddelande om att publiceringen lyckades.

Funktionsappinställningar

Visual Studio laddar inte upp de här inställningarna automatiskt när du publicerar projektet. Alla inställningar som du lägger till i local.settings.json måste du också lägga till i funktionsappen i Azure.

Det enklaste sättet att ladda upp de nödvändiga inställningarna till funktionsappen i Azure är att expandera de tre punkterna bredvid avsnittet Värd och välja länken Hantera Azure App Service inställningar som visas när du har publicerat projektet.

Inställningar i publiceringsfönstret

Om du väljer den här länken visas dialogrutan Programinställningar för funktionsappen, där du kan lägga till nya programinställningar eller ändra befintliga.

Programinställningar

Lokalt visas ett inställningsvärde i filen local.settings.json och Remote visar ett aktuellt inställningsvärde i funktionsappen i Azure. Välj Lägg till inställning för att skapa en ny appinställning. Använd infoga-värdet från den lokala länken för att kopiera ett inställningsvärde till fältet Fjärr . Väntande ändringar skrivs till den lokala inställningsfilen och funktionsappen när du väljer OK.

Anteckning

Som standard är filen local.settings.json inte incheckad i källkontrollen. Det innebär att om du klonar ett lokalt Functions-projekt från källkontrollen har projektet ingen local.settings.json-fil. I det här fallet måste du manuellt skapa filen local.settings.json i projektroten så att dialogrutan Programinställningar fungerar som förväntat.

Du kan också hantera programinställningar på något av följande sätt:

Fjärrfelsökning

Om du vill felsöka funktionsappen via fjärranslutning måste du publicera en felsökningskonfiguration för projektet. Du måste också aktivera fjärrfelsökning i funktionsappen i Azure.

Det här avsnittet förutsätter att du redan har publicerat till funktionsappen med hjälp av en versionskonfiguration.

Överväganden för fjärrfelsökning

  • Fjärrfelsökning rekommenderas inte i en produktionstjänst.
  • Om felsökning av Just My Code är aktiverat inaktiverar du det.
  • Undvik långa stopp vid brytpunkter vid fjärrfelsökning. Azure behandlar en process som har stoppats i mer än några minuter som en process som inte svarar och stänger av den.
  • När du felsöker skickar servern data till Visual Studio, vilket kan påverka bandbreddsavgifterna. Information om bandbreddshastigheter finns i Priser för Azure.
  • Fjärrfelsökning inaktiveras automatiskt i funktionsappen efter 48 timmar. Efter 48 timmar måste du återaktivera fjärrfelsökning.

Bifoga felsökningsprogrammet

Hur du kopplar felsökningsprogrammet beror på körningsläget. När du felsöker en isolerad arbetsprocessapp måste du för närvarande koppla fjärrfelsökaren till en separat .NET-process, och flera andra konfigurationssteg krävs.

När du är klar bör du inaktivera fjärrfelsökning.

Så här kopplar du en fjärrfelsökare till en funktionsapp som körs i processen med Functions-värden:

  • På fliken Publicera väljer du ellipserna (...) i avsnittet Värd och väljer sedan Bifoga felsökningsprogram.

    Skärmbild av hur du kopplar felsökningsprogrammet från Visual Studio.

Visual Studio ansluter till funktionsappen och aktiverar fjärrfelsökning, om den inte redan är aktiverad. Den letar också upp och kopplar felsökningsprogrammet till appens värdprocess. Nu kan du felsöka funktionsappen som vanligt.

Inaktivera fjärrfelsökning

När du har fjärrfelsökt koden bör du inaktivera fjärrfelsökning i Azure Portal. Fjärrfelsökning inaktiveras automatiskt efter 48 timmar, om du glömmer det.

  1. På fliken Publicera i projektet väljer du ellipserna (...) i avsnittet Värd och väljer Öppna i Azure Portal. Den här åtgärden öppnar funktionsappen i Azure Portal som projektet distribueras till.

  2. I funktionsappen väljer du Konfiguration under inställningar, väljer Allmänna inställningar, ställer in Fjärrfelsökning till Av och väljer Spara och sedan Fortsätt.

När funktionsappen har startats om kan du inte längre fjärransluta till dina fjärrprocesser. Du kan använda samma flik i Azure Portal för att aktivera fjärrfelsökning utanför Visual Studio.

Övervakningsfunktioner

Det rekommenderade sättet att övervaka körningen av dina funktioner är genom att integrera din funktionsapp med Azure Application Insights. När du skapar en funktionsapp i Azure Portal görs den här integreringen åt dig som standard. Men när du skapar din funktionsapp under Visual Studio-publiceringen görs inte integreringen i funktionsappen i Azure. Information om hur du ansluter Application Insights till din funktionsapp finns i Aktivera Application Insights-integrering.

Mer information om övervakning med Application Insights finns i Övervaka Azure Functions.

Testa funktioner

I det här avsnittet beskrivs hur du skapar ett C#-funktionsappprojekt i Visual Studio och kör och testar med xUnit.

Testa Azure Functions med C# i Visual Studio

Installation

Om du vill konfigurera din miljö skapar du en funktion och testar appen. Följande steg hjälper dig att skapa de appar och funktioner som krävs för att stödja testerna:

  1. Skapa en ny Functions-app och ge den namnet Functions
  2. Skapa en HTTP-funktion från mallen och ge den namnet MyHttpTrigger.
  3. Skapa en timerfunktion från mallen och ge den namnet MyTimerTrigger.
  4. Skapa en xUnit Test-app i lösningen och ge den namnet Functions.Tests. Ta bort standardtestfilerna.
  5. Använd NuGet för att lägga till en referens från testappen till Microsoft.AspNetCore.Mvc
  6. Referera till Functions-appen från Functions.Tests-appen.

Skapa testklasser

Nu när projekten har skapats kan du skapa de klasser som används för att köra de automatiserade testerna.

Varje funktion tar en instans av ILogger för att hantera meddelandeloggning. Vissa tester loggar antingen inte meddelanden eller bryr sig inte om hur loggning implementeras. Andra tester måste utvärdera meddelanden som loggats för att avgöra om ett test skickas.

Du skapar en ny klass med namnet ListLogger, som innehåller en intern lista över meddelanden som ska utvärderas under testningen. För att implementera det gränssnitt som krävs ILogger behöver klassen ett omfång. I följande klass hånas ett omfång för testfallen som ska skickas ListLogger till klassen.

Skapa en ny klass i Functions.Tests-projektetmed namnet NullScope.cs och ange följande kod:

using System;

namespace Functions.Tests
{
    public class NullScope : IDisposable
    {
        public static NullScope Instance { get; } = new NullScope();

        private NullScope() { }

        public void Dispose() { }
    }
}

Skapa sedan en ny klass i Functions.Tests-projektetlistlogger.cs och ange följande kod:

using Microsoft.Extensions.Logging;
using System;
using System.Collections.Generic;
using System.Text;

namespace Functions.Tests
{
    public class ListLogger : ILogger
    {
        public IList<string> Logs;

        public IDisposable BeginScope<TState>(TState state) => NullScope.Instance;

        public bool IsEnabled(LogLevel logLevel) => false;

        public ListLogger()
        {
            this.Logs = new List<string>();
        }

        public void Log<TState>(LogLevel logLevel,
                                EventId eventId,
                                TState state,
                                Exception exception,
                                Func<TState, Exception, string> formatter)
        {
            string message = formatter(state, exception);
            this.Logs.Add(message);
        }
    }
}

Klassen ListLogger implementerar följande medlemmar enligt gränssnittets kontrakt ILogger :

  • BeginScope: Omfång lägger till kontext i loggningen. I det här fallet pekar testet bara på den statiska instansen NullScope i klassen så att testet kan fungera.

  • IsEnabled: Ett standardvärde false för anges.

  • Logg: Den här metoden använder den angivna formatter funktionen för att formatera meddelandet och lägger sedan till den resulterande texten i Logs samlingen.

Samlingen Logs är en instans av List<string> och initieras i konstruktorn.

Skapa sedan en ny fil i Functions.Tests-projektetmed namnet LoggerTypes.cs och ange följande kod:

namespace Functions.Tests
{
    public enum LoggerTypes
    {
        Null,
        List
    }
}

Den här uppräkningen anger vilken typ av loggare som används av testerna.

Skapa nu en ny klass i Functions.Tests-projektetmed namnet TestFactory.cs och ange följande kod:

using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Http.Internal;
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Logging.Abstractions;
using Microsoft.Extensions.Primitives;
using System.Collections.Generic;

namespace Functions.Tests
{
    public class TestFactory
    {
        public static IEnumerable<object[]> Data()
        {
            return new List<object[]>
            {
                new object[] { "name", "Bill" },
                new object[] { "name", "Paul" },
                new object[] { "name", "Steve" }

            };
        }

        private static Dictionary<string, StringValues> CreateDictionary(string key, string value)
        {
            var qs = new Dictionary<string, StringValues>
            {
                { key, value }
            };
            return qs;
        }

        public static HttpRequest CreateHttpRequest(string queryStringKey, string queryStringValue)
        {
            var context = new DefaultHttpContext();
            var request = context.Request;
            request.Query = new QueryCollection(CreateDictionary(queryStringKey, queryStringValue));
            return request;
        }

        public static ILogger CreateLogger(LoggerTypes type = LoggerTypes.Null)
        {
            ILogger logger;

            if (type == LoggerTypes.List)
            {
                logger = new ListLogger();
            }
            else
            {
                logger = NullLoggerFactory.Instance.CreateLogger("Null Logger");
            }

            return logger;
        }
    }
}

Klassen TestFactory implementerar följande medlemmar:

  • Data: Den här egenskapen returnerar en IEnumerable-samling med exempeldata. Nyckelvärdeparen representerar värden som skickas till en frågesträng.

  • CreateDictionary: Den här metoden accepterar ett nyckel/värde-par som argument och returnerar en ny Dictionary som används för att skapa QueryCollection för att representera frågesträngsvärden.

  • CreateHttpRequest: Den här metoden skapar en HTTP-begäran som initierats med de angivna frågesträngsparametrarna.

  • CreateLogger: Baserat på loggningstypen returnerar den här metoden en loggerklass som används för testning. Håller ListLogger reda på loggade meddelanden som är tillgängliga för utvärdering i tester.

Skapa slutligen en ny klass i Functions.Tests-projektetmed namnet FunctionsTests.cs och ange följande kod:

using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Logging;
using Xunit;

namespace Functions.Tests
{
    public class FunctionsTests
    {
        private readonly ILogger logger = TestFactory.CreateLogger();

        [Fact]
        public async void Http_trigger_should_return_known_string()
        {
            var request = TestFactory.CreateHttpRequest("name", "Bill");
            var response = (OkObjectResult)await MyHttpTrigger.Run(request, logger);
            Assert.Equal("Hello, Bill. This HTTP triggered function executed successfully.", response.Value);
        }

        [Theory]
        [MemberData(nameof(TestFactory.Data), MemberType = typeof(TestFactory))]
        public async void Http_trigger_should_return_known_string_from_member_data(string queryStringKey, string queryStringValue)
        {
            var request = TestFactory.CreateHttpRequest(queryStringKey, queryStringValue);
            var response = (OkObjectResult)await MyHttpTrigger.Run(request, logger);
            Assert.Equal($"Hello, {queryStringValue}. This HTTP triggered function executed successfully.", response.Value);
        }

        [Fact]
        public void Timer_should_log_message()
        {
            var logger = (ListLogger)TestFactory.CreateLogger(LoggerTypes.List);
            new MyTimerTrigger().Run(null, logger);
            var msg = logger.Logs[0];
            Assert.Contains("C# Timer trigger function executed at", msg);
        }
    }
}

De medlemmar som implementeras i den här klassen är:

  • Http_trigger_should_return_known_string: Det här testet skapar en begäran med frågesträngsvärdena name=Bill för till en HTTP-funktion och kontrollerar att det förväntade svaret returneras.

  • Http_trigger_should_return_string_from_member_data: Det här testet använder xUnit-attribut för att tillhandahålla exempeldata till HTTP-funktionen.

  • Timer_should_log_message: Det här testet skapar en instans av ListLogger och skickar den till en timerfunktion. När funktionen har körts kontrolleras loggen för att kontrollera att det förväntade meddelandet finns.

Om du vill komma åt programinställningarna i dina tester kan du mata in en IConfiguration instans med simulerade miljövariabelvärden i din funktion.

Köra tester

Om du vill köra testerna går du till Testutforskaren och väljer Kör alla tester i vyn.

Testa Azure Functions med C# i Visual Studio

Felsöka tester

Om du vill felsöka testerna anger du en brytpunkt för ett test, navigerar till Testutforskaren och väljer Kör > felsökning senaste körning.

Azure Functions verktyg med Visual Studio 2017

Azure Functions Tools är tillgängligt i Azure Development-arbetsbelastningen från och med Visual Studio 2017. I Visual Studio 2017 installerar Azure Development-arbetsbelastningen Azure Functions Tools som ett separat tillägg. I Visual Studio 2019 och senare uppdateras tillägget Azure Functions verktyg som en del av Visual Studio.

När du uppdaterar visual studio 2017-installationen kontrollerar du att du använder den senaste versionen av Azure Functions Tools. Följande avsnitt visar hur du kontrollerar och (om det behövs) uppdaterar Azure Functions Tools-tillägget i Visual Studio 2017.

Kontrollera verktygsversionen i Visual Studio 2017

  1. På verktygsmenyn väljer du Tillägg och Uppdateringar. Expandera Installerade>verktyg och välj sedan Azure Functions- och webbjobbsverktyg.

    Verifiera versionen av Functions-verktygen

  2. Observera den installerade versionen och jämför den här versionen med den senaste versionen som anges i viktig information.

  3. Om din version är äldre uppdaterar du dina verktyg i Visual Studio enligt följande avsnitt.

Uppdatera dina verktyg i Visual Studio

  1. I dialogrutan Tillägg och Uppdateringar expanderar du Uppdateringar>Visual Studio Marketplace, väljer Azure Functions och Verktyg för webbjobb och väljer Uppdatera.

    Uppdatera functions-verktygsversionen

  2. När verktygsuppdateringen har laddats ned väljer du Stäng och stänger sedan Visual Studio för att utlösa verktygsuppdateringen med VSIX Installer.

  3. I VSIX Installer väljer du Ändra för att uppdatera verktygen.

  4. När uppdateringen är klar väljer du Stäng och startar sedan om Visual Studio.

Nästa steg

Mer information om Azure Functions Core Tools finns i Arbeta med Azure Functions Core Tools.

Mer information om hur du utvecklar funktioner som .NET-klassbibliotek finns i Azure Functions C#-utvecklarreferens. Den här artikeln länkar också till exempel på hur du använder attribut för att deklarera olika typer av bindningar som stöds av Azure Functions.