Dela via

Översikt över publicering av .NET-program

  • Artikel

Program som du skapar med .NET kan publiceras i två olika lägen och läget påverkar hur en användare kör din app.

När du publicerar din app som fristående skapas ett program som innehåller .NET-runtime och -biblioteken samt ditt program och dess beroenden. Användare av programmet kan köra det på en dator som inte har .NET-körningen installerad.

När du publicerar appen som ramverksberoende skapas ett program som endast innehåller själva programmet och dess beroenden. Användare av programmet måste installera .NET-körtiden separat.

Båda publiceringslägena skapar en plattformsspecifik körbar fil som standard. Ramverksberoende program kan skapas utan körbara filer och dessa program är plattformsoberoende.

När en körbar fil skapas kan du ange målplattformen med en körningsidentifierare (RID). Mer information om RID finns i .NET RID Catalog.

I följande tabell beskrivs de kommandon som används för att publicera en app som ramverksberoende eller fristående:

Typ Befallning
ramverksberoende körbara för den aktuella plattformen. dotnet publish
ramverksberoende körbara för en specifik plattform. dotnet publish -r <RID>
ramverksberoende binära. dotnet publish
fristående körbar fil. dotnet publish -r <RID> --self-contained

Mer information finns i .NET dotnet publish-kommandot.

Skapa en körbar fil

Körbara filer är inte plattformoberoende, de är specifika för ett operativsystem och CPU-arkitektur. När du publicerar din app och skapar en körbar fil kan du publicera appen som fristående eller ramverksberoende. När du publicerar en app som fristående ingår .NET-körningen med appen, och användarna av appen behöver inte bekymra sig om att installera .NET innan de kör appen. Att publicera en app som ramverksberoende inkluderar inte .NET-körningen. endast appen och beroenden från tredje part ingår.

Följande kommandon skapar en körbar fil:

Typ Befallning
körbar fil som är beroende av ramverk för den aktuella plattformen. dotnet publish
körbara program beroende av ramverk för en specifik plattform. dotnet publish -r <RID>
fristående exekverbar fil. dotnet publish -r <RID> --self-contained

Skapa en plattformsoberoende binär

Plattformsoberoende binärfiler skapas när du publicerar din app som ramverksberoende, i form av en dll- fil. Filen dll namnges efter projektet. Om du till exempel har en app med namnet word_readerskapas en fil med namnet word_reader.dll. Appar som publiceras på det här sättet körs med kommandot dotnet <filename.dll> och kan köras på valfri plattform.

Plattformsoberoende binärfiler kan köras på valfritt operativsystem så länge den riktade .NET-körningen redan är installerad. Om den riktade .NET-körmiljön inte är installerad kan appen köras med en nyare körmiljö om appen är konfigurerad för att rullas framåt. Mer information finns i ramverksberoende appar.

Du kan välja att köra appen som en plattformsspecifik körbar fil eller som en plattformsoberoende binärfil via dotnet kommando. Det bör inte finnas någon skillnad i appbeteende när du startar den plattformsspecifika körbara filen jämfört med kommandot dotnet för vanliga serverappar som startas via en plattformsspecifik körbar fil ger bättre integrering med det underliggande operativsystemet. Till exempel:

Följande kommando genererar en plattformsoberoende binärfil:

Typ Befallning
ramverksberoende plattformskompatibla binära. dotnet publish

Publicera ramverksberoende

Appar som publiceras som ramverksberoende är kompatibla med flera plattformar och inkluderar inte .NET runtime. En användare av din app måste installera .NET-runtime.

Om du publicerar en app som ramverksberoende skapas en plattformoberoende binär som en dll-fil och en plattformsspecifik körbar fil som riktar sig till din aktuella plattform. dll- är plattformsoberoende medan den körbara filen inte är det. Om du till exempel publicerar en app med namnet word_reader och riktar dig mot Windows, skapas en körbar fil word_reader.exe tillsammans med word_reader.dll. Vid målinriktning på Linux eller macOS skapas en körbar fil word_reader tillsammans med word_reader.dll. Om appen använder ett NuGet-paket som har plattformsspecifika implementeringar kopieras beroenden för alla plattformar till publicera\runtimes\{platform} mapp.

Den plattformsoberoende binärfilen för din app kan köras med kommandot dotnet <filename.dll> och kan köras på valfri plattform.

Plattformsspecifik och ramverksberoende

Du kan publicera en ramverksberoende app som är plattformsspecifik genom att skicka parametrarna -r <RID> till kommandot dotnet publish. Publicering på det här sättet är detsamma som publicera ramverksberoende, förutom att plattformsspecifika beroenden hanteras på olika sätt. Om appen använder ett NuGet-paket som har plattformsspecifika implementeringar kopieras endast målplattformens beroenden. Dessa beroenden kopieras direkt till mappen publicera.

Tekniskt sett är den binära som produceras plattformskompatibel, men genom att rikta in sig på en specifik plattform är din app inte garanterad att fungera plattformskompatibel. Du kan köra dotnet <filename.dll>, men appen kan krascha när den försöker komma åt plattformsspecifika beroenden som saknas.

Mer information om RID finns i .NET RID Catalog.

