TypedValueBag.cs

using Newtonsoft.Json;
 
namespace Gondwana;

public readonly record struct ValueKey<T>(string Name);

public sealed class TypedValueBag : ICloneable
{
    [JsonIgnore]
    private readonly Dictionary<string, object?> _data = new();

    public TypedValueBag()
    {
    }

    public TypedValueBag(TypedValueBag other)
    {
        if (other is null)
            throw new ArgumentNullException(nameof(other));
 
        foreach (var (key, value) in other._data)
            _data[key] = CloneValue(value);
    }

    public void Set<T>(ValueKey<T> key, T value)
    {
        ValidateKeyName(key.Name);
        _data[key.Name] = value;
    }

    public bool TryGet<T>(ValueKey<T> key, out T? value)
    {
        ValidateKeyName(key.Name);
 
        if (!_data.TryGetValue(key.Name, out var raw))
        {
            value = default;
            return false;
        }
 
        if (raw is null)
        {
            value = default;
            return true;
        }
 
        if (raw is T typed)
        {
            value = typed;
            return true;
        }
 
        throw new InvalidCastException(
            $"Value for key '{key.Name}' is of runtime type '{raw.GetType().FullName}', " +
            $"which is not assignable to requested type '{typeof(T).FullName}'.");
    }

    public T Get<T>(ValueKey<T> key, T defaultValue = default!)
    {
        return TryGet(key, out var v) && v is not null
            ? v
            : defaultValue;
    }

    public bool Remove<T>(ValueKey<T> key)
    {
        ValidateKeyName(key.Name);
        return _data.Remove(key.Name);
    }

    public void Clear()
    {
        _data.Clear();
    }

    public void MergeFrom(TypedValueBag? incoming, bool overwriteExisting = false)
    {
        if (incoming is null)
            return;
 
        foreach (var (key, value) in incoming._data)
        {
            if (!overwriteExisting && _data.ContainsKey(key))
                continue;
 
            _data[key] = CloneValue(value);
        }
    }

    public bool Contains(string keyName)
    {
        ValidateKeyName(keyName);
        return _data.ContainsKey(keyName);
    }

    public bool Contains<T>(ValueKey<T> key)
    {
        ValidateKeyName(key.Name);
        return _data.ContainsKey(key.Name);
    }

    public TypedValueBag Clone() => new(this);

    object ICloneable.Clone() => Clone();

    public Dictionary<string, object?> ToDictionary()
    {
        return new Dictionary<string, object?>(_data);
    }

    private static object? CloneValue(object? value)
    {
        if (value is null)
            return null;
 
        if (value is Array array)
            return array.Clone();
 
        if (value is ICloneable cloneable)
            return cloneable.Clone();
 
        return value;
    }

    private static void ValidateKeyName(string keyName)
    {
        if (string.IsNullOrWhiteSpace(keyName))
            throw new ArgumentException("Value bag keys may not be null, empty, or whitespace.", nameof(keyName));
    }
}