Dela via

.NET-distributionspaketering

  • Artikel

När .NET 5-versioner (och .NET Core) och senare versioner blir tillgängliga på fler och fler plattformar är det användbart att lära dig hur du paketerar, namnger och versionsprogram och bibliotek som använder det. På så sätt kan paketunderhållarna säkerställa en konsekvent upplevelse oavsett var användarna väljer att köra .NET. Den här artikeln är användbar för användare som:

  • Försöker skapa .NET från källan.
  • Vill göra ändringar i .NET CLI som kan påverka den resulterande layouten eller paketen som skapas.

Disklayout

När det är installerat består .NET av flera komponenter som anges på följande sätt i filsystemet:

{dotnet_root}                    (0)              (*)
├── dotnet                       (1)
├── LICENSE.txt                  (8)
├── ThirdPartyNotices.txt        (8)
├── host                                          (*)
│   └── fxr                                       (*)
│       └── <fxr version>        (2)
├── sdk                                           (*)
│   └── <sdk version>            (3)
├── sdk-manifests                (4)              (*)
│   └── <sdk feature band version>
├── library-packs                (20)             (*)
├── metadata                     (4)              (*)
│   └── workloads
│       └── <sdk feature band version>
├── template-packs               (4)              (*)
├── packs                                         (*)
│   ├── Microsoft.AspNetCore.App.Ref              (*)
│   │   └── <aspnetcore ref version>     (11)
│   ├── Microsoft.NETCore.App.Ref                 (*)
│   │   └── <netcore ref version>        (12)
│   ├── Microsoft.NETCore.App.Host.<rid>          (*)
│   │   └── <apphost version>            (13)
│   ├── Microsoft.WindowsDesktop.App.Ref          (*)
│   │   └── <desktop ref version>        (14)
│   ├── NETStandard.Library.Ref                   (*)
│   │   └── <netstandard version>        (15)
│   ├── Microsoft.NETCore.App.Runtime.<rid>       (*)
│   │   └── <runtime version>            (18)
│   ├── Microsoft.AspNetCore.App.Runtime.<rid>    (*)
│   │   └── <aspnetcore version>         (18)
│   └── runtime.<rid>.Microsoft.DotNet.ILCompiler (*)
│       └── <runtime version>            (19)
├── shared                                        (*)
│   ├── Microsoft.NETCore.App                     (*)
│   │   └── <runtime version>     (5)
│   ├── Microsoft.AspNetCore.App                  (*)
│   │   └── <aspnetcore version>  (6)
│   ├── Microsoft.AspNetCore.All                  (*)
│   │   └── <aspnetcore version>  (6)
│   └── Microsoft.WindowsDesktop.App              (*)
│       └── <desktop app version> (7)
└── templates                                     (*)
│   └── <templates version>      (17)
/
├── etc/dotnet
│       └── install_location     (16)
├── usr/share/man/man1
│       └── dotnet.1.gz          (9)
└── usr/bin
        └── dotnet               (10)

  • (0) {dotnet_root} är en delad rot för alla .NET-huvudversioner och delversioner. Om flera körningar har installerats delar de mappen {dotnet_root} till exempel {dotnet_root}/shared/Microsoft.NETCore.App/6.0.11 och {dotnet_root}/shared/Microsoft.NETCore.App/7.0.0. Namnet på {dotnet_root} mappen ska vara versionsagnostisk, dvs. helt enkelt dotnet.

  • (1) dotnet Värden (kallas även "muxer") har två distinkta roller: aktivera en körning för att starta ett program och aktivera en SDK för att skicka kommandon till den. Värden är en intern körbar fil (dotnet.exe).

