Build, test, and deploy .NET Core apps (.NET Core-apps bouwen, testen en implementeren)

Azure DevOps Services | Azure DevOps Server 2022 - Azure DevOps Server 2019

Gebruik een Azure Pipeline om uw .NET Core-projecten automatisch te bouwen, testen en implementeren. In dit artikel leest u hoe u de volgende taken uitvoert:

• Stel uw buildomgeving in met door Microsoft gehoste of zelf-hostende agents.
• Herstel afhankelijkheden, bouw uw project en test met de .NET Core-taak (DotNetCoreCLI@2) of een script.
• Test uw code en gebruik de taak voor het publiceren van codedekking om resultaten van de codedekking te publiceren.
• Uw build-uitvoer verpakken en leveren aan:
  • uw pijplijn.
  • een NuGet-feed.
  • een .zip bestand voor het implementeren van een web-app in Azure.

Notitie

Zie Build ASP.NET-apps met .NET Framework voor hulp bij .NET Framework-projecten.

Vereisten

• Een GitHub-account waar u een opslagplaats kunt maken. Maak gratis een account.
• Een Azure DevOps-organisatie en -project. Maak gratis een account.
• Een mogelijkheid om pijplijnen uit te voeren op door Microsoft gehoste agents. U kunt een parallelle taak aanschaffen of u kunt een gratis laag aanvragen.

Uw eerste pijplijn maken

Bent u nieuw voor Azure Pipelines? Zo ja, dan raden we u aan eerst de volgende sectie uit te voeren.

Een .NET-project maken

Als u geen .NET-project hebt om mee te werken, maakt u een nieuw project op uw lokale systeem. Begin met het installeren van de nieuwste .NET 8.0 SDK .

1. Een terminalvenster openen.

2. Maak een projectmap en navigeer ernaartoe.

3. Maak een nieuwe .NET 8-web-app.

   dotnet new webapp -f net8.0
   

4. Voer vanuit dezelfde terminalsessie de toepassing lokaal uit met behulp van de dotnet run opdracht uit uw projectmap.

   dotnet run
   

5. Zodra de toepassing is gestart, drukt u op Ctrl-C om de toepassing af te sluiten.

Een Git-opslagplaats maken en deze verbinden met GitHub

1. Maak vanuit de projectmap een lokale Git-opslagplaats en voer de toepassingscode door naar de hoofdbranch.

2. Verbind uw lokale Git-opslagplaats met een GitHub-opslagplaats.

Een DevOps-project maken

Meld u aan bij Azure Pipelines. Nadat u zich hebt aangemeld, gaat uw browser naar https://dev.azure.com/my-organization-name en geeft u uw Azure DevOps-dashboard weer.

1. Ga in een browser naar dev.azure.com en meld u aan.
2. Selecteer uw organisatie.
3. Maak een nieuw project door Nieuw project of Project maken te selecteren als u het eerste project in de organisatie maakt.
4. Voer een projectnaam in.
5. Selecteer de zichtbaarheid voor uw project.
6. Selecteer Maken.

1. Ga in een browser naar uw Azure DevOps-server.
2. Selecteer uw verzameling.
3. Maak een nieuw project door Nieuw project of Project maken te selecteren als u het eerste project in de verzameling maakt.
4. Voer een projectnaam in.
5. Selecteer de zichtbaarheid voor uw project.
6. Selecteer Maken.

Uw buildomgeving instellen

Uw builds worden uitgevoerd op door Microsoft gehoste agents. U kunt uw .NET Core-projecten bouwen met behulp van de .NET Core SDK en runtime in Windows, Linux en macOS.

U kunt ook een zelf-hostende agent gebruiken. Met een zelf-hostende agent kunt u preview- of privé-SDK's gebruiken die niet officieel worden ondersteund door Azure DevOps Services en incrementele builds uitvoeren.

Uw pijplijn maken

U kunt de YAML-pijplijneditor of de klassieke editor gebruiken om uw pijplijn te maken. Als u de klassieke editor wilt gebruiken, selecteert u De klassieke editor gebruiken.

YAML

