Catalogue RID .NET

Article
10/27/2023

RID est l’abréviation de Runtime IDentifier (identificateur de runtime). Les valeurs RID sont utilisées pour identifier les plateformes cibles où l’application s’exécute. Elles sont utilisées par les packages .NET pour représenter des ressources spécifiques à une plateforme dans les packages NuGet. Les valeurs suivantes sont des exemples de RID : linux-x64, win-x64, ou osx-x64. Pour les packages ayant des dépendances natives, les RID désignent les plateformes sur lesquelles ils peuvent être restaurés.

Un seul RID peut être défini dans l’élément <RuntimeIdentifier> de votre fichier projet. Les RID multiples peuvent être définis sous forme de liste de valeurs séparées par des points-virgules dans l’élément <RuntimeIdentifiers> du fichier projet. Ils sont également utilisés par le biais de l’option --runtime avec les commandes de l’interface CLI .NET suivantes :

Les RID qui représentent des systèmes d’exploitation concrets suivent généralement ce modèle : [os].[version]-[architecture]-[additional qualifiers] où :

[os] représente le moniker du système d’exploitation/de la plateforme. Par exemple : ubuntu.
[version] représente la version du système d’exploitation sous la forme d’un numéro de version (.) séparé par un point. Par exemple : 15.10.

La version ne doit pas correspondre à une version marketing, car les versions marketing représentent souvent plusieurs versions distinctes du système d’exploitation avec une surface d’exposition variable des API de la plateforme.
[architecture] représente l’architecture de processeur. Par exemple : x86, x64, arm ou arm64.
[additional qualifiers] permet de distinguer davantage les plateformes. Par exemple : aot.

Graphe RID

Le graphe RID ou le graphe de secours du runtime consiste en une liste d’identificateurs RID compatibles entre eux.

Ces RID sont définis dans PortableRuntimeIdentifierGraph.json dans le dotnet/runtime référentiel. Dans ce fichier, vous pouvez voir que tous les RID, sauf celui de base, contiennent une instruction "#import". Ces instructions indiquent des RID compatibles.

Avant .NET 8, les RID spécifiques à la version et à la distribution ont été régulièrement ajoutés au fichier runtime.json, qui se trouve dans le référentiel dotnet/runtime. Ce graphique n’est plus mis à jour et existe en tant qu’option de compatibilité descendante. Les développeurs doivent utiliser des RID qui ne sont pas spécifiques à la version et qui ne sont pas spécifiques à la distribution.

Lorsque NuGet restaure des packages, il tente de trouver une correspondance exacte pour le runtime spécifié. Si aucune correspondance exacte n’est trouvée, NuGet remonte le graphe jusqu'à ce qu’il trouve le système compatible le plus proche selon le graphe RID.

L’exemple suivant est l’entrée réelle pour le RID osx-x64 :

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

Le RID ci-dessus indique que osx-x64 importe unix-x64. Donc, lorsque NuGet restaure des packages, il tente de trouver une correspondance exacte pour osx-x64 dans le package. Si NuGet ne trouve pas le runtime spécifique, il peut restaurer des packages qui spécifient des runtimes unix-x64, par exemple.

L’exemple suivant illustre un graphe RID légèrement plus grand également défini dans le fichier runtime.json :

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

Vous pouvez également utiliser l’outil RidGraph pour visualiser facilement le graphique RID (ou tout sous-ensemble du graphique).

Tous les RID sont finalement remappés au RID any racine.

Lorsque vous utilisez les RID, il existe quelques remarques que vous devez garder à l’esprit :

N’essayez pas d’analyser les RID pour récupérer des parties de composants.
Utilisez des RID déjà définis pour la plateforme.
Les RID se devant d’être spécifiques, ne déduisez rien de leur valeur réelle.
Ne générez pas de RID par programmation, sauf si absolument nécessaire.