Det finns en enda värd, men de flesta av de andra komponenterna finns i versionskataloger (2,3,5,6). Det innebär att flera versioner kan finnas i systemet eftersom de installeras sida vid sida.

  • (2) värd/fxr/<fxr-version> innehåller den ramverksmatchningslogik som används av värden. Värden använder den senaste hostfxr som är installerad. Hostfxr ansvarar för att välja lämplig körning när du kör ett .NET-program. Ett program som skapats för .NET 7.0.0 använder till exempel 7.0.5-körningen när den är tillgänglig. På samma sätt väljer hostfxr lämplig SDK under utvecklingen.

  • (3) sdk/<sdk-versionen> SDK (även kallat "verktygen") är en uppsättning hanterade verktyg som används för att skriva och skapa .NET-bibliotek och -program. SDK:n innehåller .NET CLI, kompilatorer för hanterade språk, MSBuild och tillhörande bygguppgifter och mål, NuGet, nya projektmallar och så vidare.

  • (4) sdk-manifests/<sdk feature band version> Namnen och versionerna av de tillgångar som en valfri arbetsbelastningsinstallation kräver underhålls i arbetsbelastningsmanifest som lagras i den här mappen. Mappnamnet är funktionsbandsversionen av SDK:et. Så för en SDK-version som 7.0.102 skulle den här mappen fortfarande ha namnet 7.0.100. När en arbetsbelastning installeras skapas följande mappar efter behov för arbetsbelastningens tillgångar: metadata och mallpaket. En distribution kan skapa en tom /metadata/arbetsbelastningar/<sdkfeatureband>/userlocal-fil om arbetsbelastningar ska installeras under en användarsökväg i stället för i dotnet-mappen . Mer information finns i GitHub-problem med dotnet/installer#12104.

Den delade mappen innehåller ramverk. Ett delat ramverk tillhandahåller en uppsättning bibliotek på en central plats så att de kan användas av olika program.

  • (5) delad/Microsoft.NETCore.App/<runtime-version> Det här ramverket innehåller .NET-körningen och stöd för hanterade bibliotek.

  • (6) shared/Microsoft.AspNetCore.{ App,All}/<aspnetcore-versionen> innehåller ASP.NET Core-bibliotek. Biblioteken under Microsoft.AspNetCore.App utvecklas och stöds som en del av .NET-projektet. Biblioteken under Microsoft.AspNetCore.All är en superuppsättning som också innehåller bibliotek från tredje part.

  • (7) delad/Microsoft.Desktop.App/<skrivbordsappversion> innehåller Windows-skrivbordsbiblioteken. Detta ingår inte på plattformar som inte är Windows-plattformar.

  • (8) LICENSE.txt,ThirdPartyNotices.txt är .NET-licenserna och licenserna för bibliotek från tredje part som används i .NET.

  • (9,10) dotnet.1.gz är dotnet dotnet.1.gz den manuella sidan för dotnet. dotnet är en symlink till dotnet-värden(1). Dessa filer installeras på välkända platser för systemintegrering.

  • (11,12) Microsoft.NETCore.App.Ref,Microsoft.AspNetCore.App.Ref beskriver API:et för en x.y version av .NET respektive ASP.NET Core. Dessa paket används vid kompilering för dessa målversioner.

  • (13) Microsoft.NETCore.App.Host.<rid> innehåller en intern binär fil för plattformen rid. Den här binärfilen är en mall när du kompilerar ett .NET-program till en intern binär fil för den plattformen.

  • (14) Microsoft.WindowsDesktop.App.Ref beskriver API: x.y et för version av Windows Desktop-program. Dessa filer används vid kompilering för det målet. Detta tillhandahålls inte på plattformar som inte är Windows-plattformar.

  • (15) NETStandard.Library.Ref beskriver netstandard-API x.y :et. Dessa filer används vid kompilering för det målet.

  • (16) /etc/dotnet/install_location är en fil som innehåller den fullständiga sökvägen för {dotnet_root}. Sökvägen kan sluta med en ny rad. Det är inte nödvändigt att lägga till den här filen när roten är /usr/share/dotnet.

  • (17) mallar innehåller de mallar som används av SDK. Du hittar till exempel dotnet new projektmallar här.

  • (18) Microsoft.NETCore.App.Runtime.<rid>/<runtime version,Microsoft.AspNetCore.App.Runtime>.<rid>/<aspnetcore version> Dessa filer gör det möjligt att skapa fristående program. Dessa kataloger innehåller symboliska länkar till filer i (2), (5) och (6).

  • (19) körning.<rid>. Microsoft.DotNet.ILCompiler/<runtime-versionen> Dessa filer gör det möjligt att skapa NativeAOT-program för målplattformen.

  • (20) bibliotekspaket innehåller NuGet-paketfiler. SDK:n är konfigurerad för att använda den här mappen som en NuGet-källa. Listan över NuGet-paket som tillhandahålls av en .NET-version beskrivs nedan.

