Compilare, testare e distribuire progetti .NET Core

Azure DevOps Services | Azure DevOps Server | Azure DevOps Server 2022 | Azure DevOps Server 2020

Questo articolo descrive come usare Azure Pipelines per usare i progetti .NET Core. L'articolo illustra le attività seguenti:

• Creare un'app Web .NET Core e caricarla in un repository GitHub.
• Creare un progetto Azure DevOps e una pipeline di Azure Pipelines per compilare il progetto.
• Configurare l'ambiente di compilazione con agenti ospitati da Microsoft o self-hosted.
• Ripristinare le dipendenze, compilare il progetto e testare con l'attività .NET Core (DotNetCoreCLI@2) o uno script.
• Usare l'attività .NET Core (DotNetCoreCLI@2) per aggiungere altri comandi .NET SDK alla pipeline.
• Usare l'attività Pubblica risultati code coverage (Publish code coverage results v2) per pubblicare i risultati del code coverage.
• Creare un pacchetto e distribuire l'output di compilazione alla pipeline, un feed NuGet, un archivio ZIP o altre destinazioni.

Nota

Per usare i progetti .NET Framework, vedere Creare app ASP.NET con .NET Framework.

Prerequisiti

Per completare tutte le procedure descritte in questo articolo, sono necessari i prerequisiti seguenti:

• Un'organizzazione di Azure DevOps. È possibile crearne uno gratuitamente.
• Appartenenza al gruppo Amministratori progetto dell'organizzazione, in modo da poter creare progetti Azure DevOps e concedere l'accesso al progetto alle pipeline. I proprietari dell'organizzazione di Azure DevOps hanno automaticamente questa appartenenza.
• Un progetto Azure DevOps nell'organizzazione. Creare un progetto in Azure DevOps.
• Possibilità di eseguire pipeline su agenti ospitati da Microsoft, richiedendo un livello gratuito di processi paralleli. L'elaborazione di questa richiesta può richiedere diversi giorni lavorativi. Per ulteriori informazioni, vedere Configura e paga per i processi paralleli.
• Ruolo amministratore o creatore per le connessioni al servizio, che è possibile assegnare come amministratore del progetto.
• Un account e un repository GitHub .

Creare un progetto .NET e caricarlo in GitHub

Se si vuole usare un progetto .NET già nel repository GitHub, è possibile ignorare questa sezione.

Se non si ha un progetto .NET da usare, crearne uno nuovo nel computer locale come indicato di seguito:

1. Installare .NET 8.0 SDK o assicurarsi che sia installato.
2. Aprire una finestra del terminale nel computer locale.
3. Crea una directory del progetto ed entra in essa.
4. Creare una nuova app Web .NET 8 eseguendo dotnet new webapp -f net8.0.
5. Compilare ed eseguire l'applicazione in locale usando dotnet run.
6. All'avvio dell'applicazione premere CTRL+C per arrestarla.
7. Caricare o connettere il progetto locale al repository GitHub.

Creare un flusso di lavoro

Se si ha una pipeline che si vuole usare, è possibile ignorare questa sezione. In caso contrario, è possibile usare l'editor della pipeline YAML o l'editor classico per creare una pipeline come indicato di seguito:

YAML

1. Nel progetto Azure DevOps selezionare Pipeline dal menu di spostamento a sinistra.

2. Selezionare Nuova pipeline o Crea pipeline se la pipeline è la prima nel progetto.

3. Nella schermata Dove è il codice selezionare GitHub.

4. Si potrebbe essere reindirizzati a GitHub per l'accesso. In questo caso, immettere le credenziali di GitHub.

5. Nella schermata Selezionare un repository selezionare il repository in cui si trova l'app .NET.

6. È possibile che si venga reindirizzati a GitHub per installare l'app Azure Pipelines. In tal caso, selezionare Approva e installa.

7. Nella scheda Configura selezionare Mostra altro e quindi selezionare il modello di pipeline ASP.NET Core dall'elenco. Questo modello fornisce molti dei passaggi e delle impostazioni descritti in questo articolo.

   È anche possibile selezionare Pipeline di avvio nella scheda Configura per iniziare con una pipeline minima e aggiungere manualmente i passaggi e le impostazioni.

8. Nella scheda Revisione esaminare il codice YAML. È possibile personalizzare il file per i requisiti. Ad esempio, è possibile specificare un pool di agenti diverso o aggiungere un'attività per installare un SDK .NET diverso.

9. Quando si è pronti, selezionare Salva ed esegui.

   

10. Facoltativamente, modificare il messaggio Commit e quindi selezionare Salva ed esegui di nuovo.

11. Nella scheda Riepilogo selezionare il processo nella sezione Processi per controllare la pipeline in azione.

Classico

