Sviluppare Funzioni di Azure con Visual Studio

Visual Studio consente di sviluppare, testare e distribuire funzioni della libreria di classi C# in Azure. Se questa esperienza è la prima con Funzioni di Azure, vedere Introduzione a Funzioni di Azure.

Visual Studio offre i vantaggi seguenti quando si sviluppano le funzioni:

• Modificare, compilare ed eseguire funzioni nel computer di sviluppo locale.
• Pubblicare il progetto Funzioni di Azure direttamente in Azure e creare risorse di Azure in base alle esigenze.
• Usare gli attributi C# per dichiarare le associazioni di funzione direttamente nel codice C#.
• Sviluppo e distribuzione di funzioni C# precompilate. Le funzioni precompilate offrono migliori prestazioni nell'avvio a freddo rispetto alle funzioni basate su script C#.
• Possibilità di scrivere il codice delle funzioni in C# sfruttando al contempo tutti i vantaggi dello sviluppo in Visual Studio.

Questo articolo fornisce informazioni dettagliate su come usare Visual Studio per sviluppare funzioni della libreria di classi C# e pubblicarle in Azure. Prima di leggere questo articolo, è consigliabile completare l'avvio rapido di Funzioni per Visual Studio.

Se non diversamente specificato, le procedure e gli esempi mostrati sono per Visual Studio 2022. Per altre informazioni sulle versioni di Visual Studio 2022, vedere le note sulla versione o le note sulla versione di anteprima.

Prerequisiti

• Funzioni di Azure Tools. Per aggiungere Gli strumenti per le funzioni di Azure, includere il carico di lavoro Sviluppo di Azure nell'installazione di Visual Studio. Se si usa Visual Studio 2017, potrebbe essere necessario seguire alcuni passaggi di installazione aggiuntivi.

• Altre risorse necessarie, ad esempio un account Archiviazione di Azure, vengono create nella sottoscrizione durante il processo di pubblicazione.

• Se non si ha una sottoscrizione di Azure, creare un account Azure gratuito prima di iniziare.

Creare un progetto di Funzioni di Azure

Il modello di progetto Funzioni di Azure in Visual Studio crea un progetto di libreria di classi C# che è possibile pubblicare in un'app per le funzioni in Azure. È possibile usare un'app per le funzioni per raggruppare le funzioni in un'unità logica e semplificare la gestione, la distribuzione, il ridimensionamento e la condivisione delle risorse.

1. Nel menu di Visual Studio selezionare File>Nuovo>Progetto.

2. In Crea un nuovo progetto immettere funzioni nella casella di ricerca, scegliere il modello Funzioni di Azure e quindi selezionare Avanti.

3. In Configura il nuovo progetto immettere un nome per il progetto e quindi selezionare Crea. Il nome dell'app per le funzioni deve essere valido come spazio dei nomi C#, quindi non usare caratteri di sottolineatura, trattini o altri caratteri non alfanumerici.

4. Per le impostazioni di Crea una nuova applicazione Funzioni di Azure usare i valori della tabella seguente:

   • Modello di lavoro isolato
   • Modello in-process

   Impostazione	valore	Descrizione
   Versione di .NET	Isolato .NET 6	Questo valore crea un progetto di funzione che viene eseguito in un processo di lavoro isolato. Per altre informazioni, vedere Panoramica delle versioni del runtime per Funzioni di Azure.
   Modello di funzione	Trigger HTTP	Con questo valore viene creata una funzione attivata da una richiesta HTTP.
   Account di archiviazione (AzureWebJobsStorage)	Emulatore di archiviazione	Poiché un'app per le funzioni in Azure richiede un account di archiviazione, ne viene assegnata o creata una quando si pubblica il progetto in Azure. Un trigger HTTP non usa una stringa di connessione dell'account di archiviazione di Azure. Tutti gli altri tipi di trigger richiedono una stringa di connessione dell'account di archiviazione di Azure valida.
   Livello di autorizzazione	Anonimo	Viene creata una funzione che può essere attivata da qualsiasi client senza dover fornire una chiave. Questa impostazione di autorizzazione consente di testare più facilmente la nuova funzione. Per altre informazioni sulle chiavi e l'autorizzazione, vedere Chiavi di autorizzazione in Associazioni di webhook e HTTP.

   

   Assicurarsi di impostare Livello di autorizzazione su Anonimo. Se si sceglie il livello predefinito Funzione, è necessario fornire la chiave di funzione nelle richieste di accesso all'endpoint della funzione.

