Base de conhecimentoCentro de Exames
PT · PTPortuguês (Portugal)
Escolher idioma13

CKTIS / C#

GetValueOrDefault em IReadOnlyDictionary

Consulta um dicionário com um valor alternativo e distingue, quando for necessário, uma chave em falta de um `null` guardado.

Versão: C# 12 and .NET 8; later runtimes may add compatible features

Sintaxe

using System.Collections.Generic;

// Extension signatures on System.Collections.Generic.CollectionExtensions:
public static TValue? GetValueOrDefault<TKey, TValue>(this IReadOnlyDictionary<TKey, TValue> dictionary, TKey key);
public static TValue GetValueOrDefault<TKey, TValue>(this IReadOnlyDictionary<TKey, TValue> dictionary, TKey key, TValue defaultValue);

// Extension call and equivalent static call:
dictionary.GetValueOrDefault(key);
CollectionExtensions.GetValueOrDefault(dictionary, key);
dictionary.GetValueOrDefault(key, defaultValue);
CollectionExtensions.GetValueOrDefault(dictionary, key, defaultValue);

Em C# 12 e .NET 8, dictionary.GetValueOrDefault(key) chama um método de extensão de CollectionExtensions no espaço de nomes System.Collections.Generic, não um membro de instância de IReadOnlyDictionary<TKey, TValue>. Importa a extensão com using System.Collections.Generic; ou torna explícita a sua origem com a chamada estática equivalente CollectionExtensions.GetValueOrDefault(dictionary, key). Dictionary<TKey, TValue> implementa a interface só de leitura, mas a extensão não está disponível numa variável declarada apenas como IDictionary<TKey, TValue>. O acesso só de leitura não garante que a coleção subjacente seja imutável.

Ambas as sobrecargas devolvem o valor guardado quando a chave existe, mesmo que seja null. Se faltar a chave, a sobrecarga sem valor alternativo devolve default(TValue) (por exemplo, null para um tipo de referência ou 0 para int); a outra devolve o defaultValue fornecido. A expressão do argumento é avaliada antes da chamada, mesmo quando a chave existe. Em contraste, dictionary.GetValueOrDefault(key) ?? fallback exige que o resultado da consulta possa ser o operando esquerdo de ??, como acontece com Cmd? no exemplo. Nesse caso, fallback só é avaliado e usado se a consulta devolver null, incluindo quando null é o valor guardado. Com TValue = int, esta expressão não compila porque a consulta devolve um int que não admite null.

Para distinguir uma chave em falta de um valor guardado igual ao valor predefinido ou alternativo, usa TryGetValue(key, out var value) e verifica o bool devolvido. Uma chave em falta não causa uma exceção em GetValueOrDefault, mas um dicionário null causa ArgumentNullException. Dictionary<TKey, TValue> também rejeita uma chave null com essa exceção.

Com #nullable enable, Cmd? indica que uma referência a Cmd pode ser null. É uma anotação para a análise do compilador, não um invólucro nem uma verificação em tempo de execução. A extensão para dicionários é distinta do método de instância Nullable<T>.GetValueOrDefault() para tipos de valor que admitem null.

Num mini-DSL, o analisador sintático valida o texto segundo a gramática e constrói uma árvore de sintaxe abstrata (AST). O avaliador interpreta apenas os nós suportados e resolve os nomes dos comandos através de um registo. Não passes o texto ao eval de JavaScript. Se um comando desconhecido for um erro, assinala-o com a ajuda de TryGetValue, em vez de escolher silenciosamente um comando alternativo.

Exemplos

#nullable enable
using System;
using System.Collections.Generic;

IReadOnlyDictionary<string, Cmd?> commands = new Dictionary<string, Cmd?>(StringComparer.Ordinal)
{
    ["print"] = new Cmd("PRINT"),
    ["disabled"] = null
};
var fallback = new Cmd("FALLBACK");

Console.WriteLine($"hit: {Show(commands.GetValueOrDefault("print"))}");
Console.WriteLine($"missing: {Show(commands.GetValueOrDefault("missing"))}");
Console.WriteLine($"missing with fallback: {Show(commands.GetValueOrDefault("missing", fallback))}");
Console.WriteLine($"stored null with fallback: {Show(commands.GetValueOrDefault("disabled", fallback))}");
Console.WriteLine($"static: {Show(CollectionExtensions.GetValueOrDefault(commands, "missing", fallback))}");
Console.WriteLine($"presence of missing: {commands.TryGetValue("missing", out _)}");
Console.WriteLine($"presence of disabled: {commands.TryGetValue("disabled", out _)}");

static string Show(Cmd? cmd) => cmd?.Name ?? "<null>";

sealed record Cmd(string Name);

Resultado

hit: PRINT
missing: <null>
missing with fallback: FALLBACK
stored null with fallback: <null>
static: FALLBACK
presence of missing: False
presence of disabled: True

`missing` está em falta e `disabled` contém `null`. Só a chave em falta recebe `FALLBACK`; as duas chamadas a `TryGetValue` mostram qual das chaves existe.

Lições relacionadas

  • C# · Lição 57 · Avançado · Versão: 3

Fontes