Konfigurera kontinuerlig integrering för din WinUI-app

Du kan använda GitHub Actions för att konfigurera kontinuerliga integreringsversioner för WinUI-projekt. I den här artikeln ska vi titta på olika sätt att göra detta. Vi visar också hur du utför dessa uppgifter med hjälp av kommandoraden så att du kan integrera med andra byggsystem.

Förutsättningar

Börja med en enkelprojekt MSIX WinUI-app eller migrera ditt projekt för att använda enkelprojekt MSIX.
Registrera dig för GitHub och skapa en lagringsplats om du inte redan har gjort det.

Steg 1: Konfigurera certifikatet

MSIX-appar måste vara signerade för att kunna installeras. Om du redan har ett certifikat kan du hoppa över det här steget. Du kan enkelt skapa ett testcertifikat genom att öppna appen i Visual Studio, högerklicka på ditt WinUI-projekt och välja Paket och Publicera ->Skapa apppaket.

Välj sedan Nästa för att gå till sidan Välj signeringsmetod och klicka på knappen Skapa... för att skapa ett nytt certifikat. Välj utgivarens namn och lämna lösenordsfältet tomt och skapa certifikatet.

Stäng/avbryt sedan dialogrutorna och observera att en ny .pfx-fil har skapats i projektet. Det här är certifikatet som du kan signera MSIX med!

Steg 2: Lägg till certifikatet i actionshemligheterna

Du bör undvika att skicka certifikat till lagringsplatsen om det är möjligt, och git ignorerar dem som standard. För att säkert hantera känsliga filer som certifikat stöder GitHub konfidentiell data.

Så här laddar du upp ett certifikat för den automatiserade versionen:

Koda certifikatet som en Base 64-sträng: Öppna PowerShell till katalogen som innehåller certifikatet och kör följande kommando och ersätt pfx-filnamnet med certifikatets filnamn.

$pfx_cert = Get-Content 'App1_TemporaryKey.pfx' -AsByteStream

[System.Convert]::ToBase64String($pfx_cert) | Out-File 'App1_TemporaryKey_Base64.txt'

På din GitHub-lagringsplats går du till sidan Inställningar och klickar på Hemligheter till vänster.
Klicka på Ny förvaringshemlighet, ge den namnet BASE64_ENCODED_PFXoch kopiera och klistra in texten från textfilen i PowerShell-utdata till det hemliga värdet.

Steg 3: Konfigurera arbetsflödet

Gå sedan till fliken Åtgärder på lagringsplatsen och skapa ett nytt arbetsflöde. Välj alternativet konfigurera ett arbetsflöde själv istället för en av arbetsflödesmallarna.

Kopiera/klistra in följande i arbetsflödesfilen och uppdatera sedan...

Solution_Name till namnet på din lösning
dotnet-version till 8.0.x (eller vilken .NET-version projektet riktar sig mot)

Anmärkning

För steget som laddar upp artefakten (det sista steget nedan) om byggutdata inte hamnar i en mapp som innehåller din lösning ersätter env.Solution_Name du med github.workspace (mappen GitHub actions Workspace).

# This workflow will build, sign, and package a WinUI MSIX desktop application
# built on .NET.

name: WinUI MSIX app

on:
  push:
    branches: [ main ]
  pull_request:
    branches: [ main ]