5. Selezionare Crea per creare il progetto di funzione e la funzione attivata da HTTP.

Dopo aver creato un progetto Funzioni di Azure, il modello di progetto crea un progetto C#, installa il Microsoft.NET.Sdk.Functions pacchetto NuGet e imposta il framework di destinazione. Il nuovo progetto contiene i file seguenti:

• host.json: consente di configurare l'host di Funzioni. Queste impostazioni si applicano sia durante l'esecuzione in locale che nell'esecuzione in Azure. Per altre informazioni, vedere il riferimento su host.json.

• local.settings.json: mantiene le impostazioni usate quando si esegue Funzioni localmente. Queste impostazioni non vengono usate durante l'esecuzione in Azure. Per altre informazioni, vedere File di impostazioni locali.

  Importante

  Poiché il file local.settings.json può contenere segreti, è necessario escluderlo dal controllo del codice sorgente del progetto. Assicurarsi che l'impostazione Copia nella directory di output per questo file sia impostata su Copia se più recente.

Per altre informazioni, vedere Progetto di libreria di classi per Funzioni.

Usare le impostazioni dell'app in locale

Quando si esegue in un'app per le funzioni in Azure, le impostazioni richieste dalle funzioni vengono archiviate in modo sicuro nelle impostazioni dell'app. Durante lo sviluppo locale, queste impostazioni vengono invece aggiunte alla Values raccolta nel file local.settings.json. Il file local.settings.json archivia anche le impostazioni usate dagli strumenti di sviluppo locali.

Gli elementi nella Values raccolta nel file local.settings.json del progetto sono destinati a eseguire il mirroring degli elementi nelle impostazioni dell'applicazione dell'app per le funzioni in Azure.

Visual Studio non carica automaticamente le impostazioni in local.settings.json quando si pubblica il progetto. Per assicurarsi che queste impostazioni esistano anche nell'app per le funzioni in Azure, caricarle dopo la pubblicazione del progetto. Per altre informazioni, vedere Impostazioni dell'app per le funzioni. I valori di una ConnectionStrings raccolta non vengono mai pubblicati.

Il codice può anche leggere i valori delle impostazioni dell'app per le funzioni come variabili di ambiente. Per altre informazioni, vedere Variabili di ambiente.

Configurare il progetto per lo sviluppo locale

Il runtime di Funzioni usa un account di archiviazione di Azure internamente. Per tutti i tipi di trigger diversi da HTTP e webhook, impostare la Values.AzureWebJobsStorage chiave su un account Archiviazione di Azure valido stringa di connessione. L'app per le funzioni può anche usare l'emulatore Azurite per l'impostazione AzureWebJobsStorage di connessione richiesta dal progetto. Per usare l'emulatore, impostare il valore di AzureWebJobsStorage su UseDevelopmentStorage=true. Modificare questa impostazione in un account di archiviazione effettivo stringa di connessione prima della distribuzione. Per altre informazioni, vedere Emulatore di archiviazione locale.

Per impostare la stringa di connessione dell'account di archiviazione:

1. Nel portale di Azure passare all'account di archiviazione.

2. Nella scheda Chiavi di accesso, sotto Sicurezza e rete, copiare la stringa di Connessione ion di key1.

3. Nel progetto aprire il file local.settings.json e impostare il valore della AzureWebJobsStorage chiave sul stringa di connessione copiato.

4. Ripetere il passaggio precedente per aggiungere chiavi univoche alla Values matrice per tutte le altre connessioni richieste dalle funzioni.

Aggiungere una funzione al progetto

