Add Invariant IReadOnlyCollection<T> and IReadOnlyList<T> interfaces

[TylerBrinkley]

If #31001 gets implemented through default interface implementation the next logical addition would be to add invariant versions of the IReadOnlyCollection<T> and IReadOnlyList<T> interfaces as some of the read-only methods on ICollection<T> and IList<T> were not included in the read-only interfaces because that would prevent the generic type argument from being declared covariant. ICollection<T> and IList<T> would then inherit these new interfaces and use default interface implementation to forward their calls to their own versions.

Proposed API

 namespace System.Collections.Generic {
+    public interface IReadOnlyCollectionInvariant<T> : IReadOnlyCollection<T> {
+        bool Contains(T item);
+    }
-    public interface ICollection<T> : IReadOnlyCollection<T> {
+    public interface ICollection<T> : IReadOnlyCollectionInvariant<T> {
-        bool Contains(T item);
+        new bool Contains(T item);
+        bool IReadOnlyCollectionInvariant<T>.Contains(T item) => Contains(item);
     }
+    public interface IReadOnlyListInvariant<T> : IReadOnlyList<T>, IReadOnlyCollectionInvariant<T> {
+        int IndexOf(T item);
+    }
-    public interface IList<T> : ICollection<T>, IReadOnlyList<T> {
+    public interface IList<T> : ICollection<T>, IReadOnlyListInvariant<T> {
-        int IndexOf(T item);
+        new int IndexOf(T item);
+        int IReadOnlyListInvariant<T>.IndexOf(T item) => IndexOf(item);
     }
-    public interface IReadOnlySet<T> : IReadOnlyCollection<T> {
+    public interface IReadOnlySet<T> : IReadOnlyCollectionInvariant<T> {
-        bool Contains(T value);
+        new bool Contains(T value);
+        bool IReadOnlyCollectionInvariant<T>.Contains(T value) => Contains(value);
     }
-    public interface IReadOnlyDictionary<TKey, TValue> : IReadOnlyCollection<KeyValuePair<TKey, TValue>> {
+    public interface IReadOnlyDictionary<TKey, TValue> : IReadOnlyCollectionInvariant<KeyValuePair<TKey, TValue>> {
+        bool IReadOnlyCollectionInvariant<KeyValuePair<TKey, TValue>>.Contains(KeyValuePair<TKey, TValue> item) => TryGetValue(item.Key, out var value) && EqualityComparer<TValue>.Default.Equals(value, item.Value);
     }
     public interface IDictionary<TKey, TValue> : ICollection<KeyValuePair<TKey, TValue>>, IReadOnlyDictionary<TKey, TValue> {
+        bool IReadOnlyCollectionInvariant<KeyValuePair<TKey, TValue>>.Contains(KeyValuePair<TKey, TValue> item) => ((ICollection<KeyValuePair<TKey, TValue>>)this).Contains(item); // Avoids the diamond problem
     }
 }

Open Questions

• Will adding these interfaces and the generic interface implementations cause significant code-bloat?
• Is using an Invariant suffix a good naming pattern?
• Should the CopyTo method be included as it seems to be a deprecated API or at least from my perspective?

Updates

• Removed CopyTo method as it appears to be a deprecated API.

[eiriktsarpalis]

Are Contains and IndexOf the only methods to be added to the invariant subtypes? If so it feels like a lot of added complexity in order to accommodate a scenario that could in principle be obtained using enumeration or indexers.

Is using an Invariant suffix a good naming pattern?

Not sure I like, but I can't think of anything better either.

[TylerBrinkley]

At this point I don't really advocate for making this change due to the added complexity. If someone else would like to keep this issue open please let me know and I can re-open.