Een nieuwe pijplijn maken en uw bron selecteren

1. Meld u aan bij uw Azure DevOps-organisatie en ga naar uw project.

2. Ga naar Pijplijnen en selecteer vervolgens Nieuwe pijplijn of Pijplijn maken als u uw eerste pijplijn maakt.

3. Voer de stappen van de wizard uit door eerst GitHub te selecteren als de locatie van uw broncode.

4. U wordt mogelijk omgeleid naar GitHub om u aan te melden. Voer in dat geval uw GitHub-referenties in.

5. Wanneer u de lijst met opslagplaatsen ziet, selecteert u de opslagplaats.

6. U wordt mogelijk omgeleid naar GitHub om de Azure Pipelines-app te installeren. Als dat het zo is, selecteert u Goedkeuren en installeren.

Uw pijplijn configureren

1. Wanneer het tabblad Configureren wordt weergegeven, selecteert u Meer weergeven en selecteert u de ASP.NET Core-pijplijnsjabloon in de lijst.

2. Bekijk uw nieuwe pijplijn om te zien wat de YAML doet.

U kunt het YAML-bestand aanpassen aan uw vereisten. U kunt bijvoorbeeld de agentgroep opgeven of een taak toevoegen om een andere .NET SDK te installeren.

Uw pijplijn opslaan en uitvoeren

1. Wanneer u klaar bent, selecteert u Opslaan en uitvoeren.

   

2. Desgewenst kunt u het doorvoerbericht bewerken.

3. Voer het nieuwe azure-pipelines.yml-bestand door naar uw opslagplaats door Opslaan en uitvoeren te selecteren.

4. Als u de pijplijn in actie wilt bekijken, selecteert u de taak in de sectie Taken .

Klassiek

Gebruik deze stappen om uw pijplijn te maken met behulp van de klassieke editor.

Pijplijn maken

1. Ga naar uw project en selecteer Pijplijnen.

2. Selecteer Pijplijn of Nieuwe pijplijn maken als u de eerste pijplijn voor dit project niet maakt.

3. Selecteer De klassieke editor gebruiken.

Selecteer uw bron

1. Selecteer uw bron. Voor dit voorbeeld selecteert u GitHub.
2. Voer uw GitHub-referenties in om een GitHub-serviceverbinding te maken voor gebruik in uw pijplijn.
3. Selecteer uw opslagplaats en selecteer Doorgaan.

Uw pijplijn configureren

1. Zoek en selecteer ASP.NET Core in Een sjabloon selecteren.

   De pijplijnpagina wordt geopend waar u uw pijplijn kunt configureren. Hier kunt u taken toevoegen, de agentgroepen en agents opgeven en andere buildopties configureren.

2. Selecteer uw agentgroep op het tabblad Taken (meestal standaard)

3. Selecteer de agentspecificatie. Voor dit voorbeeld selecteert u windows-latest.

   U kunt andere taken toevoegen aan de agenttaak door de agenttaak te selecteren + en een andere taak in de catalogus te selecteren. U kunt bijvoorbeeld de taak .NET Core gebruiken toevoegen als eerste taak om de benodigde versie van de .NET SDK te installeren.

Uw pijplijn opslaan en uitvoeren

1. Selecteer Opslaan en wachtrij in de vervolgkeuzelijst Opslaan en wachtrij boven aan de pagina.
2. Voer in De pijplijn Uitvoeren een opmerking in en selecteer Opslaan en Uitvoeren.

U kunt uw pijplijn in actie zien door de taak te selecteren in de sectie Taken op het tabblad Samenvatting .

U hebt nu een werkende pijplijn die u kunt aanpassen. Lees verder voor meer informatie over enkele veelgebruikte manieren om uw pijplijn aan te passen.

Omgeving bouwen

U kunt Azure Pipelines gebruiken om uw .NET Core-projecten te bouwen in Windows, Linux of macOS zonder dat u infrastructuur hoeft in te stellen.

Ubuntu is bijvoorbeeld hier ingesteld in het YAML-pijplijnbestand.

pool:
  vmImage: 'ubuntu-latest' 

