[API Proposal]: Add System.Collections.Concurrent.ConcurrentSet<T>

[MapleWheels]

Copying this issue but with a change to the type's purpose.

I didn't see any open issues on this repo for it. If there are, sorry in advance.

This is something I was searching for when I needed to create a collection with near O(1) lookup of combined key-values, where the struct itself contains the key and value data, this is very useful in both resource lookups with custom Multi-Key (OR compare logic against select members) types for dictionaries.

This is very useful for in-memory resources lookups from disk-loaded or network-retrieved assets. See below for an example of a sample based on our usage. The implementation is similar to the previous proposal but with the addition of some new functions to justify it's use.

This should already be a thing, because .NET already implements this in the default HashSet<T> with my exact justification in the remarks: source

API Proposal:

Proposal for modified continuation of implementation of: ConcurrentSet<T> but type T should implement IEqualityComparer<T>. The use cases here is key-value being in the same struct so the default comparer is probably not going to work.

namespace System.Collections.Concurrent;

public class ConcurrentSet<T> : : System.Collections.Generic.ICollection<T>, System.Collections.Generic.IEnumerable<T>, System.Collections.Generic.IReadOnlyCollection<T>, System.Collections.ICollection,System.Collections.IEnumerable 
where T : notnull, IEqualityComparer<T>
{
    // partial API additions to: https://github.com/dotnet/runtime/issues/39919
    
    /// <summary>
    /// Adds the given value to, or replaces an existing value with the same equality in, the set.
    /// </summary>
    /// <param name="newValue">The new value to replace.</param>
    /// <returns></returns>
    public void AddOrReplace(T newValue){ /* */}
}

Usage Sample

// data  class
public readonly record struct AssemblyStringResource : IEqualityComparer<AssemblyStringResource>
{
    public readonly string AssemblyName;
    public readonly Assembly Assembly;

    // other data not keyed, could be MetaRefs, etc.
    public readonly int SomeData1;
    public readonly float SomeData2;
    public readonly bool SomeData3;
    
    public readonly int HashCode;

    // data struct creation
    public AssemblyStringResource(Assembly assembly, int someData1, float someData2, bool someData3)
    {
        Assembly = assembly;
        AssemblyName = assembly.GetName().Name; 
        // just using the name string for the sake of example
        HashCode = AssemblyName!.GetHashCode(); 
        SomeData1 = someData1;
        SomeData2 = someData2;
        SomeData3 = someData3;
    }

    // key ctor: Assembly
    public AssemblyStringResource(Assembly assembly)
    {
        if (assembly == null)
            throw new ArgumentNullException(nameof(assembly));
        Assembly = assembly;
        AssemblyName = assembly.GetName().Name;
        // just using the name string for the sake of example
        HashCode = AssemblyName!.GetHashCode(); 
    }

    // key ctor: AssemblyName
    public AssemblyStringResource(string assemblyName)
    {
        if (assemblyName.IsNullOrEmpty())
            throw new ArgumentNullException(nameof(assemblyName));
        AssemblyName = assemblyName;
        // just using the name string for the sake of example
        HashCode = AssemblyName!.GetHashCode(); 
        Assembly = null;
    }
    
    public static implicit operator AssemblyStringResource(Assembly assembly) => new AssemblyStringResource(assembly);
    public static implicit operator AssemblyStringResource(string assemblyName) => new AssemblyStringResource(assemblyName);

    public bool Equals(AssemblyStringResource x, AssemblyStringResource y)
    {
        if (x == y)
            return true;
        if (x.Assembly is not null && y.Assembly is not null)
            return x.Assembly == y.Assembly;
        if (!x.AssemblyName.IsNullOrEmpty() && y.AssemblyName.IsNullOrEmpty())
            return x.AssemblyName == y.AssemblyName;
        return false;
    }

    public int GetHashCode(AssemblyStringResource obj)
    {
        return obj.HashCode;
    }

    public override int GetHashCode()
    {
        return GetHashCode(this);
    }

    public override string ToString()
    {
        return AssemblyName;
    }

    public bool Equals(AssemblyStringResource? other)
    {
        return Equals(this, other);
    }
}


// example usage:

public interface IAssemblyService
{
    bool IsAssemblyLoaded(string assemblyName);
    IEnumerable<Type> GetTypesInAssembly(string assemblyname);
}

internal interface IIIInternalAssemblyService
{
    bool TryGetAssemblyRes(Assembly assembly, out AssemblyStringResource? res);
    bool TryGetAssemblyRes(string assembly, out AssemblyStringResource? res);
    void UpdateAssemblyList(AssemblyStringResource res);
}


// I know this isn't proper code, it's just an example :)
public class AssemblyService :  IAssemblyService, IIIInternalAssemblyService
{
    private readonly ConcurrentSet<AssemblyStringResource> _assemblyResources = new();

    public AssemblyService(IResourceService service)
    {
        foreach (var res in service.GetAssemblyResources())
        {
            _assemblyResources.Add(res); // populate
        }
    }

    bool IAssemblyService.IsAssemblyLoaded(string assemblyName)
    {
        return _assemblyResources.Contains(assemblyName); // implicit conversion search
    }

    IEnumerable<Type> IAssemblyService.GetTypesInAssembly(string assemblyName)
    {
        if (!_assemblyResources.TryGetValue(assemblyName, out var res)
            return null;
        if (res.Assembly is null)
        {
            return null;
        }
        return Assembly.GetTypes();
    }

    bool IIIInternalAssemblyService.TryGetAssemblyRes(Assembly assembly, out AssemblyStringResource? res)
    {
        if (!_assemblyResources.TryGetValue(assembly, out var res)
        {
            res = null;
            return false;
        }
        return res;
    }
    bool IIIInternalAssemblyService.TryGetAssemblyRes(string assembly, out AssemblyStringResource? res)
    {
        if (!_assemblyResources.TryGetValue(assembly, out var res)
        {
            res = null;
            return false;
        }
        return res;
    }

    void IIIInternalAssemblyService.UpdateAssemblyList(AssemblyStringResource res)
    {
         _assemblyResources.AddOrUpdate(res);
    }
}

[333fred]

You're looking for dotnet/runtime for new API proposals. This repo is for the C# language itself.

[MapleWheels]

Ah okay, I remember reading a post saying that proposals were moved here but I misunderstood. Thanks.

[jnm2]

Language proposals are moved here, but not API proposals.