Catalogo RID .NET

  • Articolo

RID è l'acronimo di Runtime Identifier. I valori RID vengono usati per identificare le piattaforme di destinazione in cui viene eseguita l'applicazione e vengono usati dai pacchetti .NET per rappresentare risorse specifiche della piattaforma in pacchetti NuGet. I valori seguenti sono esempi di RID: linux-x64, win-x64 o osx-x64. Per i pacchetti con dipendenze native, il RID specifica le piattaforme su cui può essere ripristinato il pacchetto.

Un singolo RID può essere impostato nell'elemento <RuntimeIdentifier> del file di progetto. Più RID possono essere definiti come elenco delimitato da punto e virgola nell'elemento <RuntimeIdentifiers> del file di progetto. Vengono usate anche tramite l'opzione --runtime con i comandi dell'interfaccia della riga di comando di .NET seguenti:

I RID che rappresentano un sistema operativo reale seguono in genere il modello seguente: [os].[version]-[architecture]-[additional qualifiers] dove:

  • [os] è il moniker di sistema operativo/piattaforma. Ad esempio: ubuntu.

  • [version] è il numero di versione del sistema operativo nel formato separato da punti (.). Ad esempio: 15.10.

    La versione non deve essere una versione di marketing, poiché le versioni di marketing spesso rappresentano più versioni discrete del sistema operativo con una superficie API della piattaforma variabile.

  • [architecture] indica l'architettura del processore, Ad esempio: x86, x64, arm o arm64.

  • [additional qualifiers] differenziano ulteriormente piattaforme diverse. Ad esempio: aot.

Grafico RID

Il grafico RID o grafico di fallback di runtime è un elenco di RID compatibili tra loro.

Questi RID sono definiti in PortableRuntimeIdentifierGraph.json nel repository dotnet/sdk. In questo file, si noterà che tutti i RID, ad eccezione di quello di base, contengono un'istruzione "#import". Queste istruzioni indicano RID compatibili.

Prima di .NET 8, i RID specifici della versione e di distribuzione sono stati aggiunti regolarmente al pacchetto Microsoft.NETCore.Platforms e al grafico RID nel file runtime.json , che si trova nel repository dotnet/runtime. Questo grafico non è più aggiornato ed esiste come opzione di compatibilità con le versioni precedenti. Gli sviluppatori devono usare RID non specifici della versione e non specifici della distribuzione.

Quando NuGet ripristina i pacchetti, tenta di trovare una corrispondenza esatta per il runtime specificato. Se non trova una corrispondenza esatta, NuGet ripercorre il grafico a ritroso fino a individuare il sistema compatibile più simile in base al grafico RID.

L'esempio seguente è la voce effettiva per il RID osx-x64:

"osx-x64": {
    "#import": [ "osx", "unix-x64" ]
}

Il RID sopra riportato specifica che osx-x64 importa unix-x64. Pertanto, quando NuGet ripristina i pacchetti, tenta di trovare una corrispondenza esatta per osx-x64 nel pacchetto. Se NuGet non riesce a trovare il runtime specifico, può ripristinare pacchetti che specificano runtime unix-x64, ad esempio.

L'esempio seguente mostra un grafico RID leggermente più ampio, anch'esso definito nel file runtime.json:

    linux-arm64     linux-arm32
         |     \   /     |
         |     linux     |
         |       |       |
    unix-arm64   |    unix-x64
             \   |   /
               unix
                 |
                any

In alternativa, è possibile usare lo strumento RidGraph per visualizzare facilmente il grafico RID (o qualsiasi subset del grafico).

Tutti i RID finiscono per mappare nuovamente al RID any radice.

Esistono alcune considerazioni che è necessario tenere presenti quando si lavora con i RID:

  • Non provare ad analizzare i RID per recuperare le parti del componente.

  • Usare i RID già definiti per la piattaforma.

  • I RID devono essere specifici, quindi non desumere nulla dal valore RID effettivo.

  • Non compilare RID a livello di codice, a meno che non sia assolutamente necessario.

    Alcune app devono calcolare i RID a livello di codice. In tal caso, i RID calcolati devono corrispondere esattamente al catalogo, inclusa la combinazione di maiuscole e minuscole. I RID con maiuscole e minuscole diverse causano problemi quando il sistema operativo fa distinzione tra maiuscole e minuscole, ad esempio Linux, perché il valore viene spesso usato durante la creazione di elementi come i percorsi di output. Si consideri, ad esempio, una procedura guidata di pubblicazione personalizzata in Visual Studio che si basa sulle informazioni del gestore di configurazione della soluzione e delle proprietà del progetto. Se la configurazione della soluzione passa un valore non valido, ad esempio ARM64 anziché arm64, potrebbe comportare un RID non valido, ad esempio win-ARM64.

