Dictionary, List and other Collection should have Empty concept

[juliusfriedman]

Background and Motivation

Like Array.Empty one typically wants an empty version of a collection. We already have as @vcsjones pointed out below:

ImmutableDictionary<TKey,TValue>.Empty Field
ImmutableHashSet.Empty Field
ImmutableList.Empty Field

These are not easily discover-able from the types which most developers start out using e.g. List<T>, Dictionary<TKey,TValue>, HashSet<T>.

There is also the ISet<T> Interface to which one can easily use Enumerable.Empty<T>(); to fulfill.

ICollection<T> implements System.Collections.Generic.IEnumerable<T> and adds Count and IsReadOnly

One can easily use

System.Collections.Generic.ICollection<int> test = (System.Collections.Generic.ICollection<int>)Array.Empty<int>();

However one cannot use

System.Collections.Generic.ICollection<int> test = (System.Collections.Generic.ICollection<int>)Enumerable.Empty<int>(); as it gives a:

Unable to cast object of type 'System.Linq.EmptyPartition1[System.Int32]' to type 'System.Collections.Generic.ICollection1[System.Int32]'.
--

See also: Partition.SpeedOpt.cs EmptyPartition<T>

See also: #27552

Proposed API

namespace System.Linq
{
     internal sealed class EmptyPartition<TElement> : IPartition<TElement>, IEnumerator<TElement>,  
+ ICollection<TElement>{
+ internal static  readonly EmptyPartition<TElement> Empty => new EmptyPartition<TElement>();
+ ICollection<TElement>.Count => 0;
+ ICollection<TElement>.IsReadyOnly => true;
}

namespace System.Collections.Generic
{
     public interface ICollection<T> : System.Collections.Generic.IEnumerable<T>{
+ ICollection<T> GetDefaultEmptyCollection() => EmptyPartition<T>.Empty;
}

Hopefully this also allows for it to be derived and overridden if required, not sure with DIM's.

Usage Examples

Especially useful once nullable enable is applied, you either have to choose to annotate the types that they may return null or you can use the Empty Sentinel.

Alternative Designs

Default implementation methods on IDictionary, EmptyCollections class or additions to almost all collections.

Make EmptyParition public and point to it's Empty member explicitly from ICollection

Risks

Low , Similar to someone hijacking new or Array Constructor or patching the Empty method itself.

Benefits

It provides a more straight forward way to create non null returning API's and you don't have to create the Sentinel yourself. Albeit is trivial to have such a EmptyCollection class with these required sentinel values.

Tagging subscribers to this area: @eiriktsarpalis
Notify danmosemsft if you want to be subscribed.

[vcsjones]

This was discussed in #24031 and that ImmutableDictionary and ImmutableList have an Empty member that works for IDictionary and IList, respectively.

using System.Collections.Generic;
using System.Collections.Immutable;

public class C {
    public void M() {
        Foo(ImmutableDictionary<string, int>.Empty);
        Foo(ImmutableList<string>.Empty);
    }
    
    private static void Foo(IDictionary<string, int> x) {
    }
    
    private static void Foo(IList<string> x) {
    }
}

[jkotas]

Duplicate of #24031

[danmoseley]

@juliusfriedman you might consider updating the top post to explicitly list the public API you want (eg including HashSet if you want it) so it can be considered together.

[danmoseley]

Oh yes. I guess it is rare a empty concrete Dictionary<K,V> is needed.

[juliusfriedman]

@danmosemsft Will do

@jkotas I agree in the aspect of Dictionary as proposed it is a duplicate

I need to think this through a bit and will update the proposal in due course, I feel that ICollection etc should probably support this as well.

[danmoseley]

My comment overlapped with closing it - I do not have an opinion on whether it is worth reconsidering it. But perhaps the properties on ImmutableDictionary/ImmutableList are not as discoverable as we would like.

[juliusfriedman]

Since we also have ToHashSet from Linq I feel like HashSet definitely needs support for an Empty, I feel like it's handled by when the underlying Enumerable is empty and via ImmutableHashSet<T> as @vcsjones indicated.

I agree that the discover-ability may be slightly less than desired and hence why I mentioned default interface implementations.

An alternate design might be an interface IEmpty<T> to which can be added to ICollection<T> etc and where the default implementation could live...

Let me know if you need more from me in any regard.

Thank you all for your time!