Zie door Microsoft gehoste agents voor een volledige lijst met installatiekopieën en verdere configuratievoorbeelden.

De door Microsoft gehoste agents in Azure Pipelines bevatten verschillende vooraf geïnstalleerde versies van ondersteunde .NET Core SDK's. Door Microsoft gehoste agents bevatten geen enkele van de oudere versies van de .NET Core SDK. Ze bevatten doorgaans ook geen voorlopige versies. Als u deze versies van de SDK op door Microsoft gehoste agents nodig hebt, installeert u deze met behulp van de UseDotNet@2 taak.

Als u bijvoorbeeld 5.0.x SDK wilt installeren, voegt u het volgende codefragment toe:

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

Windows-agents bevatten al een .NET Core-runtime. Als u een nieuwere SDK wilt installeren, stelt u deze in performMultiLevelLookup true het volgende fragment in:

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

Tip

Als u de kosten voor het uitvoeren van het installatieprogramma voor het hulpprogramma wilt besparen, kunt u een zelf-hostende Linux-, macOS- of Windows-agent instellen. U kunt ook zelf-hostende agents gebruiken om extra tijd te besparen als u een grote opslagplaats hebt of incrementele builds uitvoert. Een zelf-hostende agent kan u ook helpen bij het gebruik van de preview- of privé-SDK's die niet officieel worden ondersteund door Azure DevOps of die alleen beschikbaar zijn in uw bedrijfs- of on-premises omgevingen.

Afhankelijkheden herstellen

NuGet is een populaire manier om afhankelijk te zijn van code die u niet bouwt. U kunt NuGet-pakketten en projectspecifieke hulpprogramma's downloaden die zijn opgegeven in het projectbestand door de dotnet restore opdracht uit te voeren via de .NET Core-taak of rechtstreeks in een script in uw pijplijn. Zie .NET Core-taak (DotNetCoreCLI@2) voor meer informatie.

U kunt NuGet-pakketten downloaden uit Azure Artifacts, NuGet.org of een andere externe of interne NuGet-opslagplaats. De .NET Core-taak is vooral handig om pakketten te herstellen van geverifieerde NuGet-feeds. Als uw feed zich in hetzelfde project bevindt als uw pijplijn, hoeft u zich niet te verifiëren.

Deze pijplijn maakt gebruik van een Azure Artifact-feed voor dotnet restore in de DotNetCoreCLI@2 taak.

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)'

De dotnet restore opdracht maakt gebruik van de NuGet.exe verpakte met de .NET Core SDK en kan alleen pakketten herstellen die zijn opgegeven in de .NET Core-projectbestanden .csproj .

Als u ook een Microsoft .NET Framework-project in uw oplossing hebt of gebruikt package.json om uw afhankelijkheden op te geven, gebruikt u de NuGet-taak om deze afhankelijkheden te herstellen.

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

In .NET Core SDK versie 2.0 en hoger worden pakketten automatisch hersteld bij het uitvoeren van opdrachten zoals dotnet build. U moet echter nog steeds de .NET Core-taak gebruiken om pakketten te herstellen als u een geverifieerde feed gebruikt.

Uw builds kunnen mislukken vanwege verbindingsproblemen wanneer u pakketten herstelt vanuit NuGet.org. U kunt Azure Artifacts met upstream-bronnen gebruiken om de pakketten in de cache op te cachen. De referenties van de pijplijn worden automatisch gebruikt wanneer deze verbinding maakt met Azure Artifacts. Deze referenties zijn doorgaans afgeleid van het Project Collection Build Service-account . Zie Connect to Azure Artifact feeds (Verbinding maken met Azure Artifact-feeds) voor meer informatie over het gebruik van Azure Artifacts om uw NuGet-pakketten in de cache op te slaan.

Als u een NuGet-opslagplaats wilt opgeven, plaatst u de URL in een NuGet.config bestand in uw opslagplaats. Als uw feed is geverifieerd, beheert u de referenties door een NuGet-serviceverbinding te maken op het tabblad Services onder Projectinstellingen.