Certaines applications doivent calculer des RID par programmation. Dans ce cas, les RID calculés doivent correspondre exactement au catalogue, y compris dans la casse. Les RID avec différentes casses provoquent des problèmes lorsque le système d’exploitation respecte la casse, par exemple Linux, car la valeur est souvent utilisée lors de la construction d’éléments tels que des chemins de sortie. Par exemple, considérez un Assistant de publication personnalisé dans Visual Studio qui s’appuie sur les informations du gestionnaire de configuration de la solution et des propriétés du projet. Si la configuration de la solution transmet une valeur non valide, par exemple, ARM64 au lieu de arm64, elle peut entraîner un RID non valide, tel que win-ARM64.

Utilisation de RID

Pour utiliser des RID, vous devez savoir lesquels existent. Pour obtenir la dernière version et complète, consultez portableRuntimeIdentifierGraph.json dans le référentiel dotnet/runtime.

Il est recommandé de choisir des RID considérés comme « portables », c’est-à-dire qui ne sont pas liés à une version ou à une distribution d’un système d’exploitation spécifique. Cela signifie que les RID portables doivent être utilisés pour créer une application spécifique à la plateforme et créer un package NuGet avec des ressources spécifiques au RID.

À compter de .NET 8, le comportement par défaut du Kit de développement logiciel (SDK) .NET et du runtime consiste à considérer uniquement les RID non spécifiques à la version et non spécifiques aux distributions. Lors de la restauration et de la génération, le SDK utilise un graphique RID portable plus petit. RuntimeInformation.RuntimeIdentifier renvoie la plateforme pour laquelle le runtime a été généré. Au moment de l’exécution, .NET recherche des ressources spécifiques au RID à l’aide d’un ensemble connu de RID portables. Lors de la création d’une application avec des ressources spécifiques au RID qui peuvent être ignorées au moment de l’exécution, le SDK émet un avertissement : NETSDK1206.

Chargement des ressources pour une version ou une distribution d’un système d’exploitation spécifique

.NET ne cherche plus à fournir une prise en charge de première classe pour la résolution des dépendances spécifiques à une version ou une distribution du système d’exploitation. Si votre application ou package doit charger différentes ressources en fonction de la version ou de la distribution du système d’exploitation, elle doit implémenter la logique pour charger des ressources de manière conditionnelle.

Pour obtenir des informations sur la plateforme, utilisez des API System.OperatingSystem. Sur Windows et macOS, Environment.OSVersion retourne la version du système d’exploitation. Sur Linux, il peut s’agir de la version du noyau : pour obtenir le nom de distribution Linux et les informations de la version, l’approche recommandée consiste à lire le fichier /etc/os-release.

.NET fournit différents points d’extension pour la personnalisation de la logique de chargement, par exemple : NativeLibrary.SetDllImportResolver(Assembly, DllImportResolver), AssemblyLoadContext.ResolvingUnmanagedDll, AssemblyLoadContext.Resolving et AppDomain.AssemblyResolve. Elles peuvent être utilisées pour charger la ressource correspondant à la plateforme actuelle.

RID connus

La liste suivante présente un petit sous-ensemble des RID les plus courants utilisés pour chaque système d’exploitation. Pour obtenir la dernière version et complète, consultez portableRuntimeIdentifierGraph.json dans le référentiel dotnet/runtime.

RID Windows

win-x64
win-x86
win-arm64

Pour plus d’informations, consultez Installer .NET sur Windows.

RID Linux

linux-x64 (la plupart des distributions pour ordinateurs de bureau, comme CentOS Stream, Debian, Fedora, Ubuntu et dérivés)
linux-musl-x64 (distributions légères utilisant musl, comme Linux Alpine)
linux-musl-arm64 (Utilisé pour générer des images Docker pour les images de base 64 bits Arm v8 et minimalistes)
linux-arm (distributions Linux s’exécutant sur ARM comme Raspbian sur Raspberry Pi Modèle 2+)
linux-arm64 (distributions Linux s’exécutant sur ARM 64 bits comme Ubuntu Server 64 bits sur Raspberry Pi Modèle 3+)
linux-bionic-arm64 (Distributions à l’aide de la bibliothèque bionique d’Android, par exemple, Termux)

Pour plus d’informations, consultez Dépendances et exigences .NET.

RID macOS

Les RID macOS utilisent l’ancien logo « OSX ».

osx-x64 (la version minimale du système d’exploitation est macOS 10.12 Sierra)
osx-arm64