Nelle funzioni della libreria di classi C# le associazioni usate dalla funzione vengono definite applicando attributi nel codice. Quando si creano i trigger di funzione dai modelli forniti, vengono applicati automaticamente gli attributi del trigger.

1. In Esplora soluzioni fare clic con il pulsante destro del mouse sul nodo del progetto e scegliere Aggiungi>nuovo elemento.

2. Selezionare Funzione di Azure, immettere un nome per la classe e quindi selezionare Aggiungi.

3. Scegliere il trigger, impostare le proprietà di associazione e quindi selezionare Aggiungi. L'esempio seguente illustra le impostazioni per la creazione di una funzione trigger di archiviazione code.

   

   Verrà quindi richiesto di scegliere tra l'emulatore di archiviazione Azurite o fare riferimento a un account di archiviazione di Azure di cui è stato effettuato il provisioning.

   Questo esempio di trigger usa un stringa di connessione con una chiave denominata QueueStorage. Questa chiave, archiviata nel file local.settings.json, fa riferimento all'emulatore Azurite o a un account di archiviazione di Azure.

4. Si esamini la classe appena aggiunta. Viene visualizzato un metodo statico Run() attribuito con l'attributo FunctionName . Questo attributo indica che il metodo è il punto di ingresso per la funzione.

   Ad esempio, la classe C# seguente rappresenta una funzione trigger di archiviazione code di base:

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

Un attributo specifico dell'associazione viene applicato a ogni parametro di associazione fornito al metodo del punto di ingresso. L'attributo accetta le informazioni di associazione come parametri. Nell'esempio precedente il primo parametro ha un QueueTrigger attributo applicato, che indica una funzione trigger di archiviazione code. Il nome della coda e stringa di connessione nome dell'impostazione vengono passati come parametri all'attributo QueueTrigger . Per altre informazioni, vedere Associazioni di archiviazione code in Funzioni di Azure.

Usare la procedura precedente per aggiungere altre funzioni al progetto dell'app per le funzioni. Ogni funzione nel progetto può avere un trigger diverso, ma una funzione deve avere esattamente un trigger. Per altre informazioni, vedere Concetti relativi a trigger e associazioni in Funzioni di Azure.

Aggiungere associazioni

Come nel caso dei trigger, le associazioni di input e output vengono aggiunte alla funzione come attributi di associazione. Per aggiungere associazioni a una funzione, procedere come segue:

1. Assicurarsi di aver configurato il progetto per lo sviluppo locale.

2. Aggiungere il pacchetto di estensione NuGet appropriato per l'associazione specifica individuando i requisiti del pacchetto NuGet specifici dell'associazione nell'articolo di riferimento per l'associazione. I requisiti del pacchetto per il trigger di Hub eventi sono ad esempio disponibili nell'articolo di riferimento sulle associazioni di Hub eventi.

3. Usare il comando seguente nella console di Gestione pacchetti per installare un pacchetto specifico:

   • Modello di lavoro isolato
   • Modello in-process

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

   In questo esempio sostituire <BINDING_TYPE> con il nome specifico dell'estensione di associazione e <TARGET_VERSION> con una versione specifica del pacchetto, ad esempio 3.0.0-beta5. Le versioni valide sono elencate nelle singole pagine del pacchetto in NuGet.org. Le versioni principali che corrispondono al runtime di Funzioni 1.x o 2.x sono specificate nell'articolo di riferimento per l'associazione.

4. Se sono presenti impostazioni dell'app necessarie per l'associazione, aggiungerle alla Values raccolta nel file di impostazione locale.

   La funzione usa questi valori quando viene eseguito in locale. Quando la funzione viene eseguita nell'app per le funzioni in Azure, usa le impostazioni dell'app per le funzioni.

5. Aggiungere l'attributo di associazione appropriato per la firma del metodo. Nell'esempio seguente un messaggio della coda attiva la funzione e l'associazione di output crea un nuovo messaggio della coda con lo stesso testo in una coda diversa.

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

   La connessione all'archiviazione code viene ottenuta dall'impostazione AzureWebJobsStorage. Per altre informazioni, vedere l'articolo di riferimento per l'associazione specifica.

