Please add covariant version of dictionary interface

[Thaina]

Please add interface with in / out keyword without TryGetValue and attach it to Dictionary so that we could make use for variant of it for other usage

Suppose we have

/// suppose C# has

public interface IVariantDictionary<in TKey,out TValue> { /* all common dictionary function possible to variant */ }

public class Dictionary<TKey, TValue> : IDictionary<TKey, TValue>, IDictionary
    , IReadOnlyDictionary<TKey, TValue>
    , IVariantDictionary<TKey,TValue>
    , ISerializable, IDeserializationCallback where TKey : notnull
{
/* current implementation*/
}

/// we can then

class Animal {}
class Dog : Animal {}

var dogs = new Dictionary<string,Dog>();

IVariantDictionary<string,Animal> animals = dogs;

Console.WriteLine("I have animal : " + animals.Count);

[dotnet-policy-service]

Tagging subscribers to this area: @dotnet/area-system-collections
See info in area-owners.md if you want to be subscribed.

[elgonzo]

Note that the interface having a contravariant TKey would prevent it from having a Keys property and from being enumerable.

[Thaina]

@elgonzo We could also make another interface for IKeyedCollectionOfDictionary<out TKey> or something for that purpose and define only possible member of dictionary to attach to the dictionary

I am not sure how many useful interface for variant combination we should define. But we could expand and attach to it more in future

[elgonzo]

You can't use a covariant keys collection like IKeyedCollectionOfDictionary<out TKey> with your dictionary interface having a contravariant TKey parameter.

Can you please show a concrete code example for these two methods below? Also show the concrete declaration of any members of the IVariantDictionary interface that you would need to implement these two methods.

I am asking that of you because i am not entirely sure i understand you; and i don't know whether it is because we talk past each other for some reason or whether your argument is based on an incomplete understanding of how variance works in C#.

//
// Show an example implementation for how display all the keys in the dictionary
//
void ShowAllKeys(IVariantDictionary<string, Animal> invariantDict)
{
   ????????
}

//
// Show an example implementation for iterating over the dictionary content while maintaining relation between keys and values
//
void EnumerateDictionary(IVariantDictionary<string, Animal> invariantDict)
{
   ????????
}

[Thaina]

@elgonzo I would not use IVariantDictionary<string, Animal> to enumerate the key

Instead that interface will only used for things related to value, especially getting value

On the contrary, whenever we need to do things related to key, we then switch to use other interface, such as IKeyedCollectionOfDictionary<out TKey> which will define /* all common dictionary function possible to variant */

all common dictionary function possible to variant means possible for each interface, constraint by type of the variant

[elgonzo]

Then what exactly do you need IVariantDictionary for?
Give a concrete example of something where you really need IVariantDictionary.

In your proposal, the example does not show why IVariantDictionary is needed or beneficial: IVariantDictionary<string,Animal> animals = dogs Why exactly would this assignment be necessary, or what actual problem does it solve that cannot be solved already relatively easily by using the dogs dictionary directly?

[Thaina]

@elgonzo Because I then could cast the existing dictionary to more generic variant. And share the implementation for many type of similar object that contains in any dictionary

For example

public interface IVariantDictionary<in TKey,out TValue>
{
     public bool Contains(TKey name);
     public TValue this[TKey] { get; }
}

///

Dictionary<string,Cat> catCafe;
Dictionary<string,Dog> dogCafe;

IVariantDictionary<string,Animal> animalCafe;
if(wantCat)
    animalsCafe = catCafe;
else if(wantDog)
    animalsCafe = dogCafe;

if(animalsCafe.Contains(name))
{
    Animal animal = animalsCafe[name];
    animal.Play();
}

Something like this

[elgonzo]

You can do that easily without needing something like IVariantDictionary. Just use the power of generic methods with type constraints:

void PlayWithAnimals<TAnimal>(Dictionary<string, TAnimal> animalCafe) where TAnimal : Animal
{
	foreach (var (k, v) in animalCafe)
	{
		Console.WriteLine($"Key={k}");
		v.Play();
	}
}

(Demo: https://dotnetfiddle.net/M0kTch)

[Thaina]

@elgonzo That's not the point. I want to return the dictionary of animal for other system to use and they don't need them to know what actually animal it contains, just that it is animal and so it has method shared with other animal

public interface IVariantDictionary<in TKey,out TValue>
{
     public bool Contains(TKey name);
     public TValue this[TKey] { get; }
}

///

Dictionary<string,Cat> catCafe;
Dictionary<string,Dog> dogCafe;


/** The important parts */
IVariantDictionary<string,Animal> animalCafe;
if(wantCat)
    animalsCafe = catCafe;
else if(wantDog)
    animalsCafe = dogCafe;


/**  Other system will got only animalsCafe, and can use it almost like normal dictionary */
if(animalsCafe.Contains(name))
{
    Animal animal = animalsCafe[name];
    animal.Play();
}

[elgonzo]

Then why has it to be

Dictionary<string,Cat> catCafe;
Dictionary<string,Dog> dogCafe;

to begin with?

Instead declaring your dictionaries like

Dictionary<string, Animal> catCafe;
Dictionary<string, Animal> dogCafe;

would easily solve the problem of "want[ing] to return the dictionary of animal for other system to use".

[eiriktsarpalis]

Adding interfaces to popular types like dictionary does not come without cost. I don't see how this would be useful to the vast majority of users. I would suggest either defining the interface in your own code or perhaps wrap either ContainsKey or the indexer in a Func delegate which is itself variant.