Разработка приложений на платформе .NET презентация

абстрактных членов.
Интерфейс определяет спецификацию, но не определяет реализацию
Класс – наследуют, а интерфейс – реализуют

interface IDisposable {
void Dispose();
}
public interface IPointy {
byte Points {get;}
int GetNumberOfPoints();
}

реализацию
Члены интерфейса не могут быть статическими
Члены интерфейса не могут иметь модификаторов
Члены интерфейса всегда public

ICloneable
Базовый класс должен идти первым в списке, а за ним список реализуемых интерфейсов.
Можно реализовать одновременно несколько интерфейсов

Класс, реализующий интерфейс:
Либо реализует все его методы
Либо объявляет их (и себя) абстрактными

Clone() { … }
Метод доступен как обычно
peremen.Clone()
Метод доступен и через интерфейс
((ICloneable)peremen).Clone()
Явная (explicit) реализация интерфейса
Записывается квалифицированное имя каждого метода
object ICloneable.Clone() { … }
Метод доступен только через интерфейс
((ICloneable)peremen).Clone()
Используется при наличии конфликта
Не указывается модификатор доступа. Он неявно public

требуется самому реализовать интерфейс

Привязка к виртуальным методам
Производным классам достаточно просто переопределить виртуальный метод, чтобы сменить реализацию

все из базовых интерфейсов
Тип (класс, структура), реализующие производный интерфейс должен реализовать также и все базовые интерфейсы
public interface IDrawable : IPrintable {}
Передача интерфейсов в качестве параметров
Метод принимает любой тип, реализующий данный интерфейс
public void GetShape(IDrawable shape);
Интерфейсы в качестве возвращаемых параметров
Метод возвращает некий тип, который реализует данный интерфейс
public IDrawable GetShape();
В .NET все существующие интерфейсы начинаются с I

содержать реализацию, интерфейсы – нет
Интерфейсы могут содержать только методы, свойства, события и индексаторы
Все члены интерфейса – public. Это открытый контракт
Используйте абстрактные классы, если:
Требуется определить определенную функциональность, которую могут использовать все наследники
Производный класс “является” базовым
Используйте интерфейсы
Производный класс “реализует” интерфейс
Требуется множественное наследование

Dispose()
Реализуйте этот метод, если требуется освобождение внешних ресурсов
Файлы, соединения и т.д.

IComparable – используется при сортировках при сравнении 2 элементов

IEnumerable, IEnumerable, IEnumerator, IEnumerator
Позволяют итерировать по коллекции

IDictionary, IList, ICollection
Интерфейсы реализуемые коллекциями

строки на экран)
Создайте классы его потомков Triangle, Hexagon, Circle, Sphere

Создайте интерфейсы
IPoint, со свойством Point, выдающим количество точек в фигуре.
IDrawable, с методом Draw(), якобы рисующем фигуру (вывод строки на экран )

Реализуйте
IPoint для Triangle и Hexagon
IDrawable для Triangle (не явно) и Sphere (явно)

В основном классе:
Создайте метод AnalyzeShape(), принимающий Shape и распечатывающий, если возможно, кол-во точек в фигуре, и вызывающий метод Draw напрямую и через интерфейс.
В методе Main создайте массив из Shape с разными фигурами и проанализируйте их вызвав метод AnalyzeShape()

структура), который параметризован другим типом
class Queue { }
struct Complex { }

Обобщенная функция
Функция, параметром которой является тип
T Swap(T x, T y) { }

Обобщенный делегат
Делегат, параметрами которого являются типы
delegate T MyDelegate() where T : new()

Обобщенный интерфейс
interface IEnumerable { }

типов, накладные расходы
Коллекции с жёстко заданным типом
Каждый раз новый код
Контроль типов, нет накладных расходов
Обобщенные коллекции
Один код для всех
Контроль типов, нет накладных расходов

:= where ОбозначениeТипа1 : ограничения
[, ОбозначениeТипаN : ограниченияN]


Пример:
public class Stack
where T : IDisposable, new()
{
T[] arr;
T top = default(T);
T example = new T();
Stack(int size) { arr = new T[size]; }
void Push(T item) {…}
T Pop() {return arr[i]; }
void Dispose() {top.Dispose();}
}

Создание объекта обобщенного типа:
Необходимо указать все типы-параметры
Stack myIntStack = new Stack();
Dictionary myDict = new Dictionary ();

в коде как обычный тип
Для задания значения по умолчанию используется синтаксис
Тип Переменная = default(Тип );

class MyDictionary
where TKey : Complex, IComparable
where TValue : class
{
}

struct MyGenericStruct
{
}

class MyGenericClass
{
C c = dafault(C);
}

T b)
{
T c = a; b = a; a = c;
}

public T Swap(T a, U b, Complex comp)
{…}

public T Copy(T a, T b)
where T : new()
{ T result = new T(); …..}
Использование:
При вызове необходимо задать все типы параметры, если компилятор не может определить их из контекста
Swap(ref comp1, ref comp2);
int I = Swap(intVariable, longVariable, myIntComplexVariable);

T GetT(K k);
K GerK(T t);
T propertyT { get; }
T propretyK { get; set; }
bool Equal(T t, K k);
}
Использование:
При реализации, либо класс должен быть обобщенным, либо должен реализовывать конкретный тип обобщенного интерфейса
class MyClass : MyInterface { }
class MyClass1 : MyInterface { }
class MyClass2 : MyInterface { }

умолчанию доступны только методы object

Если нужны дополнительные методы
Необходимо использовать ограничения

/ Типы значения
where T : struct
where T : class
Нельзя одновременно указать и class, и struct
Наличие конструктора по умолчанию
ограничение должно быть последним в списке
where T : new()

указано несколько ограничений
Все должны выполняться одновременно
Если нужна альтернатива – используйте базовые интерфейсы

классе создайте обобщенный метод, создающий и заполняющий стек некоторым количеством объектов со значениями по умолчанию
Создайте код для “тестирования” вашего стека

Для желающих. Потребуйте от типа T, чтобы он реализовывал ICloneable и реализуйте T Top() так, чтобы он возвращал копию объекта, а не сам объект