Do C# Arrays Truly Implement the `IList` Interface Despite Lacking a Public `Count` Property?

Arrays in C#: Breaking the IList Interface Implementation?

Question:

Arrays in C# implement IList but mysteriously lack a public Count property. Is this a violation of the interface implementation rules?

Answer:

Arrays and Generic Interfaces

Arrays in C# implement System.Collections.IList, which is not generic. They do not directly implement System.Collections.Generic.IList because they are not generic.

Hidden Implementation in CLR

However, the Common Language Runtime (CLR) creates concrete array types dynamically. These types internally use the System.SZArrayHelper class to implement the IList interface.

Compiler and CLR Knowledge

The compiler and the CLR are aware of array types and understand how to cast them to IList. The CLR provides an implementation that accesses the underlying array object through the SZArrayHelper class.

Missing Count Property

The Count property is not explicitly implemented. Instead, the CLR internally uses a method that maps to the Length property of the array:

internal int get_Count<T>() {
    T[] _this = JitHelpers.UnsafeCast<T[]>(this);
    return _this.Length;
}

Breaking the Rules?

This internal implementation arguably violates the strict interface implementation rules. However, it provides a convenient and seamless way for arrays to behave as if they implemented IList fully.

Additional Insights

• The CLR has other type substitutions, such as映射IList to IVector in the WinRT context.
• The abstraction of treating arrays as if they fully implement IList is convenient but may be misleading in some cases.
• The GetInterfaceMap() method does not work with concrete array types for generic interfaces, revealing the hidden implementation.

The above is the detailed content of Do C# Arrays Truly Implement the `IList` Interface Despite Lacking a Public `Count` Property?. For more information, please follow other related articles on the PHP Chinese website!