Per un elenco completo delle associazioni supportate da Funzioni, vedere Associazioni supportate.

Eseguire funzioni localmente

Azure Functions Core Tools consente di eseguire il progetto Funzioni di Azure nel computer di sviluppo locale. Quando si preme F5 per eseguire il debug di un progetto di Funzioni, l'host di Funzioni locale (func.exe) inizia ad ascoltare su una porta locale (in genere 7071). Tutti gli endpoint di funzione chiamabili vengono scritti nell'output ed è possibile usare questi endpoint per testare le funzioni. Per altre informazioni, vedere Usare Funzioni di Azure Core Tools. Viene richiesto di installare questi strumenti la prima volta che si avvia una funzione da Visual Studio.

Per avviare la funzione in Visual Studio in modalità di debug:

1. Premere F5. Se viene visualizzata, accettare la richiesta di Visual Studio di scaricare e installare gli strumenti dell'interfaccia della riga di comando Azure Functions Core Tools. Potrebbe essere necessario anche abilitare un'eccezione del firewall per consentire agli strumenti di gestire le richieste HTTP.

2. Con il progetto in esecuzione, testare il codice come si testerebbe una funzione distribuita.

   Quando si esegue Visual Studio in modalità di debug, i punti di interruzione vengono raggiunti come previsto.

Per uno scenario di test più dettagliato con Visual Studio, vedere Test delle funzioni.

Pubblicare in Azure

Quando si pubblica da Visual Studio, usa uno dei due metodi di distribuzione:

• Distribuzione Web: pacchetti e distribuisce app di Windows in qualsiasi server IIS.
• Distribuzione zip con run-from-package abilitato: consigliato per le distribuzioni di Funzioni di Azure.

Usare la procedura seguente per pubblicare il progetto in un'app per le funzioni in Azure.

1. In Esplora soluzioni fare clic con il pulsante destro del mouse sul progetto e scegliere Pubblica. In Destinazione selezionare Azure e quindi Avanti.

   

2. Selezionare App per le funzioni di Azure (Windows) per La destinazione specifica, che crea un'app per le funzioni eseguita in Windows e quindi selezionare Avanti.

   

3. Nell'istanza della funzione scegliere Crea una nuova funzione di Azure...

   

4. Creare una nuova istanza usando i valori specificati nella tabella seguente:

   Impostazione	valore	Descrizione
   Nome	Nome globalmente univoco	Nome che identifica in modo univoco la nuova app per le funzioni. Accettare questo nome o immetterne uno nuovo. I caratteri validi sono a-z, 0-9 e -.
   Abbonamento	Sottoscrizione in uso	Sottoscrizione di Azure da usare. Accettare questa sottoscrizione o selezionarne una nuova dall'elenco a discesa.
   Gruppo di risorse	Nome del gruppo di risorse	Gruppo di risorse in cui si vuole creare l'app per le funzioni. Selezionare un gruppo di risorse esistente nell'elenco a discesa o selezionare Nuovo per creare un nuovo gruppo di risorse.
   Tipo di piano	Consumo	Quando si pubblica il progetto in un'app per le funzioni eseguita in un piano a consumo, vengono addebitati solo i costi relativi alle esecuzioni dell'app per le funzioni. Altri piani di hosting comportano costi più elevati.
   Location	La località del piano di servizio app	Scegliere una località in un'area nelle vicinanze o vicino ad altri servizi a cui accedono le funzioni.
   Archiviazione di Azure	Account di archiviazione per utilizzo generico	L'account di archiviazione di Azure è necessario per il runtime di Funzioni. Selezionare Nuovo per configurare un account di archiviazione per utilizzo generico. È anche possibile scegliere un account esistente che soddisfi i requisiti dell'account di archiviazione.

   

5. Selezionare Crea per creare un'app per le funzioni e le relative risorse in Azure. Lo stato della creazione della risorsa viene visualizzato in basso a sinistra della finestra.

