.NET-apps publiceren met de .NET CLI

Artikel
11/19/2023

In dit artikel ziet u hoe u uw .NET-toepassing vanaf de opdrachtregel kunt publiceren. .NET biedt drie manieren om uw toepassingen te publiceren. Frameworkafhankelijke implementatie produceert een platformoverschrijdend .dll-bestand dat gebruikmaakt van de lokaal geïnstalleerde .NET-runtime. Frameworkafhankelijk uitvoerbaar bestand produceert een platformspecifiek uitvoerbaar bestand dat gebruikmaakt van de lokaal geïnstalleerde .NET-runtime. Zelfstandig uitvoerbaar bestand produceert een platformspecifiek uitvoerbaar bestand en bevat een lokale kopie van de .NET-runtime.

Zie .NET-toepassingsimplementatie voor een overzicht van deze publicatiemodi.

Bent u op zoek naar snelle hulp bij het gebruik van de CLI? In de volgende tabel ziet u enkele voorbeelden van het publiceren van uw app. U kunt het doelframework opgeven met de -f <TFM> parameter of door het projectbestand te bewerken. Zie De basisprincipes van publiceren voor meer informatie.

Publicatiemodus	Opdracht
Frameworkafhankelijke implementatie	`dotnet publish -c Release -p:UseAppHost=false`
Frameworkafhankelijk uitvoerbaar bestand	`dotnet publish -c Release -r <RID> --self-contained false` `dotnet publish -c Release`
Zelfstandige implementatie	`dotnet publish -c Release -r <RID> --self-contained true`

Notitie

De -c Release parameter is niet vereist. Het wordt geleverd als herinnering voor het publiceren van de release-build van uw app.
In .NET SDK 3.1 of hoger is frameworkafhankelijk uitvoerbaar bestand de standaardpublicatiemodus bij het uitvoeren van de basisopdracht dotnet publish .

Basisbeginselen van publiceren

Met de <TargetFramework> instelling van het projectbestand wordt het standaarddoelframework opgegeven wanneer u uw app publiceert. U kunt het doelframework wijzigen in elke geldige Target Framework Moniker (TFM). Als uw project bijvoorbeeld gebruikt <TargetFramework>net8.0</TargetFramework>, wordt er een binair bestand gemaakt dat is gericht op .NET 8. De TFM die in deze instelling is opgegeven, is het standaarddoel dat door de dotnet publish opdracht wordt gebruikt.

Als u meer dan één framework wilt toepassen, kunt u de <TargetFrameworks> instelling instellen op meerdere TFM-waarden, gescheiden door een puntkomma. Wanneer u uw app bouwt, wordt er een build geproduceerd voor elk doelframework. Wanneer u uw app publiceert, moet u echter het doelframework opgeven met de dotnet publish -f <TFM> opdracht.

De standaardMODUS BUILD-CONFIGURATION is Foutopsporing , tenzij deze is gewijzigd met de -c parameter.

De standaarduitvoermap van de dotnet publish opdracht is ./bin/<BUILD-CONFIGURATION>/<TFM>/publish/. Publiceert bijvoorbeeld dotnet publish -c Release -f net8.0 naar ./bin/Release/net8.0/publish/. U kunt echter kiezen voor een vereenvoudigd uitvoerpad en een mapstructuur voor alle build-uitvoer. Zie de indeling Artefacten-uitvoer voor meer informatie.

Systeemeigen afhankelijkheden

Als uw app systeemeigen afhankelijkheden heeft, wordt deze mogelijk niet uitgevoerd op een ander besturingssysteem. Als uw app bijvoorbeeld gebruikmaakt van de systeemeigen Windows-API, wordt deze niet uitgevoerd op macOS of Linux. U moet platformspecifieke code opgeven en een uitvoerbaar bestand compileren voor elk platform.

Houd er ook rekening mee dat als een bibliotheek waarnaar u verwijst een systeemeigen afhankelijkheid heeft, uw app mogelijk niet op elk platform wordt uitgevoerd. Het is echter mogelijk dat een NuGet-pakket waarnaar u verwijst platformspecifieke versies bevat om de vereiste systeemeigen afhankelijkheden voor u te verwerken.

