C# 4.0: полное руководство - Герберт Шилдт

    // ссылку на него переменной iOb типа Gen<int>.

    iOb = new Gen2<int>(99);

    // Здесь вызывается вариант метода GetOb() из класса Gen2.

    Console.WriteLine(iOb.GetOb());

  }

}

Ниже приведен результат выполнения этой программы.

Метод GetOb() из класса Gen возвращает результат: 88

Метод GetOb() из класса Gen2 возвращает результат: 99

Как следует из результата выполнения приведенной выше программы, переопределяемый вариант метода GetOb() вызывается для объекта типа Gen2, а его вариант из базового класса вызывается для объекта типа Gen.

Обратите внимание на следующую строку кода.

iOb = new Gen2<int>(99);

Такое присваивание вполне допустимо, поскольку iOb является переменной типа Gen<int>. Следовательно, она может ссылаться на любой объект типа Gen<int> или же объект класса, производного от Gen<int>, включая и Gen2<int>. Разумеется, переменную iOb нельзя использовать, например, для ссылки на объект типа Gen2<int>, поскольку это может привести к несоответствию типов.

Перегрузка методов с несколькими параметрами типа

Методы, параметры которых объявляются с помощью параметров типа, могут быть перегружены. Но правила их перегрузки упрощаются по сравнению с методами без параметров типа. Как правило, метод, в котором параметр типа служит для указания типа данных параметра этого метода, может быть перегружен при условии, что сигнатуры обоих его вариантов отличаются. Это означает, что оба варианта перегружаемого метода должны отличаться по типу или количеству их параметров. Но типовые различия должны определяться не по параметру обобщенного типа, а исходя из аргумента типа, подставляемого вместо параметра типа при конструировании объекта этого типа. Следовательно, метод с параметрами типа может быть перегружен таким образом, что он окажется пригодным не для всех возможных случаев, хотя и будет выглядеть верно.

В качестве примера рассмотрим следующий обобщенный класс.

// Пример неоднозначности, к которой может привести

// перегрузка методов с параметрами типа.

//

// Этот код не подлежит компиляции,

using System;

// Обобщенный класс, содержащий метод Set(), перегрузка

// которого может привести к неоднозначности,

class Gen<T, V> {

  T ob1;

  V ob2;

  // ...

  // В некоторых случаях эти два метода не будут

  // отличаться своими параметрами типа,

  public void Set(T о) {

    ob1 = о;

  }

  public void Set(V o) {

    ob2 = o;

  }

}

class AmbiguityDemo {

  static void Main() {

    Gen<int, double> ok = new Gen<int, double>();

    Gen<int, int> notOK = new Gen<int, int>();

    ok.Set(10); // верно, поскольку аргументы типа отличаются

    notOK.Set(10); // неоднозначно, поскольку аргументы ничем не отличаются!

  }

}

Рассмотрим приведенный выше код более подробно. Прежде всего обратите внимание на то, что класс Gen объявляется с двумя параметрами типа: Т и V. В классе Gen метод Set() перегружается по параметрам типа Т и V, как показано ниже.

public void Set (T о) {

  ob1 = о;

}

public void Set(V o) {

  ob2 = o;

}

Такой подход кажется вполне обоснованным, поскольку типы Т и V ничем внешне не отличаются. Но подобная перегрузка таит в себе потенциальную неоднозначность.

При таком объявлении класса Gen не соблюдается никаких требований к различению типов Т и V. Например, нет ничего принципиально неправильного в том, что объект класса Gen будет сконструирован так, как показано ниже.

Gen<int, int> notOK = new Gen<int, int>();

В данном случае оба типа, Т и V, заменяются типом int. В итоге оба варианта метода Set() оказываются совершенно одинаковыми, что, разумеется, приводит к ошибке. Следовательно, при последующей попытке вызвать метод Set() для объекта notOK в методе Main() появится сообщение об ошибке вследствие неоднозначности во время компиляции.

Как правило, методы с параметрами типа перегружаются при условии, что объект конструируемого типа не приводит к конфликту. Следует, однако, иметь в виду, что ограничения на типы не учитываются при разрешении конфликтов, возникающих при перегрузке методов. Поэтому ограничения на типы нельзя использовать для исключения неоднозначности. Конструкторы, операторы и индексаторы с параметрами типа могут быть перегружены аналогично конструкторам по тем же самым правилам.

Ковариантность и контравариантность в параметрах обобщенного типа

В главе 15 ковариантность и контравариантность были рассмотрены в связи с необобщенными делегатами. Эта форма ковариантности и контравариантности по-прежнему поддерживается в С#, поскольку она очень полезна. Но в версии C# 4.0 возможности ковариантности и контравариантности были расширены до параметров обобщенного типа, применяемых в обобщенных интерфейсах и делегатах. Ковариантность и контравариантность применяется, главным образом, для рационального разрешения особых ситуаций, возникающих в связи с применением обобщенных интерфейсов и делегатов, определенных в среде .NET Framework. И поэтому некоторые интерфейсы и делегаты, определенные в библиотеке, были обновлены, чтобы использовать ковариантность и контравариантность параметров типа. Разумеется, преимуществами ковариантности и контравариантности можно также воспользоваться в интерфейсах и делегатах, создаваемых собственными силами. В этом разделе механизмы ковариантности и контравариантности параметров типа поясняются на конкретных примерах.

Применение ковариантности в обобщенном интерфейсе

Применительно к обобщенному интерфейсу ковариантность служит средством, разрешающим методу возвращать тип, производный от класса, указанного в параметре типа. В прошлом возвращаемый тип должен был в точности соответствовать параметру типа в силу строгой проверки обобщений на соответствие типов. Ковариантность смягчает это строгое правило таким образом, чтобы обеспечить типовую безопасность. Параметр ковариантного типа объявляется с помощью ключевого слова out, которое предваряет имя этого параметра.

Для того чтобы стали понятнее последствия применения ковариантности, обратимся к конкретному примеру. Ниже приведен очень простой интерфейс IMyCoVarGenIF, в котором применяется ковариантность.

//В этом обобщенном интерфейсе поддерживается ковариантность,

public interface IMyCoVarGenIF<out Т> {

  Т GetObject();

}

Обратите особое внимание на то, как объявляется параметр обобщенного типа Т. Его имени предшествует ключевое слово out. В данном контексте ключевое слово out обозначает, что обобщенный тип Т является ковариантным. А раз он ковариантный, то метод GetObject() может возвращать ссылку на обобщенный тип Т или же ссылку на любой класс, производный от типа Т.

Несмотря на свою ковариантность по отношению к обобщенному типу Т, интерфейс IMyCoVarGenIF реализуется аналогично любому другому обобщенному интерфейсу. Ниже приведен пример реализации этого интерфейса в классе MyClass.

// Реализовать интерфейс IMyCoVarGenIF.

class MyClass<T> : IMyCoVarGenIF<T> {

  T obj;

  public MyClass(T v) {

    obj = v;

  }

  public T GetObject() {

    return obj;

  }

}

Обратите внимание на то, что ключевое слово out не указывается еще раз в выражении, объявляющем реализацию данного интерфейса в классе MyClass. Это не только не нужно, но и вредно, поскольку всякая попытка еще раз указать ключевое слово out будет расцениваться компилятором как ошибка.