Wanneer u door Microsoft gehoste agents gebruikt, krijgt u elke keer dat u een build uitvoert een nieuwe machine, waarmee de pakketten bij elke uitvoering worden hersteld. Herstel kan een aanzienlijke hoeveelheid tijd in beslag nemen. Om dit te verhelpen, kunt u Azure Artifacts of een zelf-hostende agent gebruiken met het voordeel van het gebruik van de pakketcache.

Zie Publiceren naar NuGet-feeds voor meer informatie over NuGet-serviceverbindingen.

Pakketten herstellen vanuit een externe feed

Ga als volgt te werk om pakketten te herstellen vanuit een externe feed.

YAML

U kunt de herstelopdracht toevoegen aan uw pijplijn met behulp van de YAML-pijplijneditor door het volgende fragment rechtstreeks in uw azure-pipelines.yml bestand in te voegen of door de taakassistent te gebruiken om de .NET Core-taak toe te voegen.

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

Vervang de tijdelijke aanduiding> door de <naam van de serviceverbinding.

De taakassistent gebruiken:

Als u een build-taak wilt toevoegen met behulp van de taakassistent, voert u de volgende stappen uit:

1. Ga naar de positie in het YAML-bestand waar u de taak wilt invoegen.

2. Selecteer .NET Core in de taakcatalogus.

3. Selecteer de opdracht Herstellen in de vervolgkeuzelijst Opdracht .

4. Voer in het veld Pad naar project(en) het pad naar uw .csproj bestanden in.

5. Selecteer Toevoegen.

6. Selecteer Opslaan om de wijziging door te voeren.

Klassiek

Gebruik deze stappen om een hersteltaak toe te voegen met behulp van de klassieke editor:

1. Selecteer Taken in uw pijplijn en selecteer de taak waarmee uw buildtaken worden uitgevoerd.

2. Selecteer + deze optie om een nieuwe taak aan die taak toe te voegen.

3. Zoek en selecteer in de taakcatalogus .NET Core-taak en selecteer Toevoegen.

4. Selecteer de taak om de taakeditor te openen.

5. Selecteer herstellen in de opdrachtlijst en geef eventuele andere opties op die u nodig hebt voor deze taak.

6. Sleep de taak in de takenlijst om deze vóór de build-taak te plaatsen.

7. Selecteer in de vervolgkeuzelijst Opslaan en wachtrij een optie om de wijziging op te slaan.

Notitie

Zorg ervoor dat de aangepaste feed is opgegeven in uw NuGet.config bestand en dat referenties zijn opgegeven in de NuGet-serviceverbinding.

Uw project bouwen

Bouw uw .NET Core-projecten door de opdracht uit te dotnet build voeren. U kunt de opdracht als opdrachtregelscript aan uw pijplijn toevoegen of met behulp van de .NET Core-taak.

.NET Core-build met behulp van de .NET Core-taak

YAML-voorbeeld om te bouwen met behulp van de DotNetCoreCLI@2 taak:

steps:
- task: DotNetCoreCLI@2
  displayName: Build
  inputs:
    command: build
    projects: '**/*.csproj'
    arguments: '--configuration $(buildConfiguration)' # Update this to match your needs

YAML

U kunt een build-taak toevoegen met behulp van de YAML-pijplijneditor door het bestand rechtstreeks te bewerken of de .NET Core-taak toe te voegen met behulp van de taakassistent.

Als u een build-taak wilt toevoegen met behulp van de taakassistent, voert u de volgende stappen uit:

1. Ga naar de positie in het YAML-bestand waar u de taak wilt invoegen.

2. Selecteer .NET Core in de taakcatalogus.

3. Selecteer de build-opdracht in de vervolgkeuzelijst Opdracht .

4. Voer in het veld Pad naar project(en) het pad naar uw .csproj bestanden in.

5. Selecteer Toevoegen.

6. Selecteer Opslaan om de wijziging door te voeren.

Klassiek

Als u een build-taak wilt toevoegen met de klassieke editor, voert u de volgende stappen uit:

1. Selecteer Taken in uw pijplijn.