jobs:

  build:

    strategy:
      matrix:
        configuration: [Release]
        platform: [x64, x86]

    runs-on: windows-latest  # For a list of available runner types, refer to
                             # https://help.github.com/en/actions/reference/workflow-syntax-for-github-actions#jobsjob_idruns-on

    env:
      Solution_Name: your-solution-name                         # Replace with your solution name, i.e. App1.sln.

    steps:
    - name: Checkout
      uses: actions/checkout@v4
      with:
        fetch-depth: 0

    # Install the .NET workload
    - name: Install .NET
      uses: actions/setup-dotnet@v4
      with:
        dotnet-version: 8.0.x

    # Add  MSBuild to the PATH: https://github.com/microsoft/setup-msbuild
    - name: Setup MSBuild.exe
      uses: microsoft/setup-msbuild@v2

    # Restore the application to populate the obj folder with RuntimeIdentifiers
    - name: Restore the application
      run: msbuild $env:Solution_Name /t:Restore /p:Configuration=$env:Configuration
      env:
        Configuration: ${{ matrix.configuration }}

    # Decode the base 64 encoded pfx and save the Signing_Certificate
    - name: Decode the pfx
      run: |
        $pfx_cert_byte = [System.Convert]::FromBase64String("${{ secrets.BASE64_ENCODED_PFX }}")
        $certificatePath = "GitHubActionsWorkflow.pfx"
        [IO.File]::WriteAllBytes("$certificatePath", $pfx_cert_byte)

    # Create the app package by building and packaging the project
    - name: Create the app package
      run: msbuild $env:Solution_Name /p:Configuration=$env:Configuration /p:Platform=$env:Platform /p:UapAppxPackageBuildMode=$env:Appx_Package_Build_Mode /p:AppxBundle=$env:Appx_Bundle /p:PackageCertificateKeyFile=GitHubActionsWorkflow.pfx /p:AppxPackageDir="$env:Appx_Package_Dir" /p:GenerateAppxPackageOnBuild=true
      env:
        Appx_Bundle: Never
        Appx_Package_Build_Mode: SideloadOnly
        Appx_Package_Dir: Packages\
        Configuration: ${{ matrix.configuration }}
        Platform: ${{ matrix.platform }}

    # Remove the pfx
    - name: Remove the pfx
      run: Remove-Item -path GitHubActionsWorkflow.pfx

    # Upload the MSIX package: https://github.com/marketplace/actions/upload-a-build-artifact
    - name: Upload MSIX package
      uses: actions/upload-artifact@v4
      with:
        name: MSIX Package - ${{ matrix.platform }}
        path: ${{ env.Solution_Name }}\\Packages

Steg 4: Checka in arbetsflödet och se det köras!

Kommittera arbetsflödesfilen till din huvudgren och gå sedan till fliken Åtgärder i ditt GitHub-repository och se ditt arbetsflöde köras! Den ska köras framgångsrikt och producera artefakter som innehåller din byggda MSIX-app.

Skapa från kommandoraden

Om du vill skapa din lösning med hjälp av kommandoraden eller genom att använda något annat CI-system kör du MSBuild med dessa argument. Egenskapen GenerateAppxPackageOnBuild gör att MSIX-paketet genereras.

/p:AppxPackageDir="Packages"
/p:UapAppxPackageBuildMode=SideloadOnly
/p:AppxBundle=Never
/p:GenerateAppxPackageOnBuild=true

Steg 1: Konfigurera arbetsflödet

På din GitHub-lagringsplats går du till fliken Åtgärder och skapar ett nytt arbetsflöde. Välj alternativet konfigurera ett arbetsflöde själv istället för en av arbetsflödesmallarna.

Kopiera/klistra in följande i arbetsflödesfilen och uppdatera sedan...

Solution_Name till namnet på din lösning
dotnet-version till 8.0.x (eller vilken .NET-version projektet riktar sig till)

Anmärkning

# This workflow will build and publish a WinUI unpackaged desktop application
# built on .NET.

name: WinUI unpackaged app

on:
  push:
    branches: [ main ]
  pull_request:
    branches: [ main ]

