C#：如何使用包含具体值的具体字典中的接口值的 IReadOnly 字典实现接口

Question

In my code, I am declaring internal classes and public interfaces, and I have a situation where I want to expose an interface with an IReadonlyDictionary containing values of a an interface type, but I want to implement it with a class having a Dictionary with values of a concrete type.

I need this because I am deserializing some JSON into a concrete type, and I want to expose the deserialized data as readonly.

I have implemented it as shown below, by lazily creating a new dictionary where concrete values are cast into the interface values. Is there a way to do this without having to create a new dictionary?

    // In this code I want to expose an IReadonlyDictionary<string,ISomeValue>. 
    // The data is deserialized from JSON by using concrete type with a dictionary 
    // with values of type SomeValue which has to have public getter/setters to be deserialized.
    // I would like to do this without copying and casting into a new dictionary as shown here.
    // Is that possible?


    public interface ISomeValue { }
    internal class SomeValue : ISomeValue { }
    
    public interface IConfiguration {
        IReadOnlyDictionary<string, ISomeValue> Values{ get; }
    }
    
    internal class Configuration : IConfiguration  {
        public Configuration() {
            _values = new Lazy<IReadOnlyDictionary<string, ISomeValue>>(()
            => Values.ToDictionary(x=>x.Key,x=>(ISomeValue)x.Value));
        }
        public Dictionary<string, SomeValue> Values { get; } = null!;
        private Lazy<IReadOnlyDictionary<string, ISomeValue>> _values;
        IReadOnlyDictionary<string, ISomeValue> IConfiguration.Values=> _values.Value;
    }

Answer 1

I would like to do this without copying and casting into a new dictionary as shown here.

Well, you can't just directly return Value in the explicit interface implementation, because both generic parameters of IReadOnlyDictionary are generically invariant . If only TValue were covariant, you would have been able to directly do this:

public Dictionary<string, SomeValue> Values { get; } = new Dictionary<string, SomeValue>();
IReadOnlyDictionary<string, ISomeValue> IConfiguration.Values => Values;

But TryGetValue uses TValue as a parameter, IReadOnlyDictionary is forced to be invariant on TValue .

I suggest that you make your code look prettier in some other aspects. For example, you could extract that very long line of code that creates a new dictionary into an extension method.

Answer 2

You have to create a new object, but you don't have to create a copy of the original dictionary. Instead, you can create a view over the original dictionary, with the new shape. Here's some entirely-untested-but-simple code that I believe should work:

public class ReadOnlyDictionaryWrapper<TKey, TValue, TOriginalValue> : IReadOnlyDictionary<TKey, TValue>
    where TOriginalValue : TValue
{
    private readonly IReadOnlyDictionary<TKey, TOriginalValue> original;

    public ReadOnlyDictionaryWrapper(IReadOnlyDictionary<TKey, TOriginalValue> original) =>
        this.original = original;

    public TValue this[TKey key] => original[key];

    public IEnumerable<TKey> Keys => original.Keys;

    public IEnumerable<TValue> Values => original.Values.Cast<TValue>();

    public int Count => original.Count;

    public bool ContainsKey(TKey key) => original.ContainsKey(key);

    public IEnumerator<KeyValuePair<TKey, TValue>> GetEnumerator() =>
        original.Select(pair => new KeyValuePair<TKey, TValue>(pair.Key, pair.Value))
                .GetEnumerator();

    public bool TryGetValue(TKey key, out TValue value)
    {
        bool ret = original.TryGetValue(key, out var originalValue);
        value = originalValue;
        return ret;
    }

    IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
}

I'd suggest creating a single instance of this in your Configuration constructor, to wrap _values .