[API Proposal]: Add overload of ToDictionary that turns an IEnumerable of KeyValuePair or ValueTuple

[davidfowl]

Background and motivation

Sometimes in parsing it's common transform key value pairs expressed as text into a dictionary pretty concise LINQ statement: Consider a query string parser (a=b&c=d&e=f).

Dictionary<string, string> Parse(string query) =>
    query.Split('&')
    .Select<string, (string k, string v)?>(s => s.Split('=') switch // This part is gross 😢 
    {
        [var k, var v] => (k, v),
        _ => null,
    })
    .Where(p => p is not null)
    .Select(p => p!.Value)
    .ToDictionary(p => p.k!, p => p.v!);

The last ToDictionary call wouldn't require explicitly mapping the key and value for this common case.

API Proposal

namespace System.Collections.Generic;

public static partial class Enumerable
{
    public static Dictionary<TKey, TValue> ToDictionary<TKey, TValue>(this IEnumerable<KeyValuePair<TKey, TValue>> source) where TKey : notnull;
    public static Dictionary<TKey, TValue> ToDictionary<TKey, TValue>(this IEnumerable<ValueTuple<TKey, TValue>> source) 
where TKey : notnull;
    public static Dictionary<TKey, TValue> ToDictionary<TKey, TValue>(this IEnumerable<ValueTuple<TKey, TValue>> source, IEqualityComparer<TKey> comparer) where TKey : notnull;
}

API Usage

// Fancy the value
var c = new List<(string, int)>();
c.Add(("one", 1));
c.Add(("two", 2));
c.Add(("three", 3));

var map = c.ToDictionary();

// Getting the values out
foreach (var (key, value) in map)
    Console.WriteLine($"{key} = {value}");

Alternative Designs

No response

Risks

No response

[ghost]

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

Issue Details

---

Background and motivation

Sometimes in parsing it's common transform key value pairs expressed as text into a dictionary pretty concise LINQ statement: Consider a query string parser (a=b&c=d&e=f).

Dictionary<string, string> Parse(string query) =>
    query.Split('&')
    .Select<string, (string? k, string? v)?>(s => s.Split('=') switch // This part is gross 😢 
    {
        [var k, var v] => (k, v),
        _ => null,
    })
    .Where(p => p is not null)
    .Select(p => p!.Value)
    .ToDictionary(p => p.k!, p => p.v!);

The last ToDictionary call wouldn't require explicitly mapping the key and value for this common case.

API Proposal

namespace System.Collections.Generic;

public static partial class Enumerable
{
    public static Dictionary<TKey, TSource> ToDictionary<TSource, TKey>(this IEnumerable<KeyValuePair<TSource, TKey>> source) where TKey : notnull;
    public static Dictionary<TKey, TSource> ToDictionary<TSource, TKey>(this IEnumerable<ValueTuple<TSource, TKey>> source) where TKey : notnull;
}

API Usage

// Fancy the value
var c = new List<(string, int)>();
c.Add(("one", 1));
c.Add(("two", 2));
c.Add(("three", 3));

var map = c.ToDictionary();

// Getting the values out
foreach (var (key, value) in map)
    Console.WriteLine($"{key} = {value}");

Alternative Designs

No response

Risks

No response

Author:	davidfowl
Assignees:	-
Labels:	api-suggestion, area-System.Collections, untriaged
Milestone:	-

[DrkWzrd]

I think TKey is misplaced and TSource is misleading. What should last code print in your opinion? "one = 1"? or "1 = one"?

In linq naming conventions, TSource would be KVP<K, V> or VT<V1, V2>, not K or V1.

[davidfowl]

What should last code print in your opinion? "one = 1"? or "1 = one"?

The most intuitive thing would be one = 1 😄. At least that was the intent.

What should last code print in your opinion? "one = 1"? or "1 = one"?

Sure, I don't have any hangups about the generic argument names, whatever works. The intent is that the first value of the tuple is the key (Item1) and the second is the value (Item2). I see the issue. Fixed the generic arguments.

[jnyrup]

Do you envision other benefits from this besides the fewer key strokes?

Should there also be overloads taking an IEqualityComparer<TKey>?

