Catálogo de RIDs do .NET

  • Artigo

RID é abreviação do 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 esse tipo de versão geralmente representam várias versões distintas do sistema operacional com diferentes áreas de superfície de API da plataforma.

  • [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 suportados e o gráfico RID no arquivo runtime.json, que está localizado no repositório dotnet/runtime. 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. Desse modo, quando o NuGet restaura pacotes, ele tenta encontrar uma correspondência exata para osx.10.12-x64 no pacote. Se o NuGet não conseguir encontrar o runtime específico, ele poderá restaurar pacotes que especificam runtimes osx.10.11-x64, por exemplo.

O seguinte exemplo mostra um gráfico 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 do 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 itens 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 da 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 completa e mais recente, confira o arquivo runtime.json no repositório dotnet/runtime.

OS RIDs que não estão vinculados a uma versão específica ou à distribuição do sistema operacional são a opção preferida, especialmente ao lidar com várias distribuições do Linux, uma vez 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 completa e mais recente, confira o arquivo runtime.json no repositório dotnet/runtime.

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

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

RIDs do Linux

Apenas os valores comuns são listados. Para obter a versão completa e mais recente, confira o arquivo runtime.json no repositório dotnet/runtime. Os dispositivos que executam uma distribuição não listada abaixo podem funcionar com um dos RIDs não específicos da 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 de á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 em ARM, como Raspbian no Raspberry Pi modelo 2+)
    • linux-arm64 (Distribuições do Linux em execução no Arm de 64 bits, como 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
    • tizen.5.5.0
    • tizen.6.0.0
    • tizen.6.5.0
    • tizen.7.0.0

Para obter mais informações, confira 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 completa e mais recente, confira o arquivo runtime.json no repositório dotnet/runtime.

  • MacOS, não específico da 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
  • macOS 13 Ventura
    • osx.13-x64
    • osx.13-arm64

Para obter mais informações, confira Dependências e os requisitos do .NET.

RIDs do iOS

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

  • iOS, não específico da 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

RIDs do Android

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

  • 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