Catálogo .NET RID

Artigo
07/16/2024

RID é a abreviação de runtime identifier. Os valores RID são usados para identificar as plataformas de destino onde o aplicativo é executado. Eles são usados por pacotes .NET para representar ativos específicos da plataforma em pacotes NuGet. Os seguintes valores são exemplos de RIDs: linux-x64, win-x64, ou osx-x64. Para os pacotes com dependências nativas, o RID designa em quais plataformas o pacote pode ser restaurado.

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

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

[os] é o apelido do sistema operacional/plataforma. Por exemplo, ubuntu.
[version] é a versão do sistema operacional na forma de um número de versão separado por pontos (.). 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] diferenciar ainda mais diferentes plataformas. Por exemplo: aot.

Gráfico RID

O gráfico RID ou gráfico de fallback de tempo de execução é uma lista de RIDs que são compatíveis entre si.

Esses RIDs são definidos em PortableRuntimeIdentifierGraph.json no dotnet/runtime repositório. Neste arquivo, você pode ver que todos os RIDs, exceto o base, contêm uma "#import" instrução. Estas instruções indicam RIDs compatíveis.

Antes do .NET 8, RIDs específicos da versão e da distribuição eram adicionados regularmente ao arquivo runtime.json , que está localizado no dotnet/runtime repositório. Este gráfico não é mais atualizado e existe como uma opção de compatibilidade com versões anteriores. Os desenvolvedores devem usar RIDs que não são específicos da versão e não específicos da distro.

Quando o NuGet restaura pacotes, ele tenta encontrar uma correspondência exata para o tempo de execução especificado. Se uma correspondência exata não for encontrada, o NuGet percorrerá o 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 osx-x64 RID:

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

O RID acima especifica que osx-x64 as importações unix-x64. Assim, quando o NuGet restaura pacotes, ele tenta encontrar uma correspondência exata para osx-x64 o pacote. Se o NuGet não conseguir encontrar o tempo de execução específico, ele poderá restaurar pacotes que especificam unix-x64 tempos de execução, por exemplo.

O exemplo a seguir mostra um gráfico RID um pouco maior também definido no arquivo runtime.json :

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

Como alternativa, você pode usar a ferramenta RidGraph para visualizar facilmente o gráfico RID (ou qualquer subconjunto do gráfico).

Todos os RIDs eventualmente mapeiam de volta para o RID raiz any .

Há algumas considerações sobre RIDs que você deve ter em mente ao trabalhar com eles:

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

Alguns aplicativos precisam calcular RIDs programaticamente. Em caso afirmativo, os RIDs computados devem corresponder exatamente ao catálogo, inclusive em invólucro. RIDs com caixa diferente causariam problemas quando o sistema operacional diferencia maiúsculas de minúsculas, por exemplo, Linux, porque o valor é frequentemente 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ção 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. Para obter a versão mais recente e completa, consulte o PortableRuntimeIdentifierGraph.json no dotnet/runtime repositório.

Os RIDs que são considerados "portáteis", ou seja, não estão vinculados a uma versão específica ou distribuição do sistema operacional, são a escolha recomendada. Isso significa que os RIDs portáteis devem ser usados para criar um aplicativo específico da plataforma e criar um pacote NuGet com ativos específicos do RID.

A partir do .NET 8, o comportamento padrão do SDK e do tempo de execução do .NET é considerar apenas RIDs não específicos da versão e não específicos da distro. Ao restaurar e construir, o SDK usa um gráfico RID portátil menor. O RuntimeInformation.RuntimeIdentifier retorna a plataforma para a qual o tempo de execução foi criado. Em tempo de execução, o .NET localiza ativos específicos do RID usando um conjunto conhecido de RIDs portáteis. Ao criar um aplicativo com ativos específicos do RID que podem ser ignorados em tempo de execução, o SDK emitirá um aviso: NETSDK1206.

Carregando ativos para uma versão ou distribuição específica do sistema operacional

O .NET não tenta mais fornecer suporte de primeira classe para resolver dependências específicas de uma versão ou distribuição do sistema operacional. Se seu aplicativo ou pacote precisar carregar ativos diferentes com base na versão ou distribuição do sistema operacional, ele deverá implementar a lógica para carregar ativos condicionalmente.

Para obter informações sobre a plataforma, use System.OperatingSystem APIs. No Windows e macOS, Environment.OSVersion retornará a versão do sistema operacional. No Linux, pode ser a versão do kernel — para obter o nome da distro Linux e as informações de versão, a abordagem recomendada é ler o arquivo /etc/os-release .

O .NET fornece vários pontos de extensão para personalizar a lógica de carregamento — por exemplo, NativeLibrary.SetDllImportResolver(Assembly, DllImportResolver), AssemblyLoadContext.ResolvingUnmanagedDll, AssemblyLoadContext.Resolvinge AppDomain.AssemblyResolve. Estes podem ser usados para carregar o ativo correspondente à plataforma atual.

RIDs conhecidos

A lista a seguir mostra um pequeno subconjunto dos RIDs mais comuns usados para cada sistema operacional. Para obter a versão mais recente e completa, consulte o PortableRuntimeIdentifierGraph.json no dotnet/runtime repositório.

Windows RIDs

win-x64
win-x86
win-arm64

Para obter mais informações, consulte Instalar o .NET no Windows.

Linux RIDs

linux-x64 (A maioria das distribuições desktop como CentOS Stream, Debian, Fedora, Ubuntu e derivados)
linux-musl-x64 (Distribuições leves usando musl como Alpine Linux)
linux-musl-arm64 (Usado para construir imagens do Docker para Arm v8 de 64 bits e imagens de base minimalistas)
linux-arm (Distribuições Linux rodando no Arm como Raspbian no Raspberry Pi Model 2+)
linux-arm64 (Distribuições Linux rodando em Arm de 64 bits como o Ubuntu Server de 64 bits no Raspberry Pi Model 3+)
linux-bionic-arm64 (Distribuições usando a libc biônica do Android, por exemplo, Termux)
linux-loongarch64 (distribuições Linux rodando em LoongArch64)

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

RIDs do macOS

Os RIDs do macOS usam a marca "OSX" mais antiga.

osx-x64 (A versão mínima do SO é macOS 10.12 Sierra)
osx-arm64