[eiriktsarpalis]

Sounds reasonable, proposal should probably also include equivalent IQueryable overloads cc @krwq

[davidfowl]

Do you envision other benefits from this besides the fewer key strokes?

Haven't thought about the other potential savings.

Should there also be overloads taking an IEqualityComparer<TKey>?

Possibly yes.

Sounds reasonable, proposal should probably also include equivalent IQueryable overloads cc @krwq

Do we also have ToDictionary on IQueryable? Seems strange no?

[jnyrup]

I'm asking since I recall(?) the bar of adding generic overloads to Enumerable has been a bit high and this doesn't seem to add new functionality.

[eiriktsarpalis]

Do we also have ToDictionary on IQueryable? Seems strange no?

Ah yes you're right, not applicable to To[Collection] methods.

[krwq]

The proposal seems complete and I'm not strongly opinionated on this so I'll let API reviewers decide if we want this or not. I've personally wrote similar code in the past as mentioned so I guess it is occasionally very useful.

[stephentoub]

To make sure I understand the proposal, this would simply be to enable you to write:

.ToDictionary()

instead of

.ToDictionary(p => p.Key, p => p.Value)

? Is this scenario really common enough to warrant that? If you're parsing and you care about perf, you shouldn't be using LINQ for that in the first place, so presumably perf isn't really the argument here, and it's just the usability / discoverability? Personally I'd want to see compelling evidence that this is a common use case. (I see some examples in source.dot.net, but a bunch of the uses of that overload actually transform the key or value, while others shouldn't be using ToDictionary at all and should instead just use Dictionary's copy ctor.)

[davidfowl]

Yes I have no idea how common it is in the wild, I've been using this pattern more recently with tuples and LINQ so I figured I'd file an issue.

[eiriktsarpalis]

The proposal should probably include overloads that accept an IEqualityComparer<TKey> parameter.

[davidfowl]

Updated

[Neme12]

IMO we should use named tuples wherever possible, so this would be IEnumerable<(TKey key, TValue)> instead of IEnumerable<ValueTuple<TKey, TValue>>

[Neme12]

It might be worth mentioning that there is already an extension method ImmutableDictionary.ToImmutableDictionary that takes IEnumerable<KeyValuePair<TKey, TValue>>. I think there should be some parity between these extension methods and their overloads.

There's another issue that suggests adding overloads that take ValueTuple in addition to the existing overloads that take KeyValuePair of ToImmutableDictionary: #68811. I think both of these should be looked at at the same time and the outcome should be parity between ToDictionary and ToImmutableDictionary.

[Neme12]

@davidfowl
You only added that overload for the ValueTuple variant, not for the KeyValuePair one. Also, it should most likely be nullable like in the existing overloads that take a comparer.

[TonyValenti]

I could definitely use this as I've already written the code to do these things. It makes initializing a dictionary so much more convenient.

[bartonjs]

Video

• We changed the ValueTuple<TKey, TValue> syntax to (TKey Key, TValue Value)
• We added the KVP+EqualityComparer overload to square off the proposal.
• Discussion brought up that dict.ToDictionary() looks like a clone, but actually always uses the default comparer, which might be a loss of data integrity... and this should be pointed out in docs.

namespace System.Collections.Generic;

public static partial class Enumerable
{
    public static Dictionary<TKey, TValue> ToDictionary<TKey, TValue>(this IEnumerable<KeyValuePair<TKey, TValue>> source) where TKey : notnull;
    public static Dictionary<TKey, TValue> ToDictionary<TKey, TValue>(this IEnumerable<KeyValuePair<TKey, TValue>> source, IEqualityComparer<TKey> comparer) where TKey : notnull;
    public static Dictionary<TKey, TValue> ToDictionary<TKey, TValue>(this IEnumerable<(TKey Key, TValue Value)> source) where TKey : notnull;
    public static Dictionary<TKey, TValue> ToDictionary<TKey, TValue>(this IEnumerable<(TKey Key, TValue Value)> source, IEqualityComparer<TKey> comparer) where TKey : notnull;
}

[lateapexearlyspeed]

Hi, PR is marked as ready for review now, thanks.