6. Nell'istanza di Funzioni verificare che sia selezionata l'opzione Esegui dal file del pacchetto. L'app per le funzioni viene distribuita usando la distribuzione ZIP con la modalità esecuzione da pacchetto abilitata. Zip Deploy è il metodo di distribuzione consigliato per il progetto di funzioni con prestazioni migliori.

   

7. Selezionare Fine e quindi, nella pagina Pubblica, selezionare Pubblica per distribuire il pacchetto contenente i file del progetto nella nuova app per le funzioni in Azure.

   Al termine della distribuzione, l'URL radice dell'app per le funzioni in Azure viene visualizzato nella scheda Pubblica .

8. Nella sezione Hosting della scheda Pubblica scegliere Apri in portale di Azure. Verrà aperta la nuova risorsa di Azure dell'app per le funzioni nella portale di Azure.

   

Impostazioni dell'app per le funzioni

Visual Studio non carica automaticamente queste impostazioni quando si pubblica il progetto. Tutte le impostazioni aggiunte in local.settings.json è necessario aggiungere anche all'app per le funzioni in Azure.

Il modo più semplice per caricare le impostazioni necessarie nell'app per le funzioni in Azure consiste nell'espandere i tre puntini accanto alla sezione Hosting e selezionare il collegamento Gestisci impostazioni del servizio app Azure visualizzato dopo aver pubblicato correttamente il progetto.

Selezionando questo collegamento viene visualizzata la finestra di dialogo Impostazioni applicazione per l'app per le funzioni, in cui è possibile aggiungere nuove impostazioni dell'applicazione o modificarne quelle esistenti.

Local visualizza un valore di impostazione nel file local.settings.json e Remote visualizza un valore di impostazione corrente nell'app per le funzioni in Azure. Scegliere Aggiungi impostazione per creare una nuova impostazione dell'app. Usare il collegamento Inserisci valore da locale per copiare un valore di impostazione nel campo Remoto. Le modifiche in sospeso vengono scritte nel file delle impostazioni locali e nell'app per le funzioni quando si seleziona OK.

È anche possibile gestire le impostazioni dell'applicazione in uno degli altri modi seguenti:

• Usare il portale di Azure.
• Usare l'opzione --publish-local-settings di pubblicazione in Funzioni di Azure Core Tools.
• Usare l'interfaccia della riga di comando di Azure.

Debug remoto

Per eseguire il debug remoto dell'app per le funzioni, è necessario pubblicare una configurazione di debug del progetto. È anche necessario abilitare il debug remoto nell'app per le funzioni in Azure.

Questa sezione presuppone che l'app per le funzioni sia già stata pubblicata usando una configurazione di versione.

Considerazioni sul debug remoto

• Il debug remoto non è consigliato in un servizio di produzione.
• Se è abilitato il debug Just My Code, disabilitarlo.
• Evitare interruzioni prolungate in corrispondenza dei punti di interruzione durante il debug remoto. In Azure i processi interrotti per più di alcuni minuti vengono considerati come processi che non rispondono e vengono arrestati.
• Durante il debug, il server invia i dati a Visual Studio, con possibili implicazioni sui costi della larghezza di banda. Per informazioni sui costi della larghezza di banda, vedere Prezzi di Azure.
• Il debug remoto viene disabilitato automaticamente nell'app per le funzioni dopo 48 ore. Dopo 48 ore, sarà necessario riabilitare il debug remoto.

Collegare il debugger

Il modo in cui si collega il debugger dipende dalla modalità di esecuzione. Quando si esegue il debug di un'app del processo di lavoro isolato, è attualmente necessario collegare il debugger remoto a un processo .NET separato e sono necessari diversi altri passaggi di configurazione.

Al termine, è consigliabile disabilitare il debug remoto.

Disabilitare il debug remoto

Dopo aver completato il debug remoto del codice, è necessario disabilitare il debug remoto nella portale di Azure. Il debug remoto viene disabilitato automaticamente dopo 48 ore, nel caso in cui si dimentica.

1. Nella scheda Pubblica nel progetto selezionare i puntini di sospensione (...) nella sezione Hosting e scegliere Apri in portale di Azure. Questa azione apre l'app per le funzioni nel portale di Azure in cui viene distribuito il progetto.