jobs:

  build:

    strategy:
      matrix:
        configuration: [Release]
        platform: [x64, x86]

    runs-on: windows-latest  # For a list of available runner types, refer to
                             # https://help.github.com/en/actions/reference/workflow-syntax-for-github-actions#jobsjob_idruns-on

    env:
      Solution_Name: your-solution-name                         # Replace with your solution name, i.e. App1.sln.

    steps:
    - name: Checkout
      uses: actions/checkout@v4
      with:
        fetch-depth: 0

    # Install the .NET workload
    - name: Install .NET
      uses: actions/setup-dotnet@v4
      with:
        dotnet-version: 8.0.x

    # Add  MSBuild to the PATH: https://github.com/microsoft/setup-msbuild
    - name: Setup MSBuild.exe
      uses: microsoft/setup-msbuild@v2

    # Restore the application to populate the obj folder with RuntimeIdentifiers
    - name: Restore the application
      run: msbuild $env:Solution_Name /t:Restore /p:Configuration=$env:Configuration
      env:
        Configuration: ${{ matrix.configuration }}

    # Create the app by building and publishing the project
    - name: Create the app
      run: msbuild $env:Solution_Name /t:Publish /p:Configuration=$env:Configuration /p:Platform=$env:Platform
      env:
        Configuration: ${{ matrix.configuration }}
        Platform: ${{ matrix.platform }}

    # Upload the app
    - name: Upload app
      uses: actions/upload-artifact@v4
      with:
        name: Upload app - ${{ matrix.platform }}
        path: ${{ env.Solution_Name }}\\bin

Steg 2: Kommittera arbetsflödet och se det köras!

Kommittera arbetsflödesfilen till din huvudgren och gå sedan till fliken Åtgärder i ditt GitHub-repository och se ditt arbetsflöde köras! Den ska framgångsrikt köras och producera artefakter som innehåller din byggda app.

Skapa från kommandoraden

Om du vill skapa din lösning med hjälp av kommandoraden eller genom att använda något annat CI-system kör du MSBuild med /t:Publish argumentet .

Azure-pipelines

Om ditt team använder Azure DevOps kan du skapa WinUI 3-appar med Azure-pipelines. Följande YAML-pipeline skapar en paketerad MSIX WinUI-app på en Windows-agent:

trigger:
  - main

pool:
  vmImage: 'windows-latest'

variables:
  solution: '**/*.sln'
  buildPlatform: 'x64'
  buildConfiguration: 'Release'

steps:
- task: UseDotNet@2
  displayName: 'Install .NET SDK'
  inputs:
    packageType: 'sdk'
    version: '8.0.x'

- task: NuGetToolInstaller@1

- task: NuGetCommand@2
  inputs:
    restoreSolution: '$(solution)'

- task: VSBuild@1
  displayName: 'Build MSIX package'
  inputs:
    solution: '$(solution)'
    platform: '$(buildPlatform)'
    configuration: '$(buildConfiguration)'
    msbuildArgs: |
      /p:AppxBundlePlatforms="$(buildPlatform)"
      /p:AppxPackageDir="$(Build.ArtifactStagingDirectory)\AppxPackages\\"
      /p:AppxBundle=Never
      /p:UapAppxPackageBuildMode=SideloadOnly
      /p:GenerateAppInstallerFile=false

- task: PublishBuildArtifacts@1
  displayName: 'Publish MSIX artifacts'
  inputs:
    PathtoPublish: '$(Build.ArtifactStagingDirectory)\AppxPackages'
    ArtifactName: 'msix-package'

Anmärkning

För opaketerade versioner tar du bort MSBuild-argumenten /p:Appx* och använder dotnet publish i stället för VSBuild. Mer information finns i kommandoradsavsnittet ovan.

Om du vill signera MSIX-paket i en pipeline lagrar du certifikatet i Azure-pipelines säkra filer och använder uppgiften DownloadSecureFile för att komma åt det under bygget.

Important

Lagra aldrig signeringscertifikat eller deras lösenord i källkontrollen. Använd pipelinehemlighetsvariabler för certifikatlösenordet och Azure-pipelines Säkra filer för själva certifikatet.

Feedback

Var den här sidan till hjälp?

Last updated on 2026-07-22

Konfigurera kontinuerlig integrering för din WinUI-app

Förutsättningar

Steg 1: Konfigurera certifikatet

Steg 2: Lägg till certifikatet i actionshemligheterna

Steg 3: Konfigurera arbetsflödet

Steg 4: Checka in arbetsflödet och se det köras!

Skapa från kommandoraden

Steg 1: Konfigurera arbetsflödet

Steg 2: Kommittera arbetsflödet och se det köras!

Skapa från kommandoraden

Azure-pipelines

Feedback

Ytterligare resurser