25.C# и Java. Исключения. Основные принципы использования механизма

исключений.

Исключение (exception) — оповещение о невозможности выполнить запрошенное действие

Генерация исключений

 Исключение какого типа генерировать?

 Рекомендуется использовать содержательный тип

 Иерархия должна быть максимально плоской и широкой

 Имя исключения должно отражать суть проблемы, а не место возникновения [Name The Problem Not The Thrower]

 Используется суффикс: Exception

Генерация исключений

 Какое сообщение передавать?

 детальная техническая информация

 пользователь не должен видеть это сообщение

 для необработанных исключений сообщения регистрируются в журнале

«Политические» решения

 Разработка библиотек классов

 не следует принимать решений, что считать ошибкой, а что — нет

 Разработка приложений

 разработчики сами определяют политику

 Перехватываются только исключения, которые вы ждали, причины которых понимаете и знаете, как с ними разобраться

Обработка исключений

 Не следует «проглатывать» исключения

 Повторно сгенерировать то же самое исключение:

 throw;

 Или сгенерировать другое исключение, передав исходное в качестве внутреннего:

 throw new OtherException(параметры, e);

Обработка исключений

 Не следует передавать «выше» исключения, поступившие от служб более низкого уровня

 Исключения преобразуются в новую форму; включают исключения более низких уровней

 Convert Exceptions или Exception Abstraction

Обработка исключений

public void HighLevelMethod() {

try {

LowLevelMethod1();

LowLevelMethod2();

} catch(LowLevelException low) {

throw new HighLevelException("...", low);

}}

Пример (в падлу копировать, там дофига, начало 8.pdf 16 страница)

Java — иерархия

26.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()

{}