Python's collection.Counter equivalent in C# or .NET

Here is a performant implementation of a ToCounter LINQ operator, that takes an enumerable sequence and returns a dictionary with the elements of the sequence as keys. The int value of the resulting dictionary represents the number of times each element appears in the source sequence:

public static Dictionary<TSource, int> ToCounter<TSource>(
this IEnumerable<TSource> source,
IEqualityComparer<TSource>? comparer = default) where TSource : notnull
{
    ArgumentNullException.ThrowIfNull(source);

    Dictionary<TSource, int> dictionary = new(comparer);
    foreach (TSource item in source)
    {
        CollectionsMarshal.GetValueRefOrAddDefault(dictionary, item, out _)++;
    }
    return dictionary;
}

The CollectionsMarshal.GetValueRefOrAddDefault is an advanced API, that allows to add or update a dictionary with a single GetHashCode invocation for the key. The default value of the int type is 0, which makes the implementation pretty simple (no need to declare a ref local variable).

I made a NuGet package a few days ago just for 'fun' Pythonize.Counter.Net. I've never thought someone will actually want to search for it. Then I found this thread.

Example usage:

var value = "abacaba";
var counter = new Counter<char>(value);
var counts = counter.Get();
// Output:
// {['a',: 4], ['b', 2], ['c', 1] }

Here is a real quick implementation of a class that does what you are thinking about. Feel free to add some extra features:

public class CountedCollection<T> : IEnumerable<KeyValuePair<T, int>>
{
    private readonly Dictionary<T, int> _countDictionary;

    public CountedCollection()
    {
        if (!typeof(IEquatable<T>).IsAssignableFrom(typeof(T)))
        {
            throw new ArgumentException($"The type {typeof(T).Name} must implement IEquatable of <{typeof(T).Name}> to be usable with CountedCollection");
        }
        _countDictionary = new Dictionary<T, int>();
    }

    public CountedCollection(IEqualityComparer<T> comparer)
    {
        _countDictionary = new Dictionary<T, int>(comparer);
    }

    public void Add(T item)
    {
        ++TotalCount;
        if (_countDictionary.TryGetValue(item, out var curCount))
        {
            _countDictionary[item] = ++curCount;
        }
        else
        {
            _countDictionary.Add(item, 1);
        }
    }

    public void Add (IEnumerable<T> items)
    {
        foreach (var item in items)
        {
            Add(item);
        }
    }

    public int TotalCount { get; private set; } = 0;
    public int DistinctCount => _countDictionary.Count;

    public IEnumerator<KeyValuePair<T, int>> GetEnumerator()
    {
        foreach (var item in _countDictionary)
        {
            yield return item;
        }
    }

    IEnumerator IEnumerable.GetEnumerator()
    {
        return GetEnumerator();
    }
}

It's very lightly tested.

It implements the "Collection Initialization Pattern" and it can be initialized with an existing collection, so both of these work (the second one initializes it using an array of integers):

var dict1 = new CountedCollection<string> { "abc", "xyz", "abc", "123" };
var dict2 = new CountedCollection<int> { new[] { 34, 12, 65, 12, 101 } };

The class provides two constructors. If T doesn't implement IEquatable<T>, then you can provide your own implementation of an IEqualityComparer<T>. This also allows you to do case independent counting of instances. For example:

var dict3 = new CountedCollection<string>(StringComparer.OrdinalIgnoreCase) 
{ 
    "abc", 
    "xyz", 
    "ABC", 
    "123", 
    "Xyz"
};

That code will show two instances of "abc" and two instances of "xyz".

Because you can bring your own IEqualityComparer<T>, T is not constrained to implement IEquatable<T>, the first constructor will throw an ArgumentException if T fails to implement IEquatable<T> (things must be comparable for equality somehow).

For example, this will throw:

var dict4 = new CountedCollection<CountedCollection<string>>();