2. Selecteer de taak waarmee uw buildtaken worden uitgevoerd.

3. Selecteer + deze optie om een nieuwe taak aan die taak toe te voegen.

4. Zoek en voeg in de taakcatalogus de .NET Core-taak toe.

5. Selecteer de taak en selecteer build in de vervolgkeuzelijst Opdracht .

6. Voer in het veld Pad naar project(en) het pad naar uw .csproj bestanden in.

7. Sleep de taak om deze in de juiste takenreeks in de pijplijn te plaatsen.

8. Selecteer de vervolgkeuzelijst Opslaan en wachtrij en selecteer een optie om uw wijzigingen op te slaan.

.NET Core-build met opdrachtregelscript

YAML-voorbeeld om te bouwen met behulp van dotnet build een script:

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

YAML

U kunt een build-taak toevoegen met behulp van de YAML-pijplijneditor door het bestand rechtstreeks te bewerken of de opdrachtregeltaak toe te voegen.

Gebruik de volgende stappen om de opdrachtregeltaak toe te voegen:

1. Ga naar de positie in het YAML-bestand waar u de taak wilt invoegen.

2. Selecteer de opdrachtregel in de taakcatalogus.

3. Voeg eventueel een weergavenaam toe.

4. Voer de dotnet build opdracht in met parameters. Bijvoorbeeld: dotnet build --configuration $(buildConfiguration).

5. Voer het pad naar het .csproj bestand in als de werkmap.

6. Selecteer Toevoegen.

7. Selecteer Opslaan om de wijziging door te voeren.

Klassiek

Als u een build-taak wilt toevoegen met de klassieke editor, voert u de volgende stappen uit:

1. Selecteer Taken in uw pijplijn.

2. Selecteer de taak waarmee uw buildtaken worden uitgevoerd.

3. Selecteer + deze optie om een nieuwe taak aan die taak toe te voegen.

4. Zoek en voeg de opdrachtregeltaak toe aan de taak in de taakcatalogus.

5. Voeg eventueel een weergavenaam toe.

6. Voer de dotnet build opdracht in met parameters. Bijvoorbeeld: dotnet build --configuration $(buildConfiguration).

7. Voer het pad naar het .csproj bestand in als de werkmap.

8. Sleep de taak om deze in de juiste takenreeks in de pijplijn te plaatsen.

9. Selecteer de vervolgkeuzelijst Opslaan en wachtrij en selecteer een optie om uw wijzigingen op te slaan.

.NET SDK-opdrachten toevoegen aan uw pijplijn

U kunt .NET SDK-opdrachten toevoegen aan uw project als script of met behulp van de .NET Core-taak. Met de taak .NET Core (DotNetCoreCLI@2) kunt u eenvoudig dotnet CLI-opdrachten toevoegen aan uw pijplijn. U kunt .NET Core-taken toevoegen door uw YAML-bestand te bewerken of de klassieke editor te gebruiken.

Een .NET CLI-opdracht toevoegen met behulp van de .NET Core-taak

YAML

Als u een .NET Core CLI-opdracht wilt toevoegen met behulp van de YAML-pijplijneditor, voert u de volgende stappen uit:

1. Ga naar de positie in het YAML-bestand waar u de taak wilt invoegen.

2. Selecteer .NET Core in de taakcatalogus.

3. Selecteer de opdracht die u wilt uitvoeren.

4. Configureer alle benodigde opties.

5. Selecteer Toevoegen.

6. Selecteer Opslaan om de wijziging door te voeren.

Klassiek

Als u .NET Core-taak wilt toevoegen met de klassieke editor, voert u de volgende stappen uit:

1. Selecteer Taken in uw pijplijn.

2. Selecteer de taak waarmee uw buildtaken worden uitgevoerd.

3. Selecteer + deze optie om een nieuwe taak aan die taak toe te voegen.

4. Zoek en voeg in de taakcatalogus de .NET Core-taak toe.

5. Selecteer de taak en selecteer de opdracht die u wilt uitvoeren.

6. Configureer alle benodigde opties.

