Bygg, testa och distribuera .NET Core-appar

Azure DevOps Services | Azure DevOps Server 2022 – Azure DevOps Server 2019

Använd en Azure Pipeline för att automatiskt skapa, testa och distribuera dina .NET Core-projekt. Den här artikeln visar hur du utför följande uppgifter:

Förutsättningar

Skapa din första pipeline

Är du nybörjare på Azure Pipelines? I så fall rekommenderar vi att du provar följande avsnitt först.

Skapa ett .NET-projekt

Om du inte har något .NET-projekt att arbeta med skapar du ett nytt i det lokala systemet. Börja med att installera den senaste .NET 8.0 SDK .

1. Öppna ett terminalfönster.

2. Skapa en projektkatalog och navigera till den.

3. Skapa en ny .NET 8-webbapp.

   dotnet new webapp -f net8.0
   

4. Från samma terminalsession kör du programmet lokalt med kommandot från projektkatalogen dotnet run .

   dotnet run
   

5. När programmet har startat trycker du på Ctrl-C för att stänga av det.

Skapa en git-lagringsplats och anslut den till GitHub

1. Från projektkatalogen skapar du en lokal git-lagringsplats och checkar in programkoden till huvudgrenen.

2. Anslut din lokala Git-lagringsplats till en GitHub-lagringsplats.

Skapa ett DevOps-projekt

Konfigurera din byggmiljö

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

Skapa din pipeline

Du kan använda YAML-pipelineredigeraren eller den klassiska redigeraren för att skapa din pipeline. Om du vill använda den klassiska redigeraren väljer du Använd den klassiska redigeraren.

Nu har du en fungerande pipeline som du kan anpassa! Läs vidare för att lära dig några av de vanliga sätten att anpassa din pipeline.

Skapa miljö

pool:
  name: myPrivateAgents
  demands:
  - agent.os -equals Darwin
  - anotherCapability -equals somethingElse

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

pool:
  vmImage: 'ubuntu-latest' 

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

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

Återställa beroenden

NuGet är ett populärt sätt att vara beroende av kod som du inte skapar. Du kan ladda ned NuGet-paket och projektspecifika verktyg som anges i projektfilen genom att köra dotnet restore kommandot antingen via .NET Core-aktiviteten eller direkt i ett skript i pipelinen. Mer information finns i .NET Core-uppgift (DotNetCoreCLI@2).

Du kan ladda ned NuGet-paket från Azure Artifacts, NuGet.org eller någon annan extern eller intern NuGet-lagringsplats. . NET Core-uppgiften är särskilt användbar för att återställa paket från autentiserade NuGet-feeds. Om feeden finns i samma projekt som pipelinen behöver du inte autentisera.

Den här pipelinen använder en Azure Artifact-feed för dotnet restore i den DotNetCoreCLI@2 uppgiften.

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

Kommandot dotnet restore använder det NuGet.exe paketerade med .NET Core SDK och kan bara återställa paket som anges i .NET Core-projektfilerna .csproj .

Om du också har ett Microsoft .NET Framework-projekt i din lösning eller använder package.json för att ange dina beroenden använder du NuGet-uppgiften för att återställa dessa beroenden.

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

I .NET Core SDK version 2.0 och senare återställs paket automatiskt när du kör kommandon som dotnet build. Du skulle dock fortfarande behöva använda .NET Core-uppgiften för att återställa paket om du använder en autentiserad feed.

Dina versioner kan misslyckas på grund av anslutningsproblem när du återställer paket från NuGet.org. Du kan använda Azure Artifacts med överordnade källor för att cachelagrar paketen. Autentiseringsuppgifterna för pipelinen används automatiskt när den ansluter till Azure Artifacts. Dessa autentiseringsuppgifter härleds vanligtvis från Project Collection Build Service-kontot . Mer information om hur du använder Azure Artifacts för att cachelagrar dina NuGet-paket finns i Ansluta till Azure Artifact-feeds.

Om du vill ange en NuGet-lagringsplats placerar du URL:en i en NuGet.config fil på lagringsplatsen. Om ditt flöde autentiseras hanterar du autentiseringsuppgifterna genom att skapa en NuGet-tjänstanslutning på fliken Tjänster under Projektinställningar.

Mer information om NuGet-tjänstanslutningar finns i publicera till NuGet-feeds.

Återställa paket från en extern feed

Gör följande för att återställa paket från en extern feed.

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

Skapa projektet

