Как правильно писать тесты 46 Цикл разработки 46 Структура проекта с тестами 51 Утверждения (Asserts) 52 Утверждения в форме ограничений 54 Категории 56

Вид материалаТесты

Содержание


Создание пользовательских обобщенных коллекций
Установка ограничений для параметров типа с помощью where
Ограничение обобщения
Подобный материал:
1   ...   39   40   41   42   43   44   45   46   47

Создание пользовательских обобщенных коллекций




Итак, пространство имен System.Collections.Generic предлагает множество типов, позволяющих создавать эффективные контейнеры, удовлетворяющие требованиям типовой безопасности. С учетом множества доступных вариантов очень велика вероятность того, что в .NET 2.0 у вас вообще не возникнет необходимости в построении пользовательских типов коллекции. Тем не менее, чтобы показать, как строится обобщенный контейнер, нашей следующей задачей будет создание обобщенного класса коллекции, который мы назовем CarCollection.


Подобно созданному выше необобщенному типу CarCollection, наш новый вариант будет использовать уже существующий тип коллекции для хранения своих элементов (в данном случае это List<>). Будет реализована и поддержка цикла foreach путем реализации обобщенного интерфейса IEnumerable<>. Обратите внимание на то, что IEnumerable<> расширяет необобщенный интерфейс IEnumerable, поэтому компилятор ожидает, что вы реализуете две версии метода GetEnumerator(). Вот как может выглядеть соответствующая модификация.


public class CarCollection : IEnumerable

{

private List arCars = new List();


public T GetCar(int pos)

{ return arCars[pos]; }


public void AddCar(T c)

{ arCars.Add(c); }


public void ClearCars()

{ arCars.Clear(); }


public int Count

{ get { return arCars.Count; } }


// IEnumerable расширяет IEnumerable, поэтому

// нужно реализовать обе версии GetEnumerator().

IEnumerator IEnumerable.GetEnumerator()

{ return arCars.GetEnumerator(); }

IEnumerator IEnumerable.GetEnumerator()

{ return arCars.GetEnumerator(); }

}


Этот обновленный тип CarCollection можно использовать так.


static void Main(string[] args)

{

Console.WriteLine("* Пользовательская обобщенная коллекция *\n");


// Создание коллекции объектов Car.

CarCollection myCars = new CarCollection();

myCars.AddCar(new Car("Rusty", 20));

myCars.AddCar(new Car("Zippy", 90));


foreach (Car c in myCars)

{

Console.WriteLine("PetName: {0}, Speed: {1}",

c.PetName, c.Speed);

}

Console.ReadLine();

}


Здесь создается тип CarCollection, который должен содержать только типы Car. Снова заметим, что того же результата можно достичь и с помощью непосредственного использования типа List. Главным преимуществом данного подхода является то, что теперь вы можете добавлять в CarCollection уникальные методы, делегирующие запросы к внутреннему типу List.


Установка ограничений для параметров типа с помощью where




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


// Это синтаксически корректно, но выглядит,

// по крайней мере, странно...

CarCollection myInts = new CarCollection();

myInts.AddCar(5);

myInts.AddCar(11);


Чтобы проиллюстрировать другую форму типичного непредусмотренного использования объекта, предположим, что вы создали два новых класса — SportsCar (спортивная машина) и MiniVan (минивэн), — которые являются производными от Car.


public class SportsCar : Car


{

public SportsCar(string p, int s)

: base(p, s){}

// Дополнительные методы для SportsCar.

}


public class MiniVan : Car

{

public MiniVan(string p, int s)

: base(p, s){}

// Дополнительные методы для MiniVan.

}


В соответствии с законами наследования, в коллекцию CarCollection, созданную с параметром типа Car, можно добавлять и типы MiniVan и SportsCar.


// CarCollection может хранить любой тип, производный от Car.

CarCollection myCars = new CarCollection();

myInts.AddCar(new MiniVan("Family Truckster", 55));

myInts.AddCar(new SportsCar("Crusher", 40));


