Publicera .NET-appar med .NET CLI
Den här artikeln visar hur du kan publicera .NET-programmet från kommandoraden. .NET tillhandahåller tre sätt att publicera dina program. En ramverksberoende distribution skapar en plattformsoberoende .dll fil som använder den lokalt installerade .NET-körningen. Ramverksberoende körbar fil skapar en plattformsspecifik körbar fil som använder den lokalt installerade .NET-körningen. Fristående körbar fil skapar en plattformsspecifik körbar fil och innehåller en lokal kopia av .NET-körningen.
En översikt över dessa publiceringslägen finns i .NET-programdistribution.
Vill du ha snabb hjälp med att använda CLI? I följande tabell visas några exempel på hur du publicerar din app. Du kan ange målramverket med parametern -f <TFM> eller genom att redigera projektfilen. Mer information finns i Grunderna för publicering.
| Publiceringsläge | Command |
|---|---|
| Ramverksberoende distribution | dotnet publish -c Release -p:UseAppHost=false |
| Ramverksberoende körbar fil | dotnet publish -c Release -r <RID> --self-contained falsedotnet publish -c Release |
| Fristående distribution | dotnet publish -c Release -r <RID> --self-contained true |
Kommentar
- Parametern
-c Releasekrävs inte. Det tillhandahålls som en påminnelse om att publicera versionen av din app. - I .NET SDK 3.1 eller senare är den ramverksberoende körbara filen standardpubliceringsläget när du kör det grundläggande
dotnet publishkommandot.
Grunderna för publicering
Inställningen <TargetFramework> för projektfilen anger standardmålramverket när du publicerar din app. Du kan ändra målramverket till valfri giltig Target Framework Moniker (TFM). Om ditt projekt till exempel använder <TargetFramework>net8.0</TargetFramework>skapas en binär fil som riktar sig mot .NET 8. TFM som anges i den här inställningen är standardmålet som används av dotnet publish kommandot.
Om du vill rikta in dig på fler än ett ramverk kan du ange <TargetFrameworks> inställningen till flera TFM-värden, avgränsade med ett semikolon. När du skapar din app skapas en version för varje målramverk. Men när du publicerar din app måste du ange målramverket med dotnet publish -f <TFM> kommandot .
Standardläget BUILD-CONFIGURATION är Felsökning om det inte har ändrats med parametern -c .
Standardutdatakatalogen för dotnet publish kommandot är ./bin/<BUILD-CONFIGURATION>/<TFM>/publish/. Till exempel dotnet publish -c Release -f net8.0 publicerar till ./bin/Release/net8.0/publish/. Du kan dock välja en förenklad utdatasökväg och mappstruktur för alla build-utdata. Mer information finns i Artefaktutdatalayout.
Inbyggda beroenden
Om din app har inbyggda beroenden kanske den inte körs på ett annat operativsystem. Om din app till exempel använder det interna Windows-API:et körs den inte på macOS eller Linux. Du skulle behöva tillhandahålla plattformsspecifik kod och kompilera en körbar fil för varje plattform.
Tänk också på att om ett bibliotek som du refererade till har ett inbyggt beroende kanske din app inte körs på alla plattformar. Det är dock möjligt att ett NuGet-paket som du refererar till har inkluderat plattformsspecifika versioner för att hantera nödvändiga interna beroenden åt dig.
När du distribuerar en app med inbyggda beroenden kan du behöva använda växeln dotnet publish -r <RID> för att ange den målplattform som du vill publicera för. En lista över körningsidentifierare finns i RID-katalogen (Runtime Identifier).
Mer information om plattformsspecifika binärfiler finns i avsnitten Framework-beroende körbar och fristående distribution .
Exempelapp
Du kan använda följande app för att utforska publiceringskommandona. Appen skapas genom att köra följande kommandon i terminalen:
mkdir apptest1
cd apptest1
dotnet new console
dotnet add package Figgle
Filen Program.cs eller Program.vb som genereras av konsolmallen måste ändras till följande:
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
När du kör appen (dotnet run) visas följande utdata:
_ _ _ _ __ __ _ _ _
| | | | ___| | | ___ \ \ / /__ _ __| | __| | |
| |_| |/ _ \ | |/ _ \ \ \ /\ / / _ \| '__| |/ _` | |
| _ | __/ | | (_) | \ V V / (_) | | | | (_| |_|
|_| |_|\___|_|_|\___( ) \_/\_/ \___/|_| |_|\__,_(_)
|/
Ramverksberoende distribution
När du publicerar din app som en FDD skapas en <PROJECT-NAME>.dll fil i ./bin/<BUILD-CONFIGURATION>/<TFM>/publish/ mappen. Om du vill köra appen går du till utdatamappen och använder dotnet <PROJECT-NAME>.dll kommandot .
Appen är konfigurerad för att rikta in sig på en specifik version av .NET. Den riktade .NET-körningen måste finnas på alla datorer där appen körs. Om din app till exempel riktar in sig på .NET Core 8 måste alla datorer som appen körs på ha .NET Core 8-körningen installerad. Som du ser i avsnittet Grunderna för publicering kan du redigera din projektfil för att ändra standardmålramverket eller för att rikta in dig på mer än ett ramverk.
När du publicerar en FDD skapas en app som automatiskt överförs till den senaste .NET-säkerhetskorrigeringen som är tillgänglig i systemet som kör appen. Mer information om versionsbindning vid kompilering finns i Välj den .NET-version som ska användas.
| Publiceringsläge | Command |
|---|---|
| Ramverksberoende distribution | dotnet publish -c Release -p:UseAppHost=false |
Ramverksberoende körbar fil
Ramverksberoende körbar fil (FDE) är standardläget för det grundläggande dotnet publish kommandot. Du behöver inte ange några andra parametrar så länge du vill rikta in dig på det aktuella operativsystemet.
I det här läget skapas en plattformsspecifik körbar värd som värd för din plattformsoberoende app. Det här läget liknar FDD eftersom FDD kräver en värd i form av dotnet kommandot . Värdfilens körbara filnamn varierar per plattform och heter något som liknar <PROJECT-FILE>.exe. Du kan köra den här körbara filen direkt i stället för att anropa dotnet <PROJECT-FILE>.dll, vilket fortfarande är ett acceptabelt sätt att köra appen.
Appen är konfigurerad för att rikta in sig på en specifik version av .NET. Den riktade .NET-körningen måste finnas på alla datorer där appen körs. Om din app till exempel riktar in sig på .NET 8 måste alla datorer som appen körs på ha .NET 8-körningen installerad. Som du ser i avsnittet Grunderna för publicering kan du redigera din projektfil för att ändra standardmålramverket eller för att rikta in dig på mer än ett ramverk.
När du publicerar en FDE skapas en app som automatiskt överförs till den senaste .NET-säkerhetskorrigeringen som är tillgänglig i systemet som kör appen. Mer information om versionsbindning vid kompilering finns i Välj den .NET-version som ska användas.
| Publiceringsläge | Command |
|---|---|
| Ramverksberoende körbar fil | dotnet publish -c Release -r <RID> --self-contained falsedotnet publish -c Release |
När du använder växeln -r ändras sökvägen till utdatamappen till: ./bin/<BUILD-CONFIGURATION>/<TFM>/<RID>/publish/
Om du använder exempelappen kör du dotnet publish -f net6.0 -r win-x64 --self-contained false. Det här kommandot skapar följande körbara fil: ./bin/Debug/net6.0/win-x64/publish/apptest1.exe
Kommentar
Du kan minska den totala storleken på distributionen genom att aktivera globalisering i variant läge. Det här läget är användbart för program som inte är globalt medvetna och som kan använda formateringskonventioner, höljekonventioner och strängjämförelse och sorteringsordning för den invarianta kulturen. Mer information om globalisering ivariant läge och hur du aktiverar det finns i .NET Globalization Invariant Mode(.NET Globalization Invariant Mode).
Fristående distribution
När du publicerar en fristående distribution (SCD) skapar .NET SDK en plattformsspecifik körbar fil. Publicering av en SCD innehåller alla nödvändiga .NET-filer för att köra din app, men den innehåller inte de interna beroendena för .NET (till exempel för .NET 6 i Linux eller .NET 8 på Linux). Dessa beroenden måste finnas i systemet innan appen körs.
När du publicerar en SCD skapas en app som inte vidarekopplas till den senaste tillgängliga .NET-säkerhetskorrigeringen. Mer information om versionsbindning vid kompilering finns i Välj den .NET-version som ska användas.
Du måste använda följande växlar med dotnet publish kommandot för att publicera en SCD:
-r <RID>Den här växeln använder en identifierare (RID) för att ange målplattformen. En lista över körningsidentifierare finns i RID-katalogen (Runtime Identifier).
--self-contained trueDen här växeln instruerar .NET SDK att skapa en körbar fil som en SCD.
| Publiceringsläge | Command |
|---|---|
| Fristående distribution | dotnet publish -c Release -r <RID> --self-contained true |
Dricks
- I .NET 6 och senare versioner kan du minska den totala storleken på kompatibla fristående appar genom att publicera trimmade. Detta gör det möjligt för trimmern att ta bort delar av ramverket och refererade sammansättningar som inte finns på någon kodsökväg eller som potentiellt refereras i körningsreflektion. Se trimning av inkompatibiliteter för att avgöra om trimning är meningsfullt för ditt program.
- Du kan minska den totala storleken på distributionen genom att aktivera globalisering i variant läge. Det här läget är användbart för program som inte är globalt medvetna och som kan använda formateringskonventioner, höljekonventioner och strängjämförelse och sorteringsordning för den invarianta kulturen. Mer information om globalisering ivariant läge och hur du aktiverar det finns i .NET Core Globalization Invariant Mode(.NET Core Globalization Invariant Mode).
Se även
Feedback
Kommer snart: Under hela 2024 kommer vi att fasa ut GitHub-problem som feedbackmekanism för innehåll och ersätta det med ett nytt feedbacksystem. Mer information finns i: https://aka.ms/ContentUserFeedback.
Skicka och visa feedback för