Catálogo de RIDs do .NET

Artigo
07/28/2022
5 minutos para o fim da leitura

RID é abreviado para o Identificador de Runtime. Os valores do RID são usados para identificar plataformas de destino onde o aplicativo é executado. Eles são usados por pacotes .NET para representar ativos específicos de plataforma em pacotes NuGet. Os seguintes valores são exemplos de RIDs: linux-x64, ubuntu.14.04-x64, win7-x64 ou osx.10.12-x64. Para os pacotes com dependências nativas, o RID designará as plataformas em que o pacote pode ser restaurado.

Um único RID pode ser definido no elemento <RuntimeIdentifier> do arquivo de projeto. Vários RIDs podem ser definidos como uma lista separada por ponto-e-vírgula no elemento <RuntimeIdentifiers> do arquivo de projeto. Eles também são usados por meio da opção --runtime com os seguintes comandos da CLI do .NET:

RIDs que representem sistemas operacionais concretos geralmente seguem este padrão: [os].[version]-[architecture]-[additional qualifiers] em que:

[os] é o moniker do sistema operacional/plataforma. Por exemplo, ubuntu.
[version] é a versão do sistema operacional na forma de um separado de versão separado por ponto (.). Por exemplo, 15.10.

A versão não deve ser uma versão de marketing, pois as versões de marketing geralmente representam várias versões discretas do sistema operacional com área de superfície de API de plataforma variável.
[architecture] é a arquitetura do processador. Por exemplo: x86, x64, arm ou arm64.
[additional qualifiers] distingue diferentes plataformas. Por exemplo: aot.

Gráfico RID

O gráfico RID ou gráfico de fallback de runtime é uma lista de RIDs que são compatíveis entre si. Os RIDs são definidos no pacote Microsoft.NETCore.Platforms. Você pode ver a lista de RIDs com suporte e o grafo RID no arquivo runtime.json , que está localizado no dotnet/runtime repositório. Nesse arquivo, você pode ver todos os RIDs, exceto para a base um, que contém uma instrução "#import". Essas instruções indicam RIDs compatíveis.

Quando o NuGet restaura pacotes, ele tenta encontrar uma correspondência exata para o runtime especificado. Se uma correspondência exata não for encontrada, o NuGet voltará ao gráfico até encontrar o sistema compatível mais próximo de acordo com o gráfico RID.

O exemplo a seguir é a entrada real para o RID osx.10.12-x64:

"osx.10.12-x64": {
    "#import": [ "osx.10.12", "osx.10.11-x64" ]
}

O RID acima especifica que osx.10.12-x64 importa osx.10.11-x64. Portanto, quando o NuGet restaura pacotes, ele tenta encontrar uma correspondência exata no osx.10.12-x64 pacote. Se o NuGet não conseguir localizar o runtime específico, ele poderá restaurar pacotes que especificam osx.10.11-x64 runtimes, por exemplo.

O exemplo a seguir mostra um grafo RID ligeiramente maior também definido no arquivo runtime.json :

    win7-x64    win7-x86
       |   \   /    |
       |   win7     |
       |     |      |
    win-x64  |  win-x86
          \  |  /
            win
             |
            any

Todos os RIDs eventualmente mapeiam para a raiz de any RID.

Há algumas considerações sobre RIDs das quais você precisa se lembrar ao trabalhar com eles:

Não tente analisar RIDs para recuperar partes de componente.
Use RIDs que já estão definidos para a plataforma.
Os RIDs precisam ser específicos, portanto, não presuma nada usando o valor RID real.
Não crie RIDs programaticamente, a menos que seja absolutamente necessário.

Alguns aplicativos precisam calcular RIDs programaticamente. Nesse caso, os RIDs computados devem corresponder exatamente ao catálogo, inclusive no uso de maiúsculas e minúsculas. RIDs com maiúsculas e minúsculas diferentes causariam problemas quando o sistema operacional diferencia maiúsculas de minúsculas, por exemplo, Linux, porque o valor geralmente é usado ao construir coisas como caminhos de saída. Por exemplo, considere um assistente de publicação personalizado no Visual Studio que depende de informações do gerenciador de configurações de solução e das propriedades do projeto. Se a configuração da solução passar um valor inválido, por exemplo, ARM64 em vez de arm64, poderá resultar em um RID inválido, como win-ARM64.

Usando RIDs

Para poder usar RIDs, você precisa saber quais RIDs existem. Novos RIDs são adicionados regularmente à plataforma. Para obter a versão mais recente e completa, consulte o arquivo runtime.json no dotnet/runtime repositório.

