Collection Expression interactions w/ Add functions

[dazerdude]

So I'm trying to make this statement work w/ new the new Collection Expressions

public static Dictionary<string, string> StringDict = [("Value1", "Value2")];

The error received is Cannot convert type (string, string) to KeyValuePair<string, string> which makes total sense as there's no implicit conversion between the types and I can't add one as I own neither. I tried a bit fruitlessly to define my own static Create method, but also can't add the relevant [CollectionBuilder] attribute to Dictionary.

Reading the documentation about construction of types which implement IEnumerable and lack Create, it seems like I should be able to declare an extension method which bridges the gap.

public static void Add<TKey, TVal>(this Dictionary<TKey, TVal> dict, (TKey key, TVal val) item)
    where TKey : notnull => dict.Add(item.key, item.val);

This doesn't work however. Experimenting a bit with my own type though revealed an odd inconsistency between the behavior with regards to the generic and non-generic versions of IEnumerable.

public class BasicDict<TKey, TVal> : System.Collections.IEnumerable { ... }
public class GenericDict<TKey, TVal> : System.Collections.Generic.IEnumerable<int> { ... }

public static class DictExt
{
    public static BasicDict<string, string> StringDict1 = [("Value1", "Value2")];   // Works
    public static GenericDict<string, string> StringDict2 = [("Value1", "Value2")];   // Fails
    public static BasicDict<string, string> StringDict3 = new() { ("Value1", "Value2") };  // Works
    public static GenericDict<string, string> StringDict4 = new() { ("Value1", "Value2") };  // Works
    
    public static void Add<TKey, TVal>(this BasicDict<TKey, TVal> dict, (TKey key, TVal val) item) { ... }
    public static void Add<TKey, TVal>(this GenericDict<TKey, TVal> dict, (TKey key, TVal val) item) { ... }
}

The compiler appears to be able to find and use my Add extension method when we implement System.Collections.IEnumerable but not System.Collections.Generic.IEnumerable even though the later extends the former. By contrast the equivalent old-style collection initializer find the Add extension regardless of IEnumerable's type parameter.

The same behavior persists not just for extensions, but for class methods as well. Is this difference in lookup behavior intentional? From the outside it appears mildly buggy. Is there some reason that the argument to Add must match the type passed to IEnumerable? It just seems especially odd given that it works fine if the class only implements the non-generic version of IEnumerable.

[333fred]

We do not yet have support for dictionaries in collection expressions. That work is currently scheduled for C# 13; at that point, we hope to have a syntax closer to ["Value1": "Value2"]. Until then, this isn't going to work.

[dazerdude]

This page says it looks for Add functions when a type doesn't declare a Create function and implements IEnumerable and that's the behavior I currently see for dictionaries. This compiles w/o error for example:

public static class Ext
{
    private static readonly Dictionary<string, string> StringDict = [new KeyValuePair<string, string>("Key", "Value")];
    public static void Add<TKey, TVal>(this Dictionary<TKey, TVal> dict, KeyValuePair<TKey, TVal> pair) => dict.Add(pair.Key, pair.Value);
}

[333fred]

In order to get to constructing the collection expression, you first have to be able to convert the collection expression to the destination type. That is covered earlier: https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/proposals/csharp-12.0/collection-expressions#conversions.

[dazerdude]

Oh I see. This is a long page and I missed that there's a two distinct conversion rules here. This still doesn't really answer my original question. Why is this the case? Is there some reason that the compiler can't or shouldn't fall back to the "type implements IEnumerable" conversion rule when the "type implements IEnumerable<T>" conversion rule fails?

I couldn't find much discussion about the topic, but maybe I missed something in my searches.

[333fred]

We did that for a few reasons: first, we're concerned about the stability of the error experience, and second, IEnumerable (non-generic) scenarios are generally in legacy collection types that we don't intend to fully support. You can read the notes from the meeting that elaborate these reasons more completely: https://github.com/dotnet/csharplang/blob/main/meetings/2023/LDM-2023-10-02.md#collection-expressions.

[dazerdude]

Awesome. These meeting minutes are precisely what I was looking for. Thanks for the discussion. This has been extremely enlightening and I greatly appreciate it.

[333fred]

Glad to help!

[jnm2]

However, there is a bearable alternative (#7666 (comment)):

public static Dictionary<string, string> StringDict = [new("Value1", "Value2")];

[FaustVX]

If you want just that syntax (but probably not the efficiency),
You could create your own wrapper class, which implement IEnumerable<(TKey, TValue)>

MyDictionary<string, string> StringDict = [("Value1", "Value2")];

public class MyDictionary<TKey, TValue> : IEnumerable<(TKey, TValue)>
{
    public Dictionary<TKey, TValue> Dictionary { get; } = new();
    
    public void Add((TKey, TValue) item)
    => Dictionary.Add(item.Item1, item.Item2);
}

sharplab.io

[jnm2]

Before I'd do that, I'd personally use a static helper method:

Dictionary<string, string> stringDict = Create.Dictionary([("Value1", "Value2")]);