C#. Обобщения: понятие и синтаксис. Ограничения обобщений.

Понятие

Обобщение (generic) — механизм, поддерживающий повторное использование алгоритмов

Поддерживаются:

 обобщение типов (кроме перечислений)

 обобщение интерфейсов

 обобщение методов

Обобщение типа

class ИмяКласса<ПараметрТип>

{

// определение класса

// ПараметрТип указывается везде,

// где используется соответствующий тип

// данных

}

Обобщение типа — пример

interface ICacheProvider<T> {

void Store(string key, T o);

T Load(string key);

}

class MemoryCacheProvider<T> : ICacheProvider<T> {

private Dictionary<string, T> cache =

new Dictionary<string, T>();

public void Store(string key, T o) { ... }

public T Load(string key) { ... }

}

Использование обобщений

static void Main(string[] args) {

ICacheProvider<int> cacheProvider =

       new MemoryCacheProvider<int>();

cacheProvider.Store("foo", 5);

}

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

 защита исходного кода

 безопасность типов

 простой и понятный код

 повышение производительности

Открытые и закрытые типы

 открытый тип — тип с обобщенными параметрами-типами Dictionary<,>

 закрытый тип — тип, у которого всем аргументам-типам переданы действительный типы данных

Dictionary<String, Int32>

 экземпляры открытых типов создавать нельзя

Наследование

 обобщенный тип может быть производным от других типов

 при указании аргументов-типов создается объект-тип, производный от того же типа, что

и обобщенный тип

Обобщенные методы

 метод может задавать собственные параметры-типы

 параметры могут использоваться:

 параметры

 возвращаемое значение

 локальные переменные

Пример обобщенного метода

void Swap<T>(ref T a, ref T b) {

T temp = a;

a = b;

b = temp;

}

Int32 n1 = 1, n2 = 2; String s1 = "tom", s2 = "bill";

Swap<Int32>(ref n1, ref n2);

Swap<String>(ref s1, ref s2);

Swap(ref n1, ref n2); // логический вывод типов

Swap(ref s1, ref s2); // (type inference)

Ограничения

 код должен работать с любыми типами данных

 область применения обобщений расширяется за счет ограничений

T Min<T>(T a, T b) {

return (a.CompareTo(b) < 0) ? a : b;

}

Ограничения (constraints) – механизм, позволяющий сузить перечень типов, которые можно передать в аргумент-тип

Применяются к:

 обобщенным методам

 обобщенным типам

Перегрузка:

 допускается по арности

 не допускается по именам или ограничениям

T Min<T>(T a, T b) where T : IComparable<T> {

return (a.CompareTo(b) < 0) ? a : b;

}

class SomeClass<T> where T : IComparable<T> {}

Виды ограничений:

 основное

 дополнительное

 ограничение конструктора

Основные ограничения

 ссылочный тип, указывающий на не-sealed класс

 нельзя использовать Object, Array, Delegate, MulticastDelegate, ValueType, Enum, Void

 допускается не более 1 ограничения

 особые основные ограничения:

 class [можно присвоить null]

 struct [можно вызвать конструктор]

Дополнительные ограничения

 можно задавать несколько ограничений

 ограничения типа-интерфейса

void M<T>(T t) where T :

IComparable, IConvertible {}

 ограничения параметра-типа

void M<T1, T2>(T1 t) where T2 : T1

{}

Ограничения конструктора

 указанный аргумент-тип должен быть неабстрактного типа, реализующего открытый конструктор без параметров

 допускается не более 1 ограничения

 несовместно с ограничением struct

class SomeClass<T> where T : new()

{}