Uso dei RID

Per usare i RID, è necessario sapere quali sono quelli disponibili. Per la versione più recente e completa, vedere il PortableRuntimeIdentifierGraph.json nel repository dotnet/sdk.

I RID considerati "portabili", ovvero che non sono associati a una versione specifica o a una distribuzione del sistema operativo, sono la scelta consigliata. Ciò significa che i RID portatili devono essere usati sia per la creazione di un'applicazione specifica della piattaforma che perla creazione di un pacchetto NuGet con asset specifici del RID.

A partire da .NET 8, il comportamento predefinito di .NET SDK e runtime consiste nel considerare solo i RID non specifici della versione e non specifici della distribuzione. Durante il ripristino e la compilazione, l'SDK usa un grafico RID portatile più piccolo. Il RuntimeInformation.RuntimeIdentifierrestituisce la piattaforma per cui è stato compilato il runtime. In fase di esecuzione, .NET trova asset specifici di RID usando un set noto di RID. Quando si compila un'applicazione con asset specifici del RID che possono essere ignorati in fase di esecuzione, l'SDK genera un avviso: NETSDK1206.

Caricamento di asset per una versione o una distribuzione specifica del sistema operativo

.NET non tenta più di fornire supporto di prima classe per la risoluzione delle dipendenze specifiche di una versione o distribuzione del sistema operativo. Se l'applicazione o il pacchetto deve caricare asset diversi in base alla versione o alla distribuzione del sistema operativo, deve implementare la logica per caricare in modo condizionale gli asset.

Per ottenere informazioni sulla piattaforma, usare le API System.OperatingSystem. In Windows e macOS, Environment.OSVersionrestituirà la versione del sistema operativo. In Linux, potrebbe trattarsi della versione del kernel: per ottenere il nome della distribuzione Linux e le informazioni sulla versione, l'approccio consigliato consiste nel leggere il file /etc/os-release.

.NET offre vari punti di estensione per personalizzare la logica di caricamento, ad esempio, NativeLibrary.SetDllImportResolver(Assembly, DllImportResolver), AssemblyLoadContext.ResolvingUnmanagedDll, AssemblyLoadContext.Resolving e AppDomain.AssemblyResolve. Questi possono essere usati per caricare l'asset corrispondente alla piattaforma corrente.

RID noti

L'elenco seguente mostra un piccolo subset dei RID più comuni usati per ogni sistema operativo. Per la versione più recente e completa, vedere il PortableRuntimeIdentifierGraph.json nel repository dotnet/sdk.

RID Windows

  • win-x64
  • win-x86
  • win-arm64

Per altre informazioni, vedere dipendenze e requisiti di .NET.

RID Linux

  • linux-x64 (la maggior parte delle distribuzioni desktop come CentOS, Debian, Fedora, Ubuntu e derivati)
  • linux-musl-x64 (Le distribuzioni leggere che usano musl come Alpine Linux)
  • linux-musl-arm64 (usato per compilare immagini Docker per immagini arm v8 a 64 bit e immagini di base minimaliste)
  • linux-arm (Distribuzioni Linux in esecuzione su Arm come Raspbian in Raspberry Pi Model 2+)
  • linux-arm64 (distribuzioni Linux in esecuzione in Arm a 64 bit come Ubuntu Server a 64 bit in Raspberry Pi Model 3+)
  • linux-bionic-arm64 (Distribuzioni che usano la libreria bionic di Android, ad esempio Termux)

Per altre informazioni, vedere dipendenze e requisiti di .NET.

RID macOS

I RID macOS usano la personalizzazione "OSX" precedente.

  • osx-x64 (La versione minima del sistema operativo è macOS 10.12 Sierra)
  • osx-arm64

Per altre informazioni, vedere dipendenze e requisiti di .NET.

RID iOS

  • ios-arm64

RID Android

  • android-arm64

Vedi anche