2. Nell'app per le funzioni selezionare Configurazione in impostazioni, scegliere Generale Impostazioni, impostare Debug remoto su Disattivato e selezionare Salva e quindi Continua.

Dopo il riavvio dell'app per le funzioni, non è più possibile connettersi in remoto ai processi remoti. È possibile usare questa stessa scheda nel portale di Azure per abilitare il debug remoto all'esterno di Visual Studio.

Monitoraggio delle funzioni

È consigliabile monitorare l'esecuzione delle funzioni tramite l'integrazione dell'app per le funzioni con Azure Application Insights. Quando si crea un'app per le funzioni nel portale di Azure, questa integrazione avviene automaticamente per impostazione predefinita. Tuttavia, quando si crea l'app per le funzioni durante la pubblicazione di Visual Studio, l'integrazione nell'app per le funzioni in Azure non viene eseguita. Per informazioni su come connettere Application Insights all'app per le funzioni, vedere Abilitare l'integrazione di Application Insights.

Per altre informazioni sul monitoraggio con Application Insights, vedere Monitorare Funzioni di Azure.

Test delle funzioni

Questa sezione descrive come creare un progetto di app per le funzioni C# in Visual Studio e come eseguire e testare con xUnit.

Configurazione

Per configurare l'ambiente, creare una funzione e testare l'app. I passaggi seguenti consentono di creare le app e le funzioni necessarie per supportare i test:

1. Creare una nuova app funzioni e denominarla Funzioni
2. Creare una funzione HTTP dal modello e denominarla MyHttpTrigger.
3. Creare una funzione timer dal modello e denominarla MyTimerTrigger.
4. Creare un'app di test xUnit nella soluzione e denominarla Functions.Tests. Rimuovere i file di test predefiniti.
5. Usare NuGet per aggiungere un riferimento dall'app di test a Microsoft.AspNetCore.Mvc
6. Fare riferimento all'app Funzioni dall'appFunctions.Tests.

Crea classi di test

Dopo aver creato i progetti, è possibile creare le classi usate per eseguire i test automatizzati.

Ogni funzione accetta un'istanza di ILogger per gestire la registrazione dei messaggi. Alcuni test non registrano messaggi oppure non hanno alcun problema per la modalità di implementazione della registrazione. Altri test devono valutare i messaggi registrati per determinare se si sta passando un test.

Si creerà una nuova classe denominata ListLogger, che contiene un elenco interno di messaggi da valutare durante i test. Per implementare l'interfaccia richiesta ILogger , la classe richiede un ambito. La classe seguente simula un ambito per i test case da passare alla ListLogger classe .

Creare una nuova classe nel progetto Functions.Tests denominato NullScope.cs e immettere il codice seguente:

using System;

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

        private NullScope() { }

        public void Dispose() { }
    }
}

Creare quindi una nuova classe nel progetto Functions.Tests denominato ListLogger.cs e immettere il codice seguente:

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

La classe ListLogger implementa i membri seguenti come contrattato dall'interfaccia ILogger:

• BeginScope: gli ambiti aggiungono contesto alla registrazione. In questo caso, il test punta solo all'istanza statica della NullScope classe per consentire il funzionamento del test.

• IsEnabled: viene fornito un valore predefinito di false .

• Log: questo metodo usa la funzione fornita formatter per formattare il messaggio e quindi aggiunge il testo risultante alla Logs raccolta.

La raccolta Logs è un'istanza di List<string> e viene inizializzata nel costruttore.

Creare quindi un nuovo file nel progetto Functions.Tests denominato LoggerTypes.cs e immettere il codice seguente:

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

Questa enumerazione specifica il tipo di logger usato dai test.

Creare ora una nuova classe nel progetto Functions.Tests denominato TestFactory.cs e immettere il codice seguente:

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

La classe TestFactory implementa i seguenti membri:

• Dati: questa proprietà restituisce una raccolta IEnumerable di dati di esempio. Le coppie chiave-valore rappresentano valori che vengono passati in una stringa di query.