RIDs que não estão vinculados a uma versão específica ou distribuição de sistema operacional são a escolha preferida, especialmente ao lidar com várias distribuições do Linux, já que a maioria dos RIDs de distribuição são mapeados para RIDs não específicos de distribuição.

A lista a seguir mostra um pequeno subconjunto dos RIDs mais comuns usados para cada SO.

RIDs do Windows

Apenas os valores comuns são listados. Para obter a versão mais recente e completa, consulte o arquivo runtime.json no dotnet/runtime repositório.

Windows, não específico de versão
- win-x64
- win-x86
- win-arm
- win-arm64
Windows 7 / Windows Server 2008 R2
- win7-x64
- win7-x86
Windows 8.1 / Windows Server 2012 R2
- win81-x64
- win81-x86
- win81-arm
Windows 11/Windows Server 2022/Windows 10/Windows Server 2016
- win10-x64
- win10-x86
- win10-arm
- win10-arm64

Não há win11 RIDs; use win10 RIDs para Windows 11. Para obter mais informações, consulte as dependências e os requisitos do .NET.

RIDs do Linux

Apenas os valores comuns são listados. Para obter a versão mais recente e completa, consulte o arquivo runtime.json no dotnet/runtime repositório. Os dispositivos que executam uma distribuição não listada abaixo podem funcionar com um dos RIDs não específicos de distribuição. Por exemplo, os dispositivos Raspberry Pi executando uma distribuição Linux não listada podem ser direcionados com linux-arm.

Linux, não específico da distribuição
- linux-x64 (A maioria das distribuições da área de trabalho, como CentOS, Debian, Fedora, Ubuntu e derivados)
- linux-musl-x64 (Distribuições leves usando musl, como o Alpine Linux)
- linux-arm (Distribuições linux em execução no Arm como Raspbian no Raspberry Pi Model 2+)
- linux-arm64 (Distribuições do Linux em execução no Arm de 64 bits como o Ubuntu Server de 64 bits no Raspberry Pi Model 3+)
Red Hat Enterprise Linux
- rhel-x64 (Substituído por linux-x64 para RHEL acima da versão 6)
- rhel.6-x64
Tizen
- tizen
- tizen.4.0.0
- tizen.5.0.0

Para obter mais informações, consulte as dependências e os requisitos do .NET.

RIDs do macOS

Os RIDs do macOS usam a identidade visual “OSX” mais antiga. Apenas os valores comuns são listados. Para obter a versão mais recente e completa, consulte o arquivo runtime.json no dotnet/runtime repositório.

macOS, não específico de versão
- osx-x64 (A versão mínima do sistema operacional é macOS 10.12 Sierra)
macOS 10.10 Yosemite
- osx.10.10-x64
macOS 10.11 El Capitan
- osx.10.11-x64
macOS 10.12 Sierra
- osx.10.12-x64
macOS 10.13 High Sierra
- osx.10.13-x64
macOS 10.14 Mojave
- osx.10.14-x64
macOS 10.15 Catalina
- osx.10.15-x64
macOS 11.0 Big Sur
- osx.11.0-x64
- osx.11.0-arm64
macOS 12 Monterey
- osx.12-x64
- osx.12-arm64

Para obter mais informações, consulte as dependências e os requisitos do .NET.

RIDs do iOS

Apenas os valores comuns são listados. Para obter a versão mais recente e completa, consulte o arquivo runtime.json no dotnet/runtime repositório.

iOS, não específico de versão
- ios-arm64
iOS 10
- ios.10-arm64
iOS 11
- ios.11-arm64
iOS 12
- ios.12-arm64
iOS 13
- ios.13-arm64
iOS 14
- ios.14-arm64
iOS 15
- ios.15-arm64

Android RIDs

Apenas os valores comuns são listados. Para obter a versão mais recente e completa, consulte o arquivo runtime.json no dotnet/runtime repositório.

Android, não específico da versão
- android-arm64
Android 21
- android.21-arm64
Android 22
- android.22-arm64
Android 23
- android.23-arm64
Android 24
- android.24-arm64
Android 25
- android.25-arm64
Android 26
- android.26-arm64
Android 27
- android.27-arm64
Android 28
- android.28-arm64
Android 29
- android.29-arm64
Android 30
- android.30-arm64
Android 31
- android.31-arm64
Android 32
- android.32-arm64

Confira também

IDs de Runtime