Skapa dina .NET Core-projekt genom att dotnet build köra kommandot . Du kan lägga till kommandot i pipelinen som ett kommandoradsskript eller med hjälp av .NET Core-uppgiften.

.NET Core-kompilering med hjälp av .NET Core-uppgiften

YAML-exempel för att skapa med hjälp av DotNetCoreCLI@2 uppgift:

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

.NET Core-version med kommandoradsskript

YAML-exempel för att skapa med ett dotnet build skript:

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

Lägga till .NET SDK-kommandon i pipelinen

Du kan lägga till .NET SDK-kommandon i projektet som ett skript eller med hjälp av .NET Core-aktiviteten. Med .NET Core-aktiviteten (DotNetCoreCLI@2) kan du enkelt lägga till CLI-kommandon för dotnet i pipelinen. Du kan lägga till .NET Core-uppgifter genom att redigera YAML-filen eller med den klassiska redigeraren.

Lägg till ett .NET CLI-kommando med hjälp av .NET Core-uppgiften

Lägga till ett .NET Core CLI-kommando med hjälp av ett skript

Du kan lägga till .NET Core CLI-kommandon som en script i azure-pipelines.yml filen.

Exempel:

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

Installera ett verktyg

Utför följande steg för att installera ett globalt .NET Core-verktyg som dotnetsay i din version som körs i Windows:

1. Lägg till .NET Core-aktiviteten och ange följande egenskaper:
   • Kommando: anpassad.
     • Sökväg till projekt: lämna tom.
   • Anpassat kommando: verktyg.
   • Argument: install -g dotnetsay.
2. Om du vill köra verktyget lägger du till en kommandorad och anger följande egenskaper:
   • Skript: dotnetsay.

Kör dina tester

När du har testprojekt på lagringsplatsen kan du använda .NET Core-uppgiften för att köra enhetstester med hjälp av testramverk som MSTest, xUnit och NUnit. Testprojektet måste referera till Microsoft.NET.Test.SDK version 15.8.0 eller senare. Testresultat publiceras automatiskt till tjänsten. Dessa resultat är tillgängliga för dig i byggsammanfattningen och kan användas för felsökning av misslyckade tester och analys av testtid.

Du kan lägga till en testaktivitet i pipelinen med hjälp av DotNetCoreCLI@2 uppgift eller lägga till följande kodfragment i azure-pipelines.yml filen:

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

När du använder .NET Core-aktivitetsredigeraren anger du Kommando för att testa och Sökväg till projekt bör referera till testprojekten i din lösning.

Du kan också köra dotnet test kommandot med en specifik logger och sedan använda uppgiften Publicera testresultat :

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'

Samla in kodtäckning

När du skapar på Windows-plattformen kan kodtäckningsmått samlas in med hjälp av den inbyggda datainsamlaren för täckning. Testprojektet måste referera till Microsoft.NET.Test.SDK version 15.8.0 eller senare.

När du använder .NET Core-uppgiften för att köra tester publiceras täckningsdata automatiskt till servern. Filen .coverage kan laddas ned från byggsammanfattningen för visning i Visual Studio.

Lägg till följande kodfragment i azure-pipelines.yml filen:

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

Så här lägger du till .NET Core-aktiviteten via uppgiftsredigeraren:

1. Lägg till .NET Core-aktiviteten i byggjobbet och ange följande egenskaper:

   1. Kommando: test.
   2. Sökväg till projekt: Bör referera till testprojekten i din lösning.
   3. Argument: --configuration $(BuildConfiguration) --collect "Code coverage".

2. Kontrollera att alternativet Publicera testresultat förblir markerat.

Om du väljer att köra dotnet test kommandot anger du loggnings- och täckningsalternativen för testresultat. Använd sedan uppgiften Publicera testresultat :

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'

Samla in kodtäckningsmått med Coverlet

Om du bygger på Linux eller macOS kan du använda Coverlet eller ett liknande verktyg för att samla in kodtäckningsmått.

Du kan publicera kodtäckningsresultat till servern med uppgiften Publicera kodtäckningsresultat (PublishCodeCoverageResults@1). Täckningsverktyget måste konfigureras för att generera resultat i Cobertura- eller JaCoCo-täckningsformat.

Utför följande uppgifter för att köra tester och publicera kodtäckning med Coverlet:

• Lägg till en referens till coverlet.collector NuGet-paketet.

• Lägg till följande kodfragment i azure-pipelines.yml filen:

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