7. Sleep de taak om deze in de juiste takenreeks in de pijplijn te plaatsen.

8. Selecteer in de vervolgkeuzelijst Opslaan en wachtrij een optie om uw wijzigingen op te slaan.

Een .NET Core CLI-opdracht toevoegen met behulp van een script

U kunt .NET Core CLI-opdrachten toevoegen als een script in uw azure-pipelines.yml bestand.

Voorbeeld:

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

Een hulpprogramma installeren

Als u een algemeen .NET Core-hulpprogramma zoals dotnetsay wilt installeren in uw build die wordt uitgevoerd in Windows, voert u de volgende stappen uit:

1. Voeg de .NET Core-taak toe en stel de volgende eigenschappen in:
   • Opdracht: aangepast.
     • Pad naar projecten: laat leeg.
   • Aangepaste opdracht: hulpprogramma.
   • Argumenten: install -g dotnetsay.
2. Als u het hulpprogramma wilt uitvoeren, voegt u een opdrachtregel toe en stelt u de volgende eigenschappen in:
   • Script: dotnetsay.

Uw tests uitvoeren

Wanneer u projecten in uw opslagplaats hebt getest, kunt u de .NET Core-taak gebruiken om eenheidstests uit te voeren met behulp van testframeworks zoals MSTest, xUnit en NUnit. Het testproject moet verwijzen naar Microsoft.NET.Test.SDK versie 15.8.0 of hoger. Testresultaten worden automatisch gepubliceerd naar de service. Deze resultaten zijn beschikbaar in de samenvatting van de build en kunnen worden gebruikt voor het oplossen van problemen met mislukte tests en testtime-analyse.

U kunt een testtaak aan uw pijplijn toevoegen met behulp van de DotNetCoreCLI@2 taak of het volgende fragment toevoegen aan uw azure-pipelines.yml bestand:

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

Wanneer u de .NET Core-taakeditor gebruikt, stelt u De opdracht in om te testen en moet het pad naar projecten verwijzen naar de testprojecten in uw oplossing.

U kunt de dotnet test opdracht ook uitvoeren met een specifieke logger en vervolgens de taak Testresultaten publiceren gebruiken:

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

Codedekking verzamelen

Wanneer u bouwt op het Windows-platform, kunnen metrische gegevens over de codedekking worden verzameld met behulp van de ingebouwde gegevensverzamelaar voor dekkingsgegevens. Het testproject moet verwijzen naar Microsoft.NET.Test.SDK versie 15.8.0 of hoger.

Wanneer u de .NET Core-taak gebruikt om tests uit te voeren, worden dekkingsgegevens automatisch naar de server gepubliceerd. Het .coverage bestand kan worden gedownload uit de samenvatting van de build voor weergave in Visual Studio.

Voeg het volgende fragment toe aan uw azure-pipelines.yml bestand:

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

De .NET Core-taak toevoegen via de taakeditor:

1. Voeg de .NET Core-taak toe aan uw buildtaak en stel de volgende eigenschappen in:

   1. Opdracht: testen.
   2. Pad naar projecten: Moet verwijzen naar de testprojecten in uw oplossing.
   3. Argumenten: --configuration $(BuildConfiguration) --collect "Code coverage".

2. Zorg ervoor dat de optie Testresultaten publiceren geselecteerd blijft.

Als u ervoor kiest om de dotnet test opdracht uit te voeren, geeft u de logboekregistratie en dekkingsopties voor de testresultaten op. Gebruik vervolgens de taak Testresultaten publiceren:

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

Metrische gegevens voor codedekking verzamelen met Coverlet

Als u bouwt op Linux of macOS, kunt u Coverlet of een vergelijkbaar hulpprogramma gebruiken om metrische gegevens voor codedekking te verzamelen.

U kunt resultaten van de codedekking publiceren naar de server met de taak Codedekkingsresultaten (PublishCodeCoverageResults@1). Het dekkingsprogramma moet worden geconfigureerd om resultaten te genereren in cobertura- of JaCoCo-dekkingsindeling.

Voer de volgende taken uit om tests uit te voeren en codedekking te publiceren met Coverlet:

