Support additional restrictions on typed parameters for methods

[AlexRadch]

I suggest supporting ReadOnlySpan and Span as parameters in typed Dictionary<string, TValue>, HashSet<string>, and so on classes.

Unfortunately, we can not use HashSet<string>.Contains method with Span<char> without creating a new string on the Heap or using the string pool.

public static class AClass
{
    private static HashSet<string> IgnoryWords = new HashSet<string>()
        {
            "the", "of", "in", "from", "by", "with", "and", "or", "for", "to", "at", "a"
        };

    // Using string pool any way will copy span memory to pooled string
    public static bool IsIgnoryWord(this ReadOnlySpan<char> word) =>
        IgnoryWords.Contains(new string(word)); // creates string on Heap 🤦‍♂️
}

We can use a string pool but it isn't easy and will copy span memory to pooled string in any way.

So I suggest enabling to define methods in classes and interfaces with additional restrictions on typed parameters.

For Example

public class HashSet<T>
{
	public bool Contains(ReadOnlySpan<char> span) **where T : string** // additional restrictions on typed parameter!!!
		=> throw new NotImplementedException();
}

Now that syntax is disabled, see https://learn.microsoft.com/en-us/dotnet/csharp/misc/cs0080

I suggest enabling that syntax to support additional methods when typed parameters have some additional restrictions only for that methods.

So Contains(ReadOnlySpan<char> span) method will have only string HashSet HashSet<string>.

[svick]

The request for a span-based indexing into a Dictionary<string, TValue> is tracked by dotnet/runtime#27229 (which also briefly mentioned HashSet<string>). As mentioned there, it could be implemented today by the runtime using extension methods:

public static class DictionaryExtensions
{
    public static bool ContainsKey<TValue>(this Dictionary<string, TValue> dictionary, ReadOnlySpan<char> key);
    public static bool Remove<TValue>(this Dictionary<string, TValue> dictionary, ReadOnlySpan<char> key);
    public static bool TryGetValue<TValue>(this Dictionary<string, TValue> dictionary, ReadOnlySpan<char> key, out TValue value);
    public static T GetValue<TValue>(this Dictionary<string, TValue> dictionary, ReadOnlySpan<char> key);
}

And having a decent alternative makes the proposed feature less useful.

Another hurdle is that adding this feature would very likely require runtime changes.

[AlexRadch]

New C# syntax will look cleaner than extension methods for which the class should open internal methods, fields, and properties.

[CyrusNajmabadi]

Accessing internals is definitely not allowed. That would violate safety for tons of types.

[ufcpp]

#1315

[koszeggy]

Just a side note in case you can't wait for it to be added to .NET: my core libraries contain a StringKeyedDictionary<TValue> class since .NET 5.0 (but older targets are also supported) that supports lookups with ReadOnlySpan<char> instances (NuGet, source).

[CyrusNajmabadi]

Moving to runtime as this appears to be an API request.

[AlexRadch]

Also, the extension method can not be virtual, and so on disadvantages.

[AlexRadch]

Can you return this discussion to the C# Language repository?

[koszeggy]

If you only want to be able to use Contains[Key]/TryGetValue/etc. with ReadOnlySpan<char> for string keys, why is it so important for you to have a new language feature after all? You would not use the new C# syntax, just use a feature specific to Dictionary<string, TValue>/HashSet<string>.

New C# syntax will look cleaner than extension methods for which the class should open internal methods, fields, and properties.

A public extension method in the core library can use the internals of Dictionary<TKey, TValue> just like as CollectionMarshal accesses the internals of List<T> and Dictionary<TKey, TValue> without exposing anything to other assemblies.

And an extension method specifically for string key is cleaner than polluting the generic class itself by exceptional logic specific for the various possible generic arguments.

But a specialized StringKeyDictionary<TValue> could maybe even cleaner. #27229 plans it to be derived from Dictionary<string, TValue>, whereas my already existing version is a complete implementation from scratch so it can use a special comparer that is able to compare a string to ReadOnlySpan<char> without extra allocations.

[AlexRadch]

I think the new syntax would be useful not only for Dictionary<string, TValue>/HashSet but for many other methods where the method must have additional restrictions for typed parameters. Especially if the methods must be virtual because virtual methods cannot be implemented as extension methods.

My suggestion is not to add Span support to Dictionary<string, TValue>/HashSet but for all similar cases also. I published this suggestion to C# Language repository, but @CyrusNajmabadi moved it to this repository and I can not move it back.

[koszeggy]

@CyrusNajmabadi moved it to this repository and I can not move it back

This is the csharplang repository. He moved it back about 11 hours ago. Isn't this what you requested?

I think the new syntax would be useful not only for Dictionary<string, TValue>/HashSet but for many other methods where the method must have additional restrictions for typed parameters.

Could you provide an example?

Especially if the methods must be virtual because virtual methods cannot be implemented as extension methods.

This is the 2nd time you use this reasoning but an example would be useful because it's a bit unclear what you want to achieve. You can "override" an extension method behavior by specifying a new extension method with the same name on a more specialized type. A nice example is LINQ where the "base" operations are in the Enumerable class, just like Contains(IEnumerable<T>, TSource), which is "overridden" in Contains(IQueryable<T>, TSource), Contains(ParallelQuery<TSource>, TSource), etc.