Mapparna som är markerade med (*) används av flera paket. Vissa paketformat (till exempel rpm) kräver särskild hantering av sådana mappar. Paketunderhållaren måste ta hand om detta.

Paketfiler som läggs till library-packs i (20) kan vara paket som Microsoft inte distribuerar för målplattformen. Filerna kan också vara paket som Microsoft distribuerar och som tillhandahåller ett paket som har skapats från källan för att uppfylla riktlinjerna för library-packs distribution av plattformspaket. Följande paket ingår i .NET-versionen:

Paketnamn Publicerad av Microsoft Behövs för
Microsoft.DotNet.ILCompiler.<version>.nupkg
Microsoft.NET.ILLink.Tasks.<version>.nupkg		 ☑ NativeAOT

.NET-versionshantering baseras på versionsnumren för körningskomponenten [major].[minor] . SDK-versionen använder samma [major].[minor] och har en oberoende [patch] som kombinerar funktions- och korrigeringssemantik för SDK:t. Till exempel: SDK version 7.0.302 är den andra korrigeringsversionen av den tredje funktionsversionen av SDK:t som stöder 7.0-körningen. Mer information om hur versionshantering fungerar finns i Översikt över .NET-versionshantering.

Några av paketen innehåller en del av versionsnumret i deras namn. På så sätt kan du installera en specifik version. Resten av versionen ingår inte i versionsnamnet. Detta gör att operativsystemets pakethanterare kan uppdatera paketen (till exempel automatiskt installera säkerhetskorrigeringar). Pakethanterare som stöds är Linux-specifika.