• CreateDictionary: questo metodo accetta una coppia chiave/valore come argomenti e restituisce un nuovo Dictionary oggetto usato per creare QueryCollection per rappresentare i valori della stringa di query.

• CreateHttpRequest: questo metodo crea una richiesta HTTP inizializzata con i parametri della stringa di query specificati.

• CreateLogger: in base al tipo di logger, questo metodo restituisce una classe logger usata per il test. ListLogger tiene traccia dei messaggi registrati disponibili per la valutazione nei test.

Creare infine una nuova classe nel progetto Functions.Tests denominato FunctionsTests.cs e immettere il codice seguente:

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

I membri implementati in questa classe sono:

• Http_trigger_should_return_known_string: questo test crea una richiesta con i valori della stringa di query di name=Bill a una funzione HTTP e verifica che venga restituita la risposta prevista.

• Http_trigger_should_return_string_from_member_data: questo test usa attributi xUnit per fornire dati di esempio alla funzione HTTP.

• Timer_should_log_message: questo test crea un'istanza di ListLogger e la passa a una funzione timer. Dopo l'esecuzione della funzione, il log viene controllato per assicurarsi che il messaggio previsto sia presente.

Se si desidera accedere alle impostazioni dell'applicazione nei test, è possibile inserire un'istanza IConfiguration con valori di variabile di ambiente fittizi nella funzione.

Esecuzione dei test

Per eseguire i test, passare a Esplora test e selezionare Esegui tutti i test in Visualizzazione.

Esecuzione del debug dei test

Per eseguire il debug dei test, impostare un punto di interruzione in un test, passare a Esplora test e selezionare Esegui ultima > esecuzione debug.

strumenti di Funzioni di Azure con Visual Studio 2017

Funzioni di Azure Tools è disponibile nel carico di lavoro Sviluppo di Azure a partire da Visual Studio 2017. In Visual Studio 2017 il carico di lavoro Sviluppo di Azure installa Funzioni di Azure Tools come estensione separata. In Visual Studio 2019 e versioni successive l'estensione degli strumenti di Funzioni di Azure viene aggiornata come parte di Visual Studio.

Quando si aggiorna l'installazione di Visual Studio 2017, assicurarsi di usare la versione più recente di Funzioni di Azure Tools. Le sezioni seguenti illustrano come controllare e ,se necessario, aggiornare l'estensione Funzioni di Azure Tools in Visual Studio 2017.

Controllare la versione degli strumenti in Visual Studio 2017

1. Scegliere Estensioni e aggiornamenti dal menu Strumenti. Espandere Strumenti installati>e quindi scegliere Funzioni di Azure e Strumenti processi Web.

   

2. Prendere nota della versione installata e confrontare questa versione con la versione più recente elencata nelle note sulla versione.

3. Se la versione è precedente, aggiornare gli strumenti in Visual Studio come illustrato nella sezione seguente.

Aggiornare gli strumenti in Visual Studio

1. Nella finestra di dialogo Estensioni e aggiornamenti espandere Aggiornamenti>Visual Studio Marketplace, scegliere Funzioni di Azure e strumenti per processi Web e selezionare Aggiorna.

   

2. Dopo aver scaricato l'aggiornamento degli strumenti, selezionare Chiudi e quindi chiudere Visual Studio per attivare l'aggiornamento degli strumenti con il programma di installazione VSIX.

3. In VsIX Installer (Programma di installazione VSIX) scegliere Modifica per aggiornare gli strumenti.

4. Al termine dell'aggiornamento, scegliere Chiudi e quindi riavviare Visual Studio.

Passaggi successivi

Per altre informazioni su Funzioni di Azure Core Tools, vedere Usare Funzioni di Azure Core Tools.

Per altre informazioni sullo sviluppo di funzioni come librerie di classi .NET, vedere Funzioni di Azure guida di riferimento per sviluppatori C#. Questo articolo include anche collegamenti ad esempi su come usare gli attributi per dichiarare i vari tipi di associazioni supportate da Funzioni di Azure.