using System;

using System.Collections;

using System.Collections.Generic;

using System.Diagnostics;

using System.Diagnostics.CodeAnalysis;

using System.Linq;

using System.Runtime.CompilerServices;

​

#nullable enable

​

class Base

{

}

​

class Derived : Base

{

}

​

class ReallyDerived : Derived

{

}

​

public static class Program

{

    static void Main()

    {

        Dictionary<Int32,ReallyDerived> dict = new Dictionary<Int32,ReallyDerived>();

        DictionaryAdapter<Int32,ReallyDerived> adapt = new DictionaryAdapter<Int32,ReallyDerived>( dict );

​

        //

​

        IReadOnlyDictionary2<Int32,ReallyDerived> orig    = adapt;

        IReadOnlyDictionary2<Int32,Derived      > variant = adapt;

​

        dict.Add( key: 123, value: new ReallyDerived() );

​

        ReallyDerived reallyDerivedValue = dict[123];

​

        Debug.Assert( variant.TryGetValue( key: 123, value: out Object? valueAsSupertype ) );

        Debug.Assert( Object.ReferenceEquals( valueAsSupertype, reallyDerivedValue ) );

​

        Console.WriteLine( "It didn't crash! ...so it worked?!" );

​

        AcceptsAVariantReadOnlyDictionary( orig );

        AcceptsAVariantReadOnlyDictionary( variant );

    }

​

    static void AcceptsAVariantReadOnlyDictionary( IReadOnlyDictionary2<Int32,Base> dict )

    {

        foreach( var kvp in dict )

        {

            Console.WriteLine( "dict[{0}]: \"{1}\"", kvp.Key, kvp.Value );

        }

    }

}

​

​

//

​

#region interface IReadOnlyDictionary2<TKey,out TValue>

​

public interface IReadOnlyDictionary2<TKey,out TValue> : IReadOnlyCollection< IPair<TKey,TValue> >

    where TKey : notnull

{

    TValue? TryGetVariantValue( TKey key, out Boolean isOK );

​

#region Tedium

​

    TValue this[TKey key] { get; }

​

    IEnumerable<TKey>   Keys   { get; }

    IEnumerable<TValue> Values { get; }

​

    Boolean ContainsKey( TKey key );

​

#endregion

}

​

public interface IPair<TKey,out TValue> : ITuple

    where TKey : notnull

{

    TKey   Key   { get; }

    TValue Value { get; }

}

​

#endregion

​

#region `class DictionaryAdapter<TKey,TValue>` + `class Dictionary2<TKey,TValue>`

​

public class DictionaryAdapter<TKey,TValue> : IReadOnlyDictionary2<TKey,TValue>

    where TKey : notnull

{

    private readonly IReadOnlyDictionary<TKey,TValue> dict;

​

    public DictionaryAdapter( IReadOnlyDictionary<TKey,TValue> dict )

    {

        this.dict = dict ?? throw new ArgumentNullException( nameof(dict) );

    }

​

    public TValue? TryGetVariantValue( TKey key, out Boolean isOK )

    {

        if( this.dict.TryGetValue( key, out TValue? value ) )

        {

            isOK = true;

            return value;

        }

        else

        {

            isOK = false;

            return default;

        }

    }

​

    #region Tedium

​

    public Int32 Count => this.dict.Count;

​

    public TValue this[TKey key] => this.dict[key];

​

    public IEnumerable<TKey>   Keys   => this.dict.Keys;

    public IEnumerable<TValue> Values => this.dict.Values;

​

    public Boolean ContainsKey( TKey key ) => this.dict.ContainsKey( key );

​

    public IEnumerator<IPair<TKey,TValue>> GetEnumerator()

    {

        using( var iter = this.dict.GetEnumerator() )

        {

            while( iter.MoveNext() )

            {

                KeyValuePair<TKey,TValue> kvp = iter.Current;

                yield return new PairImpl<TKey,TValue>( kvp.Key, kvp.Value );

            }

        }

    }

​

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

​

    #endregion

​

}

​

public class Dictionary2<TKey,TValue> : Dictionary<TKey,TValue>, IReadOnlyDictionary2<TKey,TValue>

    where TKey : notnull

{

    public Dictionary2() :

        base()

    {

    }

​

    public TValue? TryGetVariantValue( TKey key, out Boolean isOK )

    {

        if( base.TryGetValue( key, out TValue? value ) )

        {

            isOK = true;

            return value;

        }

        else

        {

            isOK = false;

            return default;

        }

    }

​

    #region Tedium

​

    public new IEnumerator<IPair<TKey,TValue>> GetEnumerator()

    {

        using( Dictionary<TKey,TValue>.Enumerator iter = base.GetEnumerator() )

        {

            while( iter.MoveNext() )

            {

                KeyValuePair<TKey,TValue> kvp = iter.Current;

                yield return new PairImpl<TKey,TValue>( kvp.Key, kvp.Value );

            }

        }

    }

​

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

​

    IEnumerable<TKey>   IReadOnlyDictionary2<TKey,TValue>.Keys   => base.Keys;

    IEnumerable<TValue> IReadOnlyDictionary2<TKey,TValue>.Values => base.Values;

​

    #endregion

​

}

​

#endregion

​

#region PairImpl and ReadOnlyDictionary2Extensions

​

internal sealed class PairImpl<TKey, TValue> : IPair<TKey, TValue>

    where TKey : notnull

{

    public PairImpl( TKey key, TValue value )

    {

        this.Key   = key;

        this.Value = value;

    }

​

    public Object? this[int index]

    {

        get

        {

            if     ( index == 0 ) return this.Key;

            else if( index == 1 ) return this.Value;

            else throw new ArgumentOutOfRangeException( paramName: nameof(index), message: "Indexer must be 0 or 1." );

        }

    }

​

    public TKey   Key   { get; }

    public TValue Value { get; }

​

    Int32 ITuple.Length => 2;

}

​

public static class ReadOnlyDictionary2Extensions

{

    public static Boolean TryGetValue<TKey,TValue,TOutValue>( this IReadOnlyDictionary2<TKey,TValue> dict, TKey key, [MaybeNullWhen(false)] out TOutValue value )

        where TKey   : notnull

        where TValue : TOutValue

    {

        TValue? gotValue = dict.TryGetVariantValue( key, isOK: out Boolean isOK );

        if( isOK )

        {

            value = gotValue;

            return true;

        }

        else

        {

            value = default;

            return false;

        }

    }

​

    public static IEnumerable<KeyValuePair<TKey,TValue>> AsEnumerable<TKey,TValue>( this IReadOnlyDictionary2<TKey,TValue> dict )

        where TKey : notnull

    {

        using( var iter = dict.GetEnumerator() )

        {

            while( iter.MoveNext() )

            {

                IPair<TKey,TValue> kvp = iter.Current;

                yield return new KeyValuePair<TKey,TValue>( kvp.Key, kvp.Value );

            }

        }

    }

​

    public static KeyValuePair<TKey,TValue> ToKvp<TKey,TValue>( this IPair<TKey,TValue> pair )

        where TKey : notnull

    {

        return new KeyValuePair<TKey,TValue>( key: pair.Key, value: pair.Value );

    }

​

    public static IReadOnlyDictionary2<TKey,TValue> AsReadOnly<TKey,TValue>( this Dictionary<TKey,TValue> dict )

        where TKey : notnull

    {

        return new DictionaryAdapter<TKey,TValue>( dict );

    }

}

​

#endregion