Följande visar de rekommenderade paketen:

  • dotnet-sdk-[major].[minor] – Installerar den senaste SDK:t för specifik körning

    • Version:<sdk-version>
    • Exempel: dotnet-sdk-7.0
    • Innehåller: (3),(4),(18),(20)
    • Beroenden: dotnet-runtime-[major].[minor], aspnetcore-runtime-[major].[minor], dotnet-targeting-pack-[major].[minor], aspnetcore-targeting-pack-[major].[minor], , netstandard-targeting-pack-[netstandard_major].[netstandard_minor], , dotnet-apphost-pack-[major].[minor]dotnet-templates-[major].[minor]

  • dotnet-sdk-aot-[major].[minor] – Installerar SDK-komponenterna för plattformen NativeAOT

    • Version:<sdk-version>
    • Exempel: dotnet-sdk-aot-9.0
    • Innehåller: (19)
    • Beroenden: dotnet-sdk-[major].[minor], kompilatorverktygskedja och utvecklarpaket för bibliotek som .NET-körningen är beroende av

  • aspnetcore-runtime-[major].[minor] – Installerar en specifik ASP.NET Core-körning

    • Version:<aspnetcore runtime version>
    • Exempel: aspnetcore-runtime-7.0
    • Innehåller: (6)
    • Beroenden: dotnet-runtime-[major].[minor]

  • dotnet-runtime-deps-[major].[minor](Valfritt) – Installerar beroenden för att köra fristående program

    • Version:<körningsversion>
    • Exempel: dotnet-runtime-deps-7.0
    • Beroenden: distributionsspecifika beroenden

  • dotnet-runtime-[major].[minor] – Installerar en specifik körning

    • Version:<körningsversion>
    • Exempel: dotnet-runtime-7.0
    • Innehåller: (5)
    • Beroenden: dotnet-hostfxr-[major].[minor], dotnet-runtime-deps-[major].[minor]

  • dotnet-hostfxr-[major].[minor] -beroende

    • Version:<körningsversion>
    • Exempel: dotnet-hostfxr-7.0
    • Innehåller: (2)
    • Beroenden: dotnet-host

  • dotnet-host -beroende

    • Version:<körningsversion>
    • Exempel: dotnet-host
    • Innehåller: (1),(8),(9),(10),(16)

  • dotnet-apphost-pack-[major].[minor] -beroende

    • Version:<körningsversion>
    • Innehåller: (13)

  • dotnet-targeting-pack-[major].[minor] – Tillåter mål för en icke-senaste körning

    • Version:<körningsversion>
    • Innehåller: (12)

  • aspnetcore-targeting-pack-[major].[minor] – Tillåter mål för en icke-senaste körning

    • Version:<aspnetcore runtime version>
    • Innehåller: (11)

  • netstandard-targeting-pack-[netstandard_major].[netstandard_minor] – Tillåter mål för en netstandard-version

    • Version:<sdk-version>
    • Innehåller: (15)

  • dotnet-templates-[major].[minor]

    • Version:<sdk-version>
    • Innehåller: (17)

Följande två metapaket är valfria. De ger slutanvändarna ett värde genom att de abstraherar det översta paketet (dotnet-sdk), vilket förenklar installationen av den fullständiga uppsättningen .NET-paket. Dessa metapaket refererar till en specifik .NET SDK-version.

  • dotnet[major] – Installerar den angivna SDK-versionen

    • Version:<sdk-version>
    • Exempel: dotnet7
    • Beroenden: dotnet-sdk-[major].[minor]

  • dotnet – Installerar en specifik SDK-version som bestäms av distributioner för att vara den primära versionen – vanligtvis den senaste tillgängliga

    • Version:<sdk-version>
    • Exempel: dotnet
    • Beroenden: dotnet-sdk-[major].[minor]

Kräver dotnet-runtime-deps-[major].[minor] att du förstår de distributionsspecifika beroendena. Eftersom distributionssystemet kanske kan härleda detta automatiskt är paketet valfritt, i vilket fall dessa beroenden läggs till dotnet-runtime-[major].[minor] direkt i paketet.

När paketinnehållet finns under en version av mappen matchar paketnamnet [major].[minor] det versionerade mappnamnet. För alla paket, förutom netstandard-targeting-pack-[netstandard_major].[netstandard_minor], matchar detta även med .NET-versionen.

Beroenden mellan paket bör använda ett krav som är lika med eller större än versionskravet. Kräver till exempel dotnet-sdk-7.0:7.0.401 aspnetcore-runtime-7.0 >= 7.0.6. Detta gör det möjligt för användaren att uppgradera sin installation via ett rotpaket (till exempel dnf update dotnet-sdk-7.0).

De flesta distributioner kräver att alla artefakter skapas från källan. Detta har viss inverkan på paketen:

  • Bibliotek från tredje part under shared/Microsoft.AspNetCore.All kan inte enkelt skapas från källan. Så den mappen utelämnas från aspnetcore-runtime paketet.

  • NuGetFallbackFolder fylls i med binära artefakter från nuget.org. Den bör vara tom.

Flera dotnet-sdk paket kan ge samma filer för NuGetFallbackFolder. För att undvika problem med pakethanteraren bör dessa filer vara identiska (kontrollsumma, ändringsdatum och så vidare).

Felsöka paket