Wanneer u een app distribueert met systeemeigen afhankelijkheden, moet u mogelijk de dotnet publish -r <RID> switch gebruiken om het doelplatform op te geven waarvoor u wilt publiceren. Zie de rid-catalogus (Runtime Identifier) voor een lijst met runtime-id's.

Meer informatie over platformspecifieke binaire bestanden vindt u in de secties Voor het framework afhankelijke uitvoerbare bestanden en zelfstandige implementaties .

Voorbeeld-app

U kunt de volgende app gebruiken om de publicatieopdrachten te verkennen. De app wordt gemaakt door de volgende opdrachten uit te voeren in uw terminal:

mkdir apptest1
cd apptest1
dotnet new console
dotnet add package Figgle

Het Program.cs bestand dat Program.vb door de consolesjabloon wordt gegenereerd, moet worden gewijzigd in het volgende:

using System;

namespace apptest1
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine(Figgle.FiggleFonts.Standard.Render("Hello, World!"));
        }
    }
}

Module Program
    Sub Main(args As String())
        Console.WriteLine(Figgle.FiggleFonts.Standard.Render("Hello, World!"))
    End Sub
End Module

Wanneer u de app uitvoert (dotnet run), wordt de volgende uitvoer weergegeven:

  _   _      _ _         __        __         _     _ _
 | | | | ___| | | ___    \ \      / /__  _ __| | __| | |
 | |_| |/ _ \ | |/ _ \    \ \ /\ / / _ \| '__| |/ _` | |
 |  _  |  __/ | | (_) |    \ V  V / (_) | |  | | (_| |_|
 |_| |_|\___|_|_|\___( )    \_/\_/ \___/|_|  |_|\__,_(_)
                     |/

Frameworkafhankelijke implementatie

Wanneer u uw app publiceert als een FDD, wordt er een <PROJECT-NAME>.dll bestand in de ./bin/<BUILD-CONFIGURATION>/<TFM>/publish/ map gemaakt. Als u uw app wilt uitvoeren, gaat u naar de uitvoermap en gebruikt u de dotnet <PROJECT-NAME>.dll opdracht.

Uw app is geconfigureerd voor een specifieke versie van .NET. Deze beoogde .NET-runtime moet zich bevinden op elke computer waarop uw app wordt uitgevoerd. Als uw app bijvoorbeeld is gericht op .NET Core 8, moet op elke computer waarop uw app wordt uitgevoerd, de .NET Core 8-runtime zijn geïnstalleerd. Zoals aangegeven in de sectie Basisbeginselen publiceren, kunt u het projectbestand bewerken om het standaarddoelframework te wijzigen of om meer dan één framework te gebruiken.

Als u een FDD publiceert, wordt er een app gemaakt die automatisch wordt doorgestuurd naar de nieuwste .NET-beveiligingspatch die beschikbaar is op het systeem waarop de app wordt uitgevoerd. Zie De .NET-versie selecteren die u wilt gebruiken voor meer informatie over versiebinding tijdens het compileren.

Publicatiemodus	Opdracht
Frameworkafhankelijke implementatie	`dotnet publish -c Release -p:UseAppHost=false`

Frameworkafhankelijk uitvoerbaar bestand

Frameworkafhankelijk uitvoerbaar bestand (FDE) is de standaardmodus voor de basisopdracht dotnet publish . U hoeft geen andere parameters op te geven, zolang u het huidige besturingssysteem wilt instellen.

In deze modus wordt een platformspecifieke uitvoerbare host gemaakt om uw platformoverschrijdende app te hosten. Deze modus is vergelijkbaar met FDD, omdat FDD een host in de vorm van de dotnet opdracht vereist. De bestandsnaam van het uitvoerbare hostbestand verschilt per platform en heeft een naam die vergelijkbaar is met <PROJECT-FILE>.exe. U kunt dit uitvoerbare bestand rechtstreeks uitvoeren in plaats van aanroepen dotnet <PROJECT-FILE>.dll. Dit is nog steeds een acceptabele manier om de app uit te voeren.

Uw app is geconfigureerd voor een specifieke versie van .NET. Deze beoogde .NET-runtime moet zich bevinden op elke computer waarop uw app wordt uitgevoerd. Als uw app bijvoorbeeld is gericht op .NET 8, moet op elke computer waarop uw app wordt uitgevoerd, de .NET 8-runtime zijn geïnstalleerd. Zoals aangegeven in de sectie Basisbeginselen publiceren, kunt u het projectbestand bewerken om het standaarddoelframework te wijzigen of om meer dan één framework te gebruiken.

Als u een FDE publiceert, wordt er een app gemaakt die automatisch wordt doorgestuurd naar de nieuwste .NET-beveiligingspatch die beschikbaar is op het systeem waarop de app wordt uitgevoerd. Zie De .NET-versie selecteren die u wilt gebruiken voor meer informatie over versiebinding tijdens het compileren.

Publicatiemodus	Opdracht
Frameworkafhankelijk uitvoerbaar bestand	`dotnet publish -c Release -r <RID> --self-contained false` `dotnet publish -c Release`

Wanneer u de -r schakeloptie gebruikt, wordt het pad naar de uitvoermap gewijzigd in: ./bin/<BUILD-CONFIGURATION>/<TFM>/<RID>/publish/

Als u de voorbeeld-app gebruikt, voert u het volgende uit dotnet publish -f net6.0 -r win-x64 --self-contained false. Met deze opdracht maakt u het volgende uitvoerbare bestand: ./bin/Debug/net6.0/win-x64/publish/apptest1.exe

Notitie

U kunt de totale grootte van uw implementatie verkleinen door de invariante modus voor globalisatie in te schakelen. Deze modus is handig voor toepassingen die niet globaal op de hoogte zijn en die de opmaakconventies, casingconventies en tekenreeksvergelijking en sorteervolgorde van de invariante cultuur kunnen gebruiken. Zie de .NET Globalization Invariant-modus voor meer informatie over de invariante modus voor globalisatie en hoe u deze inschakelt.

Zelfstandige implementatie

Wanneer u een zelfstandige implementatie (SCD) publiceert, maakt de .NET SDK een platformspecifiek uitvoerbaar bestand. Het publiceren van een SCD bevat alle vereiste .NET-bestanden om uw app uit te voeren, maar bevat geen systeemeigen afhankelijkheden van .NET (bijvoorbeeld voor .NET 6 op Linux of .NET 8 op Linux). Deze afhankelijkheden moeten aanwezig zijn op het systeem voordat de app wordt uitgevoerd.

Als u een SCD publiceert, wordt er een app gemaakt die niet wordt doorgestuurd naar de nieuwste beschikbare .NET-beveiligingspatch. Zie De .NET-versie selecteren die u wilt gebruiken voor meer informatie over versiebinding tijdens het compileren.

U moet de volgende schakelopties gebruiken met de dotnet publish opdracht om een SCD te publiceren:

-r <RID>

Deze switch maakt gebruik van een id (RID) om het doelplatform op te geven. Zie de rid-catalogus (Runtime Identifier) voor een lijst met runtime-id's.
--self-contained true

Deze schakeloptie vertelt de .NET SDK om een uitvoerbaar bestand als SCD te maken.

Publicatiemodus	Opdracht
Zelfstandige implementatie	`dotnet publish -c Release -r <RID> --self-contained true`

Tip

In .NET 6 en latere versies kunt u de totale grootte van compatibele zelf-ingesloten apps verkleinen door ingekort te publiceren. Hierdoor kan de trimmer delen van het framework en assembly's waarnaar wordt verwezen, verwijderen die zich niet op een codepad bevinden of waarnaar mogelijk wordt verwezen in runtime-reflectie. Bekijk incompatibiliteit bij het bijsnijden om te bepalen of bijsnijden zinvol is voor uw toepassing.
U kunt de totale grootte van uw implementatie verkleinen door de invariante modus voor globalisatie in te schakelen. Deze modus is handig voor toepassingen die niet globaal op de hoogte zijn en die de opmaakconventies, casingconventies en tekenreeksvergelijking en sorteervolgorde van de invariante cultuur kunnen gebruiken. Zie de .NET Core Globalization Invariant-modus voor meer informatie over de invariante modus voor globalisatie en hoe u deze inschakelt.