1. Nel progetto Azure DevOps selezionare Pipeline dal menu di spostamento a sinistra.

2. Selezionare Nuova pipeline o Crea pipeline se la pipeline è la prima nel progetto.

3. Nella schermata Where is your code (Dove è il codice ) selezionare Use the classic editor to create a pipeline without YAML (Usa l'editor classico per creare una pipeline senza YAML).

   Nota

   La possibilità di creare pipeline classiche è disattivata per impostazione predefinita per le nuove organizzazioni e progetti Azure DevOps. Se non viene visualizzata l'opzione per l'uso dell'editor classico, disattivare le opzioni Disabilita creazione di pipeline di compilazione classiche e Disabilita creazione di pipeline di versione classica in Impostazioni organizzazione Impostazioni>pipeline> e/o> progettoImpostazioni>

4. In Selezionare un'origine selezionareGitHub.

5. Specificare un nome di connessione e quindi selezionare Autorizza usando OAuth. È anche possibile selezionare questa opzione per autorizzare l'app GitHub di Azure Pipelines o un token di accesso personale di GitHub.

6. Specificare il nome del repository GitHub, tra cui l'organizzazione o l'utente e il ramo predefinito, in genere principale.

7. Seleziona Continua.

8. Nella schermata Seleziona un modello cercare e selezionare il modello ASP.NET Core e quindi selezionare Applica. Viene visualizzata la pagina della pipeline, in cui è possibile aggiungere attività, specificare pool di agenti e agenti e configurare altre opzioni di compilazione.

   Il modello ASP.NET Core fornisce molti dei passaggi e delle impostazioni descritti in questo articolo. È anche possibile selezionare Processo vuoto per iniziare con una pipeline minima e aggiungere manualmente le attività e le impostazioni.

9. Nella scheda Attività , in Pool di agenti selezionare Azure Pipelines per usare gli agenti ospitati da Microsoft.

10. In Specifica agente selezionare windows-latest per questo esempio.

11. Selezionare Salva e accoda>Salva e accoda nella parte superiore della pagina.

12. Nella schermata Esegui pipeline immettere un commento Salva e quindi selezionare Salva ed esegui.

13. Selezionare il processo nella sezione Processi nella scheda Riepilogo per visualizzare la pipeline in azione.

È possibile aggiungere attività al processo di Agent 1 selezionando + nel processo e selezionando un'attività dall'elenco. Ad esempio, è possibile aggiungere l'attività Usa .NET Core come prima attività per installare .NET SDK.

È ora disponibile una pipeline di lavoro pronta per la personalizzazione.

Configurare l'ambiente di compilazione

È possibile compilare i progetti .NET Core usando .NET Core SDK e il runtime per Windows, Linux o macOS. Per impostazione predefinita, le compilazioni vengono eseguite su agenti ospitati da Microsoft, quindi non è necessario configurare l'infrastruttura.

Gli agenti ospitati da Microsoft in Azure Pipelines includono diverse versioni preinstallate degli SDK .NET Core supportati. Per un elenco completo delle immagini e degli esempi di configurazione disponibili, vedere Agenti ospitati da Microsoft .

Il frammento di pipeline YAML seguente imposta il sistema operativo Ubuntu per il pool di agenti.

pool:
  vmImage: 'ubuntu-latest' 

Gli agenti ospitati da Microsoft non includono alcune versioni precedenti di .NET Core SDK e in genere non includono versioni non definitive. Se sono necessarie queste versioni dell'SDK negli agenti ospitati da Microsoft, è possibile installarle usando l'attività Usa DotNet (UseDotNet@2).

Ad esempio, il codice seguente installa .NET 5.0.x SDK:

steps:
- task: UseDotNet@2
  inputs:
    version: '5.x'

Gli agenti Windows includono già un runtime .NET Core. Per installare un SDK più recente, impostare su performMultiLevelLookuptrue come nel frammento di codice seguente:

steps:
- task: UseDotNet@2
  displayName: 'Install .NET Core SDK'
  inputs:
    version: 8.x
    performMultiLevelLookup: true
    includePreviewVersions: true # Required for preview versions

Agenti gestiti autonomamente

In alternativa, è possibile usare agenti self-hosted per compilare i progetti .NET Core. È possibile configurare agenti Linux, macOS o Windows self-hosted.

Gli agenti self-hosted consentono di:

• Evitare il costo di esecuzione del programma di installazione dello UseDotNet@2 strumento.
• Ridurre il tempo di compilazione se si dispone di un repository di grandi dimensioni.
• Eseguire compilazioni incrementali.
• Usare sdk di anteprima o privati che Microsoft non supporta ufficialmente.
• Usare gli SDK disponibili solo negli ambienti aziendali o locali.

Per ulteriori informazioni, vedere Agenti ospitati localmente.

Ripristinare le dipendenze

I pacchetti NuGet sono un modo per consentire al progetto di dipendere dal codice che non si compila. È possibile scaricare pacchetti NuGet e strumenti specifici del progetto eseguendo il dotnet restore comando, tramite l'attività .NET Core (DotNetCoreCLI@2) o come script nella pipeline. Il dotnet restore comando usa il NuGet.exe incluso in un pacchetto con .NET Core SDK e può ripristinare solo i pacchetti specificati nei file *.csproj del progetto .NET Core.

È possibile usare l'attività .NET Core (DotNetCoreCLI@2) per scaricare e ripristinare pacchetti NuGet da Azure Artifacts, NuGet.org o da un altro repository NuGet esterno o interno autenticato. Se il feed NuGet si trova nello stesso progetto della pipeline, non è necessario eseguire l'autenticazione. Per altre informazioni, vedere Attività .NET Core (DotNetCoreCLI@2).For more information, see .NET Core task (DotNetCoreCLI@2).

Quando si usano agenti ospitati da Microsoft, si ottiene un nuovo computer ogni volta che si esegue una compilazione, che ripristina i pacchetti con ogni esecuzione. Il ripristino può richiedere una quantità significativa di tempo. Per attenuare questo problema, usare Azure Artifacts o un agente self-hosted per sfruttare i vantaggi della cache dei pacchetti.

La pipeline seguente usa l'attività DotNetCoreCLI@2 per ripristinare un feed di Azure Artifact.

trigger:
- main

pool:
  vmImage: 'windows-latest'

steps:
- task: UseDotNet@2
  displayName: 'Install .NET Core SDK'
  inputs:
    version: 8.x
    performMultiLevelLookup: true
    includePreviewVersions: true # Required for preview versions

variables:
  buildConfiguration: 'Release'

steps:
- task: DotNetCoreCLI@2
  inputs:
    command: 'restore'
    feedsToUse: 'select'
    vstsFeed: 'my-vsts-feed' # A series of numbers and letters

- task: DotNetCoreCLI@2
  inputs:
    command: 'build'
    arguments: '--configuration $(buildConfiguration)'
  displayName: 'dotnet build $(buildConfiguration)'

In .NET Core SDK versione 2.0 e successive i pacchetti vengono ripristinati automaticamente quando si eseguono comandi come dotnet build. È comunque necessario usare l'attività .NET Core (DotNetCoreCLI@2) per ripristinare i pacchetti se si usa un feed autenticato.

Gestire le credenziali per un feed autenticato creando una connessione al servizio NuGet nelleconnessioni del servizio>impostazioni> progetto. Per altre informazioni sulle connessioni al servizio NuGet, vedere Pubblicare pacchetti NuGet con Azure Pipelines.

Ripristinare pacchetti da NuGet.org

Per ripristinare i pacchetti da NuGet.org, aggiornare la pipeline come indicato di seguito.

YAML

È possibile aggiungere il comando di ripristino alla pipeline modificando direttamente il codice YAML o usando l'assistente attività.

Aggiungere direttamente l'attività .NET Core (DotNetCoreCLI@2) inserendo il frammento di codice seguente nel file azure-pipelines.yml prima delle attività di compilazione.

steps:
- task: DotNetCoreCLI@2
  displayName: Restore
  inputs:
    command: restore
    projects: '**/*.csproj'
    feedsToUse: select

Per usare l'assistente delle attività:

1. Passare alla posizione nel file YAML in cui si desidera inserire l'attività.
2. Selezionare .NET Core dal catalogo attività.
3. Nella schermata di configurazione selezionare Ripristina dall'elenco a discesa Comando .
4. Nel campo Percorso progetti o soluzioni immettere il percorso dei file *.csproj . È possibile usare il carattere jolly **/*.csproj per tutti i file *.csproj in tutte le sottocartelle.
5. Per Feed da aggiungere, assicurarsi che i feed selezionati qui e Use packages from NuGet.org (Usa pacchetti da NuGet.org ) siano selezionati.
6. Selezionare Aggiungi.
7. Selezionare Convalida e salva e quindi salva per eseguire il commit della modifica.

Classico

È possibile aggiungere un'attività di ripristino usando l'editor classico.

1. Nella scheda Attività della pipeline selezionare Processo agente 1 o altro processo che esegue le attività di compilazione.
2. Selezionare + per aggiungere una nuova attività a tale processo.
3. Nel catalogo attività selezionare .NET Core e quindi selezionare Aggiungi.
4. Nel riquadro sinistro selezionare l'attività dotnet build aggiunta per aprire l'editor attività.
5. Selezionare Ripristina dall'elenco a discesa Comando . Il nome visualizzato cambia in dotnet restore.
6. Nel campo Percorso progetti o soluzioni immettere il percorso dei file *.csproj . È possibile usare il carattere jolly **/*.csproj per tutti i file *.csproj in tutte le sottocartelle.
7. Per Feed da aggiungere, assicurarsi che i feed selezionati qui e Use packages from NuGet.org (Usa pacchetti da NuGet.org ) siano selezionati.
8. Nel riquadro sinistro trascinare l'attività per posizionarla prima dell'attività Di compilazione .
9. Nella parte superiore della pagina selezionare Salva e salva coda>.

Ripristinare i pacchetti da un feed esterno

Per specificare un repository NuGet esterno, inserire l'URL in un fileNuGet.config nel repository. Assicurarsi che nel file diNuGet.config siano specificati feed personalizzati e che le credenziali siano specificate in una connessione al servizio NuGet.

Per ripristinare i pacchetti da un feed esterno, aggiungere l'attività restore come indicato nella sezione precedente, ma modificare le impostazioni di configurazione come indicato di seguito:

YAML

Aggiungere direttamente l'attività .NET Core (DotNetCoreCLI@2) inserendo il frammento di codice seguente nel file azure-pipelines.yml prima delle attività di compilazione. Sostituire <NuGet service connection> con il nome della connessione al servizio.

steps:
- task: DotNetCoreCLI@2
  displayName: Restore
  inputs:
    command: restore
    projects: '**/*.csproj'
    feedsToUse: config
    nugetConfigPath: NuGet.config    # Relative to root of the repository
    externalFeedCredentials: <NuGet service connection>

Per usare l'assistente delle attività:

1. Aggiungere l'attività .NET Core e selezionare Ripristina nella schermata di configurazione come nella procedura precedente.
2. Per Feed da aggiungere, selezionare Feed nel NuGet.config.
3. In Percorso per NuGet.configimmettere il percorso del file NuGet.config relativo alla radice del repository. È possibile selezionare i puntini di sospensione ... accanto al campo per passare a e selezionare la posizione.
4. In Credenziali per feed esterni a questa organizzazione/raccolta selezionare le credenziali da usare per i registri esterni nel file diNuGet.config selezionato. Per i feed nella stessa organizzazione, è possibile lasciare vuoto questo campo. Le credenziali della compilazione vengono usate automaticamente.

Classico

1. Aggiungere l'attività .NET Core e selezionare Ripristina nella schermata di configurazione.

2. Per Feed da aggiungere, selezionare Feed nel NuGet.config.

3. In Percorso per NuGet.configimmettere il percorso del file NuGet.config relativo alla radice del repository. È possibile selezionare i puntini di sospensione ... per passare a e selezionare il percorso del repository.

4. In Credenziali per feed esterni a questa organizzazione/raccolta selezionare le credenziali da usare per i registri esterni che si trovano nel NuGet.configselezionato. Per i feed in questa organizzazione, è possibile lasciare vuoto questo campo perché le credenziali della compilazione vengono usate automaticamente.

   È possibile selezionare Gestisci per passare alle impostazioni del progetto e selezionare la connessione. È anche possibile selezionare Nuovo per creare una connessione al servizio. Assicurarsi di selezionare la casella di controllo Concedi l'autorizzazione di accesso a tutte le pipeline.

Ripristinare i pacchetti per i progetti .NET Framework

Se nella soluzione è presente anche un progetto Microsoft .NET Framework o si usa package.json per specificare le dipendenze, usare l'attività NuGetCommand@2 per ripristinare tali dipendenze.

- task: NuGetCommand@2
  inputs:
    command: 'restore'
    restoreSolution: '**/*.sln'
    feedsToUse: 'select'

Nota

Per Ubuntu 24.04 o versione successiva, è necessario usare l'attività NuGetAuthenticate anziché l'attività NuGetCommand@2 con l'interfaccia della riga di comando di .NET. Per altre informazioni, vedere Supporto per le immagini ospitate di Ubuntu più recenti.

Compilare il progetto

Compilare il progetto .NET Core eseguendo il dotnet build comando . È possibile aggiungere il comando alla pipeline usando l'attività .NET Core (DotNetCoreCLI@2) o come script della riga di comando.

Usare l'attività .NET Core

YAML

È possibile aggiungere un'attività di compilazione con l'editor della pipeline YAML modificando direttamente il file o usando l'assistente attività.

Aggiungere direttamente l'attività .NET Core (DotNetCoreCLI@2) inserendo il frammento di codice seguente. Aggiornare per arguments soddisfare le proprie esigenze.

steps:
- task: DotNetCoreCLI@2
  displayName: Build
  inputs:
    command: build
    projects: '**/*.csproj'
    arguments: '--configuration $(buildConfiguration)'

Per usare l'assistente delle attività:

1. Passare alla posizione nel file YAML in cui si desidera inserire l'attività.
2. Selezionare l'attività .NET Core (DotNetCoreCLI@2).
3. Selezionare build nell'elenco a discesa Comando .
4. Nel campo Percorso progetti o soluzioni immettere il percorso dei file *.csproj . È possibile usare il carattere jolly **/*.csproj per tutti i file *.csproj in tutte le sottocartelle.
5. Selezionare Aggiungi.
6. Selezionare Salva per eseguire il commit della modifica.

Classico

È possibile aggiungere un'attività di compilazione usando l'editor classico.

1. Nella scheda Attività della pipeline selezionare Processo agente 1 o altro processo che esegue le attività di compilazione.
2. Selezionare + per aggiungere una nuova attività a tale processo.
3. Nel catalogo attività selezionare .NET Core e quindi selezionare Aggiungi.
4. Nel riquadro sinistro selezionare l'attività dotnet build aggiunta per aprire l'editor attività. Il campo Comando mostra già la compilazione.
5. Nel campo Percorso progetti o soluzioni immettere il percorso dei file *.csproj . È possibile usare il carattere jolly **/*.csproj per tutti i file *.csproj in tutte le sottocartelle.
6. Per Feed da aggiungere, assicurarsi che i feed selezionati qui e Use packages from NuGet.org (Usa pacchetti da NuGet.org ) siano selezionati.
7. Nel riquadro sinistro trascinare l'attività per posizionarla nella sequenza di attività corretta.
8. Nella parte superiore della pagina selezionare Salva e salva coda>.

Compilare .NET Core con uno script della riga di comando

È anche possibile compilare usando uno script della riga di comando.

YAML

Per aggiungere una riga di comando di compilazione modificando direttamente il file YAML, aggiungere il codice seguente:

steps:
- script: dotnet build --configuration $(buildConfiguration)
  displayName: 'dotnet build $(buildConfiguration)'

È anche possibile usare l'assistente attività per aggiungere l'attività Riga di comando .

1. Passare alla posizione nel file YAML in cui si desidera inserire l'attività.
2. Selezionare l'attività Riga di comando (CmdLine@2) dall'elenco.
3. Nel campo Script immettere il dotnet build comando con i parametri. Ad esempio: dotnet build --configuration $(buildConfiguration).
4. InDirectory di lavoro> immettere il percorso del file *.csproj come directory di lavoro. Se si lascia vuoto, per impostazione predefinita la directory di lavoro è $(Build.SourcesDirectory).
5. Selezionare Aggiungi.
6. Selezionare Salva per eseguire il commit della modifica.

Classico

Per aggiungere una riga di comando di compilazione usando l'editor classico:

1. Nella scheda Attività della pipeline selezionare Processo agente 1 o altro processo che esegue le attività di compilazione.
2. Selezionare + per aggiungere una nuova attività a tale processo.
3. Nel catalogo attività selezionare Riga di comando e quindi Aggiungi.
4. Nel riquadro sinistro selezionare l'attività Script della riga di comando aggiunta per aprire l'editor attività.
5. Modificare il nome visualizzato , se necessario.
6. In Script immettere il dotnet build comando con i parametri. Ad esempio: dotnet build --configuration $(buildConfiguration).
7. InDirectory di lavoro> immettere il percorso del file *.csproj come directory di lavoro. È possibile selezionare i puntini di sospensione ... per passare a e selezionare il percorso del repository.
8. Nel riquadro sinistro trascinare l'attività per posizionarla nella sequenza di attività corretta.
9. Nella parte superiore della pagina selezionare Salva e salva coda>.

Aggiungere altri comandi .NET SDK alla pipeline

È possibile aggiungere altri comandi .NET SDK alla pipeline usando l'attività .NET Core (DotNetCoreCLI@2) o come script.

Aggiungere un comando CLI di .NET con l'attività .NET Core

L'attività .NET Core (DotNetCoreCLI@2) consente di aggiungere facilmente comandi dell'interfaccia della riga di comando .NET alla pipeline. È possibile aggiungere attività .NET Core (DotNetCoreCLI@2) modificando il file YAML o usando l'editor classico.

YAML

Per aggiungere un comando .NET Core usando l'assistente attività nell'editor della pipeline YAML, seguire questa procedura:

1. Passare alla posizione nel file YAML in cui si desidera inserire l'attività.
2. Selezionare .NET Core dal catalogo attività.
3. Selezionare il comando da eseguire dall'elenco a discesa nel campo Comando .
4. Configurare tutte le opzioni necessarie.
5. Selezionare Aggiungi.
6. Selezionare Salva per eseguire il commit della modifica.

Aggiungere un comando dell'interfaccia della riga di comando di .NET Core in uno script

È possibile aggiungere un comando dell'interfaccia della riga di comando di .NET Core come nel script file azure-pipelines.yml . Per esempio:

steps:
# ...
- script: dotnet test <test-project> 

Classico

Per aggiungere un comando .NET Core usando l'editor classico, seguire questa procedura:

1. Nella scheda Attività della pipeline selezionare Processo agente 1 o altro processo che esegue le attività di compilazione.
2. Selezionare + per aggiungere una nuova attività a tale processo.
3. Nel catalogo attività selezionare .NET Core e quindi selezionare Aggiungi.
4. Nel riquadro sinistro selezionare l'attività dotnet build aggiunta per aprire l'editor attività.
5. Modificare il nome visualizzato in base alle esigenze. Il nome dell'attività nel riquadro sinistro viene aggiornato di conseguenza.
6. In Comando selezionare il comando che si vuole eseguire, ad esempio personalizzato.
7. Configurare tutte le opzioni necessarie.
8. Nel riquadro sinistro trascinare l'attività per posizionarla nella sequenza di attività corretta.
9. Nella parte superiore della pagina selezionare Salva e salva coda>.

Installare uno strumento

Per installare uno strumento globale .NET Core come dotnetsay in una compilazione in esecuzione in Windows, aggiungere un'attività .NET Core e impostare le proprietà seguenti nella configurazione:

• Comando: personalizzato
• Percorso dei progetti: lasciare vuoto
• Comando personalizzato: tool
• Argomenti: install -g dotnetsay

Per eseguire lo strumento, aggiungere un'attività Riga di comando e immettere dotnetsay nel campo Script .

Esecuzione dei test

Quando sono presenti progetti di test nel repository, è possibile usare l'attività .NET Core (DotNetCoreCLI@2) per eseguire unit test usando framework di test come MSTest, xUnit e NUnit. Il progetto di test deve fare riferimento a Microsoft.NET.Test.SDK versione 15.8.0 o successiva.

I risultati dei test vengono pubblicati automaticamente nel servizio e sono disponibili nel riepilogo della compilazione. È possibile usare i risultati del test per risolvere i problemi relativi ai test non superati e analizzare i tempi dei test.

Per aggiungere un'attività di test alla pipeline, aggiungere il frammento di codice seguente al file azure-pipelines.yml :

steps:
# ...
# do this after other tasks such as build
- task: DotNetCoreCLI@2
  inputs:
    command: test
    projects: '**/*Tests/*.csproj'
    arguments: '--configuration $(buildConfiguration)'

Se si usa l'assistente attività per aggiungere l'attività .NET Core (DotNetCoreCLI@2), impostare le proprietà seguenti:

• Comando: test
• Percorso dei progetti: impostare sui progetti di test nella soluzione
• Argomenti: --configuration $(BuildConfiguration)

In alternativa, è possibile eseguire il dotnet test comando con un logger specifico e quindi usare l'attività PublishTestResults@2 :

steps:
# ...
# do this after your tests run
- script: dotnet test <test-project> --logger trx
- task: PublishTestResults@2
  condition: succeededOrFailed()
  inputs:
    testRunner: VSTest
    testResultsFiles: '**/*.trx'

Raccogliere copertura del codice

Quando si usa la piattaforma Windows, è possibile raccogliere le metriche di code coverage usando l'agente di raccolta dati di copertura predefinito. Il progetto di test deve fare riferimento a Microsoft.NET.Test.SDK versione 15.8.0 o successiva.

Quando si usa l'attività .NET Core (DotNetCoreCLI@2) per eseguire i test, i dati di copertura vengono pubblicati automaticamente nel server. È possibile scaricare il file *.coverage dal riepilogo della compilazione per visualizzare in Visual Studio.

Per raccogliere il code coverage, aggiungere l'argomento quando si aggiunge l'attività --collect "Code Coverage" di test alla pipeline.

steps:
# ...
# do this after other tasks such as build
- task: DotNetCoreCLI@2
  inputs:
    command: test
    projects: '**/*Tests/*.csproj'
    arguments: '--configuration $(buildConfiguration) --collect "Code Coverage"'

Se si usa l'assistente attività per aggiungere l'attività .NET Core (DotNetCoreCLI@2), impostare le proprietà seguenti:

• Comando: test
• Percorso dei progetti: impostare sui progetti di test nella soluzione
• Argomenti: --configuration $(BuildConfiguration) --collect "Code Coverage"

Assicurarsi che l'opzione Pubblica risultati test rimanga selezionata.

In alternativa, per raccogliere i risultati del code coverage usando il dotnet test comando con un logger specifico e quindi eseguire l'attività PublishTestResults@2 , usare il codice seguente:

steps:
# ...
# do this after your tests run
- script: dotnet test <test-project> --logger trx --collect "Code Coverage"
- task: PublishTestResults@2
  inputs:
    testRunner: VSTest
    testResultsFiles: '**/*.trx'

Raccogliere le metriche di code coverage con Coverlet

Se si esegue la compilazione in Linux o macOS, è possibile usare Coverlet o uno strumento simile per raccogliere le metriche di code coverage.

È possibile pubblicare i risultati del code coverage nel server con l'attività Pubblica risultati code coverage (PublishCodeCoverageResults@2). È necessario configurare lo strumento di copertura per generare i risultati in formato Cobertura o JaCoCo coverage.

Per eseguire test e pubblicare code coverage con Coverlet:

1. Aggiungere un riferimento al pacchetto NuGet coverlet.collector.
2. Aggiungere il frammento di codice seguente al file azure-pipelines.yml :

- task: DotNetCoreCLI@2
  displayName: 'dotnet test'
  inputs:
    command: 'test'
    arguments: '--configuration $(buildConfiguration) --collect:"XPlat Code Coverage" -- DataCollectionRunSettings.DataCollectors.DataCollector.Configuration.Format=cobertura'
    publishTestResults: true
    projects: '<test project directory>'
  
- task: PublishCodeCoverageResults@2
  displayName: 'Publish code coverage report'
  inputs:
    codeCoverageTool: 'Cobertura'
    summaryFileLocation: '$(Agent.TempDirectory)/**/coverage.cobertura.xml'

Confeziona e consegna il tuo codice

Per creare un pacchetto e recapitare l'output di compilazione, è possibile:

• Pubblicare gli artefatti di compilazione in Azure Pipelines.
• Creare un pacchetto NuGet e pubblicarlo nel feed NuGet.
• Pubblicare il pacchetto NuGet in Azure Artifacts.
• Creare un archivio ZIP da distribuire in un'app Web.
• Pubblicare simboli in un server di simboli di Azure Artifacts o in una condivisione file.

È anche possibile creare un'immagine per l'app ed eseguirne il push in un registro di container.

Pubblicare elementi in Azure Pipelines

Per pubblicare l'output della compilazione .NET nella pipeline, seguire questa procedura.

1. Eseguire dotnet publish --output $(Build.ArtifactStagingDirectory) usando l'interfaccia della riga di comando di .NET o aggiungere l'attività .NET Core (DotNetCoreCLI@2) con il comando publish .
2. Pubblicare l'artefatto usando l'attività Publish Pipeline Artifact (PublishPipelineArtifact@1). Questa attività carica tutti i file in $(Build.ArtifactStagingDirectory) come artefatto della compilazione.

Aggiungere il codice seguente al file azure-pipelines.yml :

steps:

- task: DotNetCoreCLI@2
  inputs:
    command: publish
    publishWebProjects: True
    arguments: '--configuration $(BuildConfiguration) --output $(Build.ArtifactStagingDirectory)'
    zipAfterPublish: True

- task: PublishPipelineArtifact@1
  inputs:
    targetPath: '$(Build.ArtifactStagingDirectory)' 
    artifactName: 'myWebsite'

Per copiare altri file nella directory di compilazione prima della pubblicazione, usare l'attività Copia file (CopyFile@2).

Nota

L'input publishWebProjects nell'attività .NET Core (DotNetCoreCLI@2) è impostato su true per impostazione predefinita e pubblica tutti i progetti Web nel repository. Per altre informazioni, vedere il repository GitHub azure-pipelines-tasks .

Per altre informazioni, vedere Pubblicare e scaricare gli artefatti di compilazione.

Pubblicare in un feed NuGet

Per creare un pacchetto NuGet e pubblicarlo nel feed NuGet, aggiungere il frammento di codice seguente al file azure-pipelines.yml :

steps:
# ...
# do this near the end of your pipeline
- script: dotnet pack /p:PackageVersion=$(version)  # define the version variable elsewhere in your pipeline
- task: NuGetAuthenticate@1
  inputs:
    nuGetServiceConnections: '<NuGet service connection>'
- task: NuGetCommand@2
  inputs:
    command: push
    nuGetFeedType: external
    publishFeedCredentials: '<NuGet service connection>'
    versioningScheme: byEnvVar
    versionEnvVar: version

Nota

L'attività NuGetAuthenticate@1 non supporta l'autenticazione della chiave API NuGet. Se si usa una chiave API NuGet, usare l'attività NuGetCommand@2 con l'input command impostato su push e l'argomento --api-key . Ad esempio: dotnet nuget push --api-key $(NuGetApiKey).

Per altre informazioni sul controllo delle versioni e sulla pubblicazione di pacchetti NuGet, vedere Pubblicare pacchetti NuGet con Azure Pipelines.

Pubblicare un pacchetto NuGet in Azure Artifacts

È possibile pubblicare i pacchetti NuGet nel feed di Azure Artifacts usando l'attività NuGetCommand@2 . Per altre informazioni, vedere Pubblicare pacchetti NuGet con Azure Pipelines.

Pubblicare un archivio di file ZIP in un'app Web

Per creare un archivio di file ZIP pronto per la pubblicazione in un'app Web, aggiungere il frammento di codice seguente a azure-pipelines.yml. Eseguire questa attività dopo aver compilato l'app, nella maggior parte dei casi alla fine della pipeline. Ad esempio, eseguire questa attività prima di eseguire la distribuzione in un'app Web di Azure in Windows.

steps:
# ...
- task: DotNetCoreCLI@2
  inputs:
    command: publish
    publishWebProjects: True
    arguments: '--configuration $(BuildConfiguration) --output $(Build.ArtifactStagingDirectory)'
    zipAfterPublish: True

Per pubblicare questo archivio in un'app Web, vedere Distribuzione di Azure App Web.

Pubblicare i simboli

È possibile usare l'attività PublishSymbols@2 per pubblicare simboli in un server di simboli di Azure Artifacts o in una condivisione file. Per altre informazioni, vedere Pubblicare simboli.

Ad esempio, per pubblicare simboli in una condivisione file, aggiungere il frammento di codice seguente al file azure-pipelines.yml :

- task: PublishSymbols@2
  inputs:
    SymbolsFolder: '$(Build.SourcesDirectory)'
    SearchPattern: '**/bin/**/*.pdb'
    IndexSources: true
    PublishSymbols: true
    SymbolServerType: 'FileShare' 
    SymbolsPath: '\\<server>\<shareName>'

Per usare l'editor classico, aggiungere l'attività Origini indice e pubblicazione simboli alla pipeline.

Risoluzione dei problemi

Se il progetto viene compilato correttamente nel computer locale ma non in Azure Pipelines, esplorare le possibili cause e le azioni correttive seguenti.

• Le versioni non definitive di .NET Core SDK non sono installate negli agenti ospitati da Microsoft e l'implementazione di una nuova versione dell'SDK in tutti i data center di Azure Pipelines può richiedere alcune settimane. Anziché attendere il completamento di un'implementazione, è possibile usare l'attività Usa .NET Core per installare la versione di .NET Core SDK desiderata negli agenti ospitati da Microsoft.

• Una nuova versione di .NET Core SDK o Visual Studio potrebbe interrompere la compilazione, ad esempio se contiene una versione o una funzionalità più recente dello strumento NuGet. Assicurarsi che le versioni e il runtime di .NET Core SDK nel computer di sviluppo corrispondano all'agente della pipeline.

  È possibile includere uno dotnet --version script della riga di comando nella pipeline per stampare la versione di .NET Core SDK. Usare il programma di installazione dello strumento .NET Core per distribuire la stessa versione nell'agente oppure aggiornare i progetti e il computer di sviluppo alla versione della pipeline di .NET Core SDK.

• Le compilazioni potrebbero non riuscire in modo intermittente a causa di problemi di connessione quando si ripristinano pacchetti da NuGet.org. NuGet.org potrebbero verificarsi problemi o potrebbero verificarsi problemi di rete tra il data center di Azure e NuGet.org. È possibile verificare se l'uso di Azure Artifacts con origini upstream per memorizzare nella cache i pacchetti migliora l'affidabilità delle compilazioni.

  Le credenziali della pipeline vengono usate automaticamente per connettersi ad Azure Artifacts. Queste credenziali vengono in genere derivate dall'account Project Collection Build Service. Per altre informazioni sull'uso di Azure Artifacts per memorizzare nella cache i pacchetti NuGet, vedere Connettersi ai feed di Azure Artifact.

• È possibile usare una logica in Visual Studio non codificata nella pipeline. Azure Pipelines esegue ogni comando in un'attività in sequenza in un nuovo processo. Esaminare i log della compilazione delle pipeline per visualizzare i comandi esatti eseguiti nella compilazione. Per individuare il problema, ripetere gli stessi comandi nello stesso ordine nel computer di sviluppo.

• Se si dispone di una soluzione mista che include alcuni progetti .NET Core e alcuni progetti .NET Framework, usare l'attività NuGet per ripristinare i pacchetti specificati nei file dipackages.config . Aggiungere l'attività MSBuild o Visual Studio Build per compilare i progetti .NET Framework.

Contenuti correlati

• Azure Artifacts
• Attività di compilazione e rilascio
• Strumenti dell'interfaccia della riga di comando di .NET Core
• Unit test nei progetti .NET Core