Как массивы в C# частично реализуют IList?

новый ответ в свете ответа

благодаря ответу, данному Гансом, мы можем видеть, что реализация несколько сложнее, чем мы могли бы подумать. И компилятор, и среда CLR пытаются очень тяжелый чтобы создать впечатление, что тип массива реализует IList<T> - но дисперсия массива делает это хитрее. Вопреки ответу от Hans, типы массивов (одномерные, основанные на нуле в любом случае) реализуют общие коллекции напрямую, потому что тип любого конкретного массива неSystem.Array - это просто базовый тип массива. Если вы спросите тип массива, какие интерфейсы он поддерживает, он включает в себя универсальные типы:

foreach (var type in typeof(int[]).GetInterfaces())
{
    Console.WriteLine(type);
}

выход:

System.ICloneable
System.Collections.IList
System.Collections.ICollection
System.Collections.IEnumerable
System.Collections.IStructuralComparable
System.Collections.IStructuralEquatable
System.Collections.Generic.IList`1[System.Int32]
System.Collections.Generic.ICollection`1[System.Int32]
System.Collections.Generic.IEnumerable`1[System.Int32]

для одномерных нулевых массивов, насколько язык обеспокоен, массив действительно реализует IList<T> тоже. Так сказано в разделе 12.1.2 спецификации C#. Так что базовая реализация делает, язык должен вести как бы типа T[] осуществляет IList<T> как и с любым другим интерфейсом. С этой точки зрения, интерфейс и реализовано с некоторыми явно реализуемыми членами (например,Count). Это лучшее объяснение в язык уровень для того, что происходит.

обратите внимание, что это справедливо только для одномерных массивов (и нулевых массивов, не то C# как язык говорит что-либо о ненулевых массивах). T[,]не реализовать IList<T>.

С точки зрения CLR, происходит что-то более фанковое. Вы не можете получить сопоставление интерфейса для универсальных типов интерфейса. Например:

typeof(int[]).GetInterfaceMap(typeof(ICollection<int>))

выдает исключение:

Unhandled Exception: System.ArgumentException: Interface maps for generic
interfaces on arrays cannot be retrived.

так почему же странность? Ну, я считаю, что это действительно связано с ковариацией массива, которая является бородавкой в системе типов, IMO. Даже если IList<T> is не ковариантный (и не может быть безопасным), ковариация массива позволяет это работать:

string[] strings = { "a", "b", "c" };
IList<object> objects = strings;

... что делает его посмотреть как typeof(string[]) осуществляет IList<object>, когда это на самом деле не так.

раздел 1 спецификации CLI (ECMA-335), раздел 8.7.1, имеет следующее:

тип подписи T совместим-с типом подписи U тогда и только тогда, когда хотя бы одно из следующих значений

...

T-это нулевой массив ранга-1 V[] и U и IList<W>, и V массив-элемент-совместимый-с W.

(на самом деле он не упоминает ICollection<W> или IEnumerable<W> что я считаю ошибкой в спецификации.)

для non-отклонения, спецификация CLI идет вместе с спецификацией языка сразу. Из раздела 8.9.1 раздела 1:

кроме того, созданный вектор с типом элемента T реализует интерфейс System.Collections.Generic.IList<U>, где U : = T. (§8.7)

(A вектор представляет собой одномерный массив с нулевым основанием.)

теперь с точки зрения детали реализации, очевидно, CLR делает некоторые фанки отображения, чтобы сохранить совместимость назначения здесь: когда string[] для реализации ICollection<object>.Count, он не может справиться с этим в совсем обычным способом. Считается ли это явной реализацией интерфейса? Я думаю, что это разумно рассматривайте его таким образом, как если бы вы не просили напрямую сопоставить интерфейс, он всегда поведение таким образом, с точки зрения языка.

а как же ICollection.Count?

до сих пор я говорил о универсальных интерфейсах, но тогда есть не-универсальный ICollection С Count собственность. На этот раз мы можете получить отображение интерфейса, и на самом деле интерфейс реализуется непосредственно System.Array. Этот документация для ICollection.Count реализация имущества в Array заявляет, что он реализован с явной реализацией интерфейса.

если кто-нибудь может придумать способ, которым этот вид явной реализации интерфейса отличается от "нормальной" явной реализации интерфейса, я был бы рад изучить его дальше.

старый ответ вокруг явной реализации интерфейса

несмотря на вышесказанное, что сложнее из-за знания массивов, вы все еще можете сделать что-то с теми же видимого эффекты через явная реализация интерфейса.

вот простой автономный пример:

public interface IFoo
{
    void M1();
    void M2();
}

public class Foo : IFoo
{
    // Explicit interface implementation
    void IFoo.M1() {}

    // Implicit interface implementation
    public void M2() {}
}

class Test    
{
    static void Main()
    {
        Foo foo = new Foo();

        foo.M1(); // Compile-time failure
        foo.M2(); // Fine

        IFoo ifoo = foo;
        ifoo.M1(); // Fine
        ifoo.M2(); // Fine
    }
}