Fördelar

  • Liten distribution
    Endast din app och dess beroenden distribueras. .NET-körningen och biblioteken installeras av användaren och alla appar delar körningen.

  • Plattformsoberoende
    Din app och alla . NET-baserat bibliotek körs på andra operativsystem. Du behöver inte definiera en målplattform för din app. Information om .NET-filformatet finns i .NET Assembly File Format.

  • Använder den senaste uppdaterade körtiden
    Appen använder den senaste körmiljön (inom den målinriktade huvud- och delversionsfamiljen av .NET) installerad på målsystemet. Det innebär att appen automatiskt använder den senaste korrigerade versionen av .NET-körningen. Det här standardbeteendet kan åsidosättas. För mer information, se ramverksberoende appar rulla framåt.

Nackdelar

  • Kräver förinstallation av körningsmiljö
    Din app kan bara köras om versionen av .NET som appens mål redan är installerad på värdsystemet. Du kan konfigurera roll-forward-beteende för appen så att den antingen kräver en specifik version av .NET eller tillåter en nyare version av .NET. Mer information finns i ramverksberoende applikationer som uppgraderas.

  • .NET kan komma att ändras
    Det är möjligt att .NET-körningen och biblioteken uppdateras på den dator där appen körs. I sällsynta fall kan detta ändra appens beteende om du använder .NET-biblioteken, vilket de flesta appar gör. Du kan konfigurera hur din app använder nyare versioner av .NET. För mer information, se ramverksberoende appar rulla framåt.

Exempel

Publicera en app som plattformsoberoende och ramverksberoende. En körbar fil som riktar sig mot din aktuella plattform skapas tillsammans med dll- fil. Alla plattformsspecifika beroenden publiceras med appen.

dotnet publish

Publicera en app som plattformsspecifik och ramverksberoende. En 64-bitars körbar Linux-fil skapas tillsammans med dll- fil. Endast målplattformens beroenden publiceras med appen.

dotnet publish -r linux-x64

Publicera fristående

När du publicerar din app som fristående skapas en plattformsspecifik körbar fil. Utdatapubliceringsmappen innehåller alla komponenter i appen, inklusive .NET-biblioteken och målkörningsmiljön. Denna app är isolerad från andra .NET-appar och använder inte en lokalt installerad delad körmiljö. Användaren av appen behöver inte ladda ned och installera .NET.

Du kan publicera en fristående app genom att skicka parametern --self-contained till kommandot dotnet publish. Den körbara binärfilen skapas för den angivna målplattformen. Om du till exempel har en app med namnet word_readeroch du publicerar en fristående körbar fil för Windows skapas en word_reader.exe fil. Vid publicering för Linux eller macOS skapas en word_reader-fil. Målplattformen och arkitekturen anges med parametern -r <RID> för kommandot dotnet publish. Mer information om RID finns i .NET RID Catalog.

Om appen har plattformsspecifika beroenden, till exempel ett NuGet-paket som innehåller plattformsspecifika beroenden, kopieras dessa till publiceringsmappen tillsammans med appen.

Fördelar

  • Kontrollera .NET-version
    Du styr vilken version av .NET som distribueras med din app.

  • Plattformsspecifik inriktning
    Eftersom du måste publicera din app för varje plattform vet du var din app körs. Om .NET introducerar en ny plattform kan användarna inte köra din app på den plattformen förrän du släpper en version som riktar sig till den plattformen. Du kan testa din app för kompatibilitetsproblem innan användarna kör appen på den nya plattformen.

Nackdelar

  • Större implementeringar
    Eftersom din app innehåller .NET-körningen och alla dina appberoenden är nedladdningsstorleken och hårddiskutrymmet som krävs större än en ramverksberoende version.

    Tips

    Du kan minska storleken på distributionen på Linux-system med cirka 28 MB genom att använda .NET globaliseringsinvariant läge. Detta tvingar din app att behandla alla andra kulturer som den invarianta kulturen.

    Tips

    IL-trimning kan ytterligare minska storleken på distributionen.

  • Svårare att uppdatera .NET-versionen
    .NET Runtime (distribueras med din app) kan bara uppgraderas genom att släppa en ny version av din app.

Exempel

Publicera en fristående app. En 64-bitars körbar macOS-fil skapas.

dotnet publish -r osx-x64 --self-contained

Publicera en fristående app. En körbar Windows 64-bitarsversion skapas.

dotnet publish -r win-x64 --self-contained

Publicera med ReadyToRun-bilder

Publicering med ReadyToRun-avbildningar förbättrar starttiden för ditt program på bekostnad av att öka storleken på ditt program. Mer information finns i ReadyToRun.

Fördelar

  • Förbättrad starttid
    Programmet ägnar mindre tid åt att köra JIT.

Nackdelar

  • Större storlek
    Programmet är större på disk.

Exempel

Publicera en fristående app och ReadyToRun. En 64-bitars körbar macOS-fil skapas.

dotnet publish -c Release -r osx-x64 --self-contained -p:PublishReadyToRun=true

Publicera en fristående app och en ReadyToRun-app. En körbar Windows 64-bitarsversion skapas.

dotnet publish -c Release -r win-x64 --self-contained -p:PublishReadyToRun=true

Se även