Felsökningsinnehåll bör paketeras i felsökningsnamnspaket som följer den .NET-paketdelning som beskrivs tidigare i den här artikeln. Till exempel bör felsökningsinnehåll för dotnet-sdk-[major].[minor] paketet ingå i ett paket med namnet dotnet-sdk-dbg-[major].[minor]. Du bör installera felsökningsinnehåll på samma plats som binärfilerna.

Här är några binära exempel:

I katalogen {dotnet_root}/sdk/<sdk version> förväntas följande två filer:

  • dotnet.dll – installerat med dotnet-sdk-[major].[minor] paket
  • dotnet.pdb – installerat med dotnet-sdk-dbg-[major].[minor] paket

I katalogen {dotnet_root}/shared/Microsoft.NETCore.App/<runtime version> förväntas följande två filer:

  • System.Text.Json.dll – installerat med dotnet-runtime-[major].[minor] paket
  • System.Text.Json.pdb – installerat med dotnet-runtime-dbg-[major].[minor] paket

I katalogen {dotnet_root/shared/Microsoft.AspNetCore.App/<aspnetcore version> förväntas följande två filer:

  • Microsoft.AspNetCore.Routing.dll - installeras med aspnetcore-runtime-[major].[minor] paket
  • Microsoft.AspNetCore.Routing.pdb - installeras med aspnetcore-runtime-dbg-[major].[minor] paket

Från och med .NET 8.0 är allt .NET-felsökningsinnehåll (PDB-filer), som skapats av source-build, tillgängligt i en tarball med namnet dotnet-symbols-sdk-<version>-<rid>.tar.gz. Det här arkivet innehåller PDF-filer i underkataloger som matchar katalogstrukturen för .NET SDK tarball – dotnet-sdk-<version>-<rid>.tar.gz.

Även om allt felsökningsinnehåll är tillgängligt i felsöknings-tarball är inte allt felsökningsinnehåll lika viktigt. Slutanvändarna är mest intresserade av innehållet i katalogerna shared/Microsoft.AspNetCore.App/<aspnetcore version> och shared/Microsoft.NETCore.App/<runtime version> .

SDK-innehållet under sdk/<sdk version> är användbart för felsökning av .NET SDK-verktygsuppsättningar.

Följande paket är de rekommenderade felsökningspaketen:

  • aspnetcore-runtime-dbg-[major].[minor] – Installerar felsökningsinnehåll för en specifik ASP.NET Core-körning

    • Version:<aspnetcore runtime version>
    • Exempel: aspnetcore-runtime-dbg-8.0
    • Innehåller: felsöka innehåll för (6)
    • Beroenden: aspnetcore-runtime-[major].[minor]

  • dotnet-runtime-dbg-[major].[minor] – Installerar felsökningsinnehåll för en viss körning

    • Version:<körningsversion>
    • Exempel: dotnet-runtime-dbg-8.0
    • Innehåller: felsöka innehåll för (5)
    • Beroenden: dotnet-runtime-[major].[minor]

Följande felsökningspaket är valfritt:

  • dotnet-sdk-dbg-[major].[minor] – Installerar felsökningsinnehåll för en specifik SDK-version
    • Version:<sdk-version>
    • Exempel: dotnet-sdk-dbg-8.0
    • Innehåller: felsöka innehåll för (3),(4),(18)
    • Beroenden: dotnet-sdk-[major].[minor]

Felsöknings-tarball innehåller också en del felsökningsinnehåll under packs, som representerar kopior av innehåll under shared. I .NET-layouten packs används katalogen för att skapa .NET-program. Det finns inga felsökningsscenarier, så du bör inte paketera felsökningsinnehållet under packs i felsöknings-tarballen.

Skapa paket

Lagringsplatsen dotnet/source-build innehåller instruktioner om hur du skapar en källtarball för .NET SDK och alla dess komponenter. Utdata från källlagringsplatsen matchar layouten som beskrivs i det första avsnittet i den här artikeln.