Paketera och leverera din kod

Du kan publicera dina byggartefakter genom att:

• Publicera till Azure Pipelines.
• Publicera paket till Azure Artifacts.
• Skapa ett NuGet-paket och publicera till din NuGet-feed.
• Skapa ett .zip arkiv för att distribuera webbappen.

Publicera artefakter till Azure Pipelines

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'

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: PublishBuildArtifacts@1
  inputs:
    PathtoPublish: '$(Build.ArtifactStagingDirectory)'
    ArtifactName: 'drop'

Publicera till en NuGet-feed

Om du vill skapa ett NuGet-paket och publicera det i Din NuGet-feed lägger du till följande kodfragment:

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

Mer information om versionshantering och publicering av NuGet-paket finns i Publicera till NuGet-feeds.

Publicera ett NuGet-paket till Azure Artifacts

Du kan publicera dina NuGet-paket i Azure Artifacts-flödet med hjälp av NuGetCommand@2 för att skicka till Azure Artifact-flödet. Se till exempel Publicera NuGet-paket med Azure Pipelines.

Distribuera en webbapp

Om du vill skapa ett .zip filarkiv som är redo att publiceras i en webbapp lägger du till följande kodfragment:

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

Information om hur du publicerar det här arkivet till en webbapp finns i Distribution av Azure Web Apps.

Skapa en avbildning och skicka till containerregistret

Du kan också skapa en avbildning för din app och skicka den till ett containerregister.

Publicera symboler

Du kan använda PublishSymbols@2 uppgift för att publicera symboler till en Azure Artifacts-symbolserver eller en filresurs.

Om du till exempel vill publicera symboler till en filresurs lägger du till följande kodfragment i azure-pipelines.yml filen:

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

När du använder den klassiska redigeraren väljer du Indexkällor publicera symboler från aktivitetskatalogen för att lägga till i din pipeline.

Mer information finns i Publicera symboler.

Felsöka

Om du kan skapa projektet på utvecklingsdatorn, men du har problem med att skapa det i Azure Pipelines, kan du utforska följande potentiella orsaker och korrigerande åtgärder:

• Kontrollera .NET Core SDK-versionerna och körningen på utvecklingsdatorn och se till att de matchar agenten. Du kan inkludera ett kommandoradsskript dotnet --version i pipelinen för att skriva ut versionen av .NET Core SDK. Använd antingen installationsprogrammet för .NET Core-verktyget för att distribuera samma version på agenten eller uppdatera projekt- och utvecklingsdatorn till den nyare versionen av .NET Core SDK.

• Du kanske använder viss logik i Visual Studio IDE som inte är kodad i din pipeline. Azure Pipelines kör vart och ett av de kommandon som du anger i aktiviteterna en efter en i en ny process. Granska loggarna från pipelines-versionen för att se de exakta kommandon som kördes som en del av bygget. Upprepa samma kommandon i samma ordning på utvecklingsdatorn för att hitta problemet.

• Om du har en blandad lösning som innehåller vissa .NET Core-projekt och vissa .NET Framework-projekt bör du också använda NuGet-uppgiften för att återställa paket som anges i packages.config filer. Lägg till uppgiften MSBuild eller Visual Studio Build för att skapa .NET Framework-projekten.

• Dina versioner kan misslyckas tillfälligt när du återställer paket: antingen NuGet.org har problem eller om det finns nätverksproblem mellan Azure-datacentret och NuGet.org. Du kan utforska om användning av Azure Artifacts med NuGet.org som uppströmskälla förbättrar tillförlitligheten för dina versioner, eftersom det inte finns i vår kontroll.

• Ibland, när en ny version av .NET Core SDK eller Visual Studio distribueras, kan bygget gå sönder. Till exempel levereras en nyare version eller funktion av NuGet-verktyget med SDK:n. Om du vill isolera det här problemet använder du .NET Core Tool Installer-uppgiften för att ange den version av .NET Core SDK som används i din version.

Vanliga frågor

F: Var kan jag lära mig mer om Azure Artifacts?

S: Pakethantering i Azure Artifacts

F: Var kan jag lära mig mer om .NET Core-kommandon?

S: .NET Core CLI-verktyg

F: Var kan jag lära mig mer om att köra tester i min lösning?

S: Enhetstestning i .NET Core-projekt

F: Var kan jag lära mig mer om uppgifter?

S: Bygg- och versionsaktiviteter