• Voeg een verwijzing toe naar het coverlet.collector NuGet-pakket.

• Voeg het volgende fragment toe aan uw azure-pipelines.yml bestand:

  - task: UseDotNet@2
    inputs:
      version: '8.x'
      includePreviewVersions: true # Required for preview versions
  
  - task: DotNetCoreCLI@2
    displayName: 'dotnet build'
    inputs:
      command: 'build'
      configuration: $(buildConfiguration)
  
  - 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: 'MyTestLibrary' # update with your test project directory
  
  - task: PublishCodeCoverageResults@1
    displayName: 'Publish code coverage report'
    inputs:
      codeCoverageTool: 'Cobertura'
      summaryFileLocation: '$(Agent.TempDirectory)/**/coverage.cobertura.xml'
  

Uw code verpakken en leveren

U kunt uw buildartefacten publiceren door:

• Publiceren naar Azure Pipelines.
• Pakketten publiceren naar Azure Artifacts.
• Een NuGet-pakket maken en publiceren naar uw NuGet-feed.
• Een .zip archief maken om uw web-app te implementeren.

Artefacten publiceren naar Azure Pipelines

Voer de volgende taken uit om de uitvoer van uw .NET-build naar uw pijplijn te publiceren:

• Voer dotnet publish --output $(Build.ArtifactStagingDirectory) de .NET CLI uit of voeg de DotNetCoreCLI@2 taak toe met de opdracht Publiceren.
• Publiceer het artefact met behulp van de taak Pijplijnartefact publiceren .

Voeg het volgende fragment toe aan uw azure-pipelines.yml bestand:

steps:

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

# this code takes all the files in $(Build.ArtifactStagingDirectory) and uploads them as an artifact of your build.
- task: PublishPipelineArtifact@1
  inputs:
    targetPath: '$(Build.ArtifactStagingDirectory)' 
    artifactName: 'myWebsite'

Notitie

De DotNetCoreCLI@2-taak heeft standaard een publishWebProjects invoer die is ingesteld op waar . Met deze taak worden standaard alle webprojecten in uw opslagplaats gepubliceerd. Meer hulp en informatie vindt u in de opensource-taak op GitHub.

Als u meer bestanden naar de buildmap wilt kopiëren voordat u publiceert, gebruikt u de taak Bestanden kopiëren (CopyFile@2 ).

Publiceren naar een NuGet-feed

Als u een NuGet-pakket wilt maken en naar uw NuGet-feed wilt publiceren, voegt u het volgende codefragment toe:

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

Notitie

De NuGetAuthenticate@1-taak biedt geen ondersteuning voor Verificatie van NuGet-API-sleutels. Als u een NuGet-API-sleutel gebruikt, gebruikt u de NuGetCommand@2 taak met de command invoer die is ingesteld push op het argument --api-key . Bijvoorbeeld: dotnet nuget push --api-key $(NuGetApiKey).

Zie Publiceren naar NuGet-feeds voor meer informatie over versiebeheer en het publiceren van NuGet-pakketten.

Een NuGet-pakket publiceren naar Azure Artifacts

U kunt uw NuGet-pakketten publiceren naar uw Azure Artifacts-feed met behulp van de NuGetCommand@2 om naar uw Azure Artifact-feed te pushen. Zie Bijvoorbeeld NuGet-pakketten publiceren met Azure Pipelines.

Een web-app implementeren

Als u een .zip bestandsarchief wilt maken dat klaar is om te publiceren naar een web-app, voegt u het volgende fragment toe:

steps:
# ...
# do this after you've built your app, near the end of your pipeline in most cases
# for example, you do this before you deploy to an Azure web app on Windows
- task: DotNetCoreCLI@2
  inputs:
    command: publish
    publishWebProjects: True
    arguments: '--configuration $(BuildConfiguration) --output $(Build.ArtifactStagingDirectory)'
    zipAfterPublish: True

Als u dit archief wilt publiceren naar een web-app, raadpleegt u de implementatie van Azure Web Apps.

Een installatiekopieën bouwen en pushen naar het containerregister

U kunt ook een installatiekopieën voor uw app bouwen en naar een containerregister pushen.

Symbolen publiceren

U kunt de PublishSymbols@2 taak gebruiken om symbolen te publiceren naar een Azure Artifacts-symboolserver of een bestandsshare.

Als u bijvoorbeeld symbolen wilt publiceren naar een bestandsshare, voegt u het volgende codefragment toe aan uw azure-pipelines.yml bestand:

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

Wanneer u de klassieke editor gebruikt, selecteert u Indexbronnen die symbolen uit de taakcatalogus publiceren om toe te voegen aan uw pijplijn.

Zie Symbolen publiceren voor meer informatie.

Problemen oplossen

Als u uw project op uw ontwikkelcomputer kunt bouwen, maar u problemen ondervindt met het bouwen ervan in Azure Pipelines, bekijkt u de volgende mogelijke oorzaken en corrigerende acties:

• Voorlopige versies van de .NET Core SDK worden niet geïnstalleerd op door Microsoft gehoste agents. Nadat een nieuwe versie van de .NET Core SDK is uitgebracht, kan het enkele weken duren voordat deze wordt geïmplementeerd in alle Azure Pipelines-datacenters. U hoeft niet te wachten tot deze implementatie is voltooid. U kunt de .NET Core-taak gebruiken om de .NET Core SDK-versie te installeren die u wilt gebruiken op door Microsoft gehoste agents.

• Controleer de .NET Core SDK-versies en -runtime op uw ontwikkelcomputer en zorg ervoor dat deze overeenkomen met de agent. U kunt een opdrachtregelscript dotnet --version in uw pijplijn opnemen om de versie van de .NET Core SDK af te drukken. Gebruik het .NET Core Tool Installer om dezelfde versie op de agent te implementeren of werk uw projecten en ontwikkelcomputer bij naar de nieuwere versie van de .NET Core SDK.

• Mogelijk gebruikt u een aantal logica in de Visual Studio IDE die niet in uw pijplijn is gecodeerd. Azure Pipelines voert elk van de opdrachten uit die u opgeeft in de taken na de andere in een nieuw proces. Bekijk de logboeken van de pijplijnbuild om de exacte opdrachten te zien die zijn uitgevoerd als onderdeel van de build. Herhaal dezelfde opdrachten in dezelfde volgorde op uw ontwikkelcomputer om het probleem op te sporen.

• Als u een gemengde oplossing hebt met enkele .NET Core-projecten en sommige .NET Framework-projecten, moet u ook de NuGet-taak gebruiken om pakketten te herstellen die zijn opgegeven in packages.config bestanden. Voeg de MSBuild - of Visual Studio Build-taak toe om de .NET Framework-projecten te bouwen.

• Uw builds kunnen af en toe mislukken tijdens het herstellen van pakketten: NuGet.org problemen ondervindt of er netwerkproblemen zijn tussen het Azure-datacenter en NuGet.org. U kunt verkennen of het gebruik van Azure Artifacts met NuGet.org als een upstream-bron de betrouwbaarheid van uw builds verbetert, omdat deze niet in onze controle staat.

• Af en toe wordt een nieuwe versie van de .NET Core SDK of Visual Studio geïmplementeerd. Uw build kan worden verbroken. Een nieuwere versie of functie van het NuGet-hulpprogramma wordt bijvoorbeeld geleverd met de SDK, kan uw build verbreken. Als u dit probleem wilt isoleren, gebruikt u de taak .NET Core Tool Installer om de versie op te geven van de .NET Core SDK die in uw build wordt gebruikt.

Veelgestelde vragen

V: Waar vind ik meer informatie over Azure Artifacts?

A: Pakketbeheer in Azure Artifacts

V: Waar vind ik meer informatie over .NET Core-opdrachten?

A: .NET Core CLI-hulpprogramma's

V: Waar vind ik meer informatie over het uitvoeren van tests in mijn oplossing?

A: Eenheidstests in .NET Core-projecten

V: Waar vind ik meer informatie over taken?

A: Build- en releasetaken