A .Net SoftDictionary<K,V> is a Dictionary<K,V> which, if you try to read an empty entry, returns default(V) instead of throwing an exception.

SoftDictionary.cs

/// <summary>
/// A SoftDictionary is a <see cref="Dictionary{TKey,TValue}"/> which does not
/// throw if you try to to access a non-existent entry. Instead, it returns <c>default(TValue)</c>
/// </summary>
/// <typeparam name="TKey"></typeparam>
/// <typeparam name="TValue"></typeparam>
public class SoftDictionary<TKey,TValue> : Dictionary<TKey,TValue> where TKey : notnull
{
    /// <inheritdoc cref="IDictionary{TKey,TValue}"/>
    /// <remarks>
    /// The get method does not throw when <paramref name="key" /> is not found. 
    /// </remarks>
    /// <returns>
    /// The stored value for <paramref name="key"/> if found, or <c>default(TValue)</c> if not.
    /// </returns>
    public new TValue? this[TKey key]
    {
        get
        {
            if(ContainsKey(key))return base[key];
            return default;
        }
        set => base[key] = value!;
    }
    
    public SoftDictionary() { }
    public SoftDictionary(IDictionary<TKey,TValue> dictionary) : base(dictionary) { }
    public SoftDictionary(IDictionary<TKey,TValue> dictionary,IEqualityComparer<TKey>? comparer) 
        : base(dictionary,comparer) { }
    public SoftDictionary(IEnumerable<KeyValuePair<TKey,TValue>> collection) : base(collection) { }

    public SoftDictionary(IEnumerable<KeyValuePair<TKey,TValue>> collection,IEqualityComparer<TKey>? comparer) 
        : base(collection,comparer) { }
    public SoftDictionary(IEqualityComparer<TKey>? comparer) : base(comparer) { }
    public SoftDictionary(int capacity) : base(capacity) { }
    public SoftDictionary(int capacity,IEqualityComparer<TKey>? comparer) : base(capacity,comparer) { }

    public SoftDictionary(IEnumerable<ValueTuple<TKey,TValue>> enumerable)
    {
        // We similarly special-case KVP<>[] and List<KVP<>>, as they're commonly used to seed dictionaries, and
        // we want to avoid the enumerator costs (e.g. allocation) for them as well. Extract a span if possible.
        ReadOnlySpan<ValueTuple<TKey, TValue>> span;
        if (enumerable is ValueTuple<TKey, TValue>[] array)
        {
            span = array;
        }
        else if (enumerable.GetType() == typeof(List<ValueTuple<TKey, TValue>>))
        {
            span = CollectionsMarshal.AsSpan((List<ValueTuple<TKey, TValue>>)enumerable);
        }
        else
        {
            // Fallback path for all other enumerables
            foreach (ValueTuple<TKey, TValue> pair in enumerable)
            {
                Add(pair.Item1, pair.Item2);
            }
            return;
        }

        // We got a span. Add the elements to the dictionary.
        foreach (ValueTuple<TKey, TValue> pair in span)
        {
            Add(pair.Item1, pair.Item2);
        }
    }
}