Это синтаксически корректно, но что делать, если вдруг понадобится добавить в CarCollection новый открытый метод, например, с именем PrintPetName()? Такая задача кажется простой — достаточно получить доступ к подходящему элементу из List и вызвать свойство PetName.


// Ошибка!

// System.Объект не имеет свойства с именем PetName.

public void PrintPetName(int pos)

{

Console.WriteLine(arCars[pos].PetName);

}


Однако в таком виде программный код скомпилирован не будет, поскольку истинная суть еще не известна, и вы не можете с уверенностью утверждать, что какой-то элемент типа List будет иметь свойство PetName. Когда параметр типа не имеет никаких ограничений (как в данном случае), обобщенный тип называется свободным (unbound). По идее параметры свободного типа должны иметь только члены System.Object (которые, очевидно, не имеют свойства PetName).


Вы можете попытаться “обмануть” компилятор путем преобразования элемента, возвращенного из метода индексатора List, в строго типизованный объект Car, чтобы затем вызвать PetName возвращенного объекта.


// Ошибка!

// Нельзя превратить тип 'T' в 'Car'!

public void PrintPetName(int pos)

{

Console.WriteLine(((Car)arCars[pos]).PetName);

}


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


Для решения именно таких проблем обобщения .NET могут опционально определяться с ограничениями, для чего используется ключевое слово where. В .NET 2.0 обобщения могут иметь ограничения, описанные в табл.



Ограничение обобщения

Описание

where T : struct

Параметр типа должен иметь в цепочке наследования System.ValueType

where T : class

Параметр типа не должен иметь в цепочке наследования System.ValueType (т.е. должен быть ссылочным типом)

where T : new()

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

where T : БазовыйКласс

Параметр типа должен быть производным класса, указанного параметром БазовыйКласс

where T : Интерфейс

Параметр типа должен реализовывать интерфейс, указанный параметром Интерфейс



При наложении ограничений с помощью ключевого слова where список ограничений размещается после имени базового класса обобщенного типа и списка интерфейсов. В качестве конкретных примеров рассмотрите следующие ограничения обобщенного класса MyGenericClass.


// Типы параметра должны иметь конструктор,

// заданный по умолчанию.

public class MyGenericClass where T : new()

{...}


// Типы параметра должны быть классами, реализующими IDrawable

// и поддерживающими конструктор, заданный по умолчанию.

public class MyGenericClass where T : class, IDrawable, new()

{...}


// MyGenericClass получается из MyBase и реализует ISomeInterface,

// а типы параметра должны быть структурами.

public class MyGenericClass : MyBase, ISomeInterface

where T : struct

{...}


При построении обобщенного типа, в котором указано несколько параметров типа, вы можете указать уникальный набор ограничений для каждого из таких параметров.


// должен иметь конструктор, заданный по умолчанию,

// а должен реализовывать открытый интерфейс IComparable.

public class MyGenericClass where K : new()

where T : IComparable

{...}


Если вы хотите изменить тип CarCollection так, чтобы в него можно было поместить только производные от Car, вы можете записать следующее.


public class CarCollection : IEnumerable where T : Car

{

...

public void PrintPetName(int pos)

{

// Поскольку теперь все элементы должны быть из семейства Car,

// свойство PetName можно вызывать непосредственно.

Console.WriteLine(arCars[pos].PetName);

}

}


При таких ограничениях на CarCollection реализация PrintPetName() становится очень простой, поскольку теперь компилятор может предполагать, что является производным от Car. Более того, если указанный пользователем параметр типа не совместим с Car, будет сгенерирована ошибка компиляции.


// Ошибка компиляции!

CarCollection myInts = new CarCollection();


Вы должны понимать, что обобщенные методы тоже могут использовать ключевое слово where. Например, если нужно гарантировать, чтобы методу Swap(), созданному выше, передавались только типы, производные от System.ValueType, измените свой программный код так.


// Этот метод переставит любые типы-значения.

static void Swap(ref T a, ref T b) where T : struct

{

...

}


Следует также понимать то, что при таком ограничении метод Swap() уже не сможет переставлять строковые типы (поскольку они являются ссылочными).