1

|

2

|

3

|

вопросы | »

учебники

|

для печати и PDA

Рассмотрев интуитивное определение

Рассмотрев интуитивное определение понятия класса, а также представив домены как формальную модель классов языков программирования в целом, остановимся более подробно на классах в языке объектно-ориентированного программирования C#.

По аналогии с другими известными языками объектно-ориентированного программирования (в частности, C++ и Java), под классом в языке C# понимается ни что иное, как ссылочный тип, определенный пользователем.

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

Членами (или, иначе, элементами) класса языка программирования C# могут являться следующие конструкции:

константа, поле, метод, оператор, конструктор, деструктор;

свойство, индексатор, событие;статические и инициализированные члены.

Доступ к членам класса определяется исходя из значения модификатора области действия идентификатора класса, который может принимать следующие значения: public, protected, private (данное значение используется по умолчанию), internal, protected internal.

Инициализация объекта класса языка программирования C# производится посредством оператора new, о котором будет рассказано ниже.

Рассмотрим манипулирование классами на примере следующих фрагментов программ на языке C#.

Прежде всего, приведем простейшее описание класса. Описание класса C c целочисленным полем value на языке C# имеет вид:

class C { ... int value = 0; ... }

Заметим, что в описании класса C на языке программирования C# кроме рассмотренного поля value могут присутствовать и другие поля (т.е. атрибуты объектов класса) допустимых в языке C# типов, а также методы (т.е. способы манипулирования объектами данного класса).

В языке программирования C# инициализация поля (т.е. связывание его с начальным значением) не является обязательной. Для обеспечения безопасности программного кода и в силу реализации принципа инкапсуляции, инициализация поля некоторого класса C не должна открывать возможностей для доступа к полям и методам данного типа.
При этом доступ к элементам класса внутри класса реализуется посредством обращения и не требует полного имени объекта:

... value ...

В отличие от предыдущего случая, доступ из сторонних классов требует указания полного имени объекта (в примере последовательно производятся инициализация и обращение):

C c = new C(); ... c.value ...

Рассмотрим более развернутый пример описания классов и манипулирования их элементами.

Приведем описание класса Rectangle, моделирующего прямоугольник с полями origin, width и height, моделирующими, соответственно, начальную точку (с парой координат), ширину и высоту, а также методом MoveTo, моделирующим перемещение начальной точки в заданную:

class Rectangle { Point origin; public int width, height; public Rectangle(){ origin = new Point(0,0); width=height=0; } public Rectangle ( Point p, int w, int h){ origin = p; width = w; height = h; } public void MoveTo (Point p) { origin = p; } }

Заметим, что модификатор области видимости для данного класса и его элементов разрешает общедоступное применение (public). Рассмотрим пример использования класса Rectangle:

Rectangle r = new Rectangle( new Point(10,20),5,5); int area = r.width * r.height; r.MoveTo(new Point(3,3));

Заметим, что в данном примере последовательно осуществляются инициализация объекта класса Rectangle с начальной точкой (10,20), шириной и высотой в пять единиц (т.е. квадрата), подсчет его площади area и перемещение начала отсчета в точку с координатами (3,3).

В результате анализа рассмотренных примеров становится очевидным, что объект является принципиально динамическим и изменяет состояние в зависимости от соотнесения (времени и внешних воздействий).

В этой связи исследуем более подробно простейший, статический случай полей объекта, который в языке программирования C# выделен в самостоятельный синтаксический элемент, характеризующийся независимостью от состояния объекта (и потому условно принадлежащий к классу). Приведем модифицированный пример предыдущего класса для случая статических полей:

class Rectangle { static Color defaultColor; // для каждого класса static readonly int scale; // для каждого класса int x, y, width,height; // для каждого объекта ... }

Заметим, что статические поля defaultColor и scale остаются неизменными внутри класса, тогда как динамические поля x, y, width и height индивидуально изменяются в зависимости от состояния каждого из объектов класса. Доступ изнутри класса осуществляется посредством обращения:

... defaultColor ... scale ...

а из внешних классов - посредством обращения:

... Rectangle.defaultColor ... Rectangle.scale ...

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

Классы и обьекты

Понятие класса является фундаментальным в ООП и служит основой для создания объектов. В описании класса определяются данные (т.е. переменные) и код (т.е. методы), манипулирующий этими данными. Объекты являются экземплярами класса.

Методы и переменные, составляющие класс, называются членами класса. При определении класса объявляются данные, которые он содержит, и код, манипулирующий этими данными. Данные содержатся в переменных экземпляра, которые определены классом, а код содержится в методах. В языке С# определены несколько специфических разновидностей членов класса. К ним относятся: переменные экземпляра, статические переменные, константы, методы, конструкторы, деструкторы, индексаторы, события, операторы и свойства.

Инициализация переменных в объекте (как в экземпляре класса) производится непосредственно в конструкторе класса. В составе класса может быть определено несколько конструкторов.

Синтаксис определения класса:

class имя_класса{ тип_доступа тип имя_переменной1; тип_доступа тип имя_переменной2; ... тип_доступа возвращаемый_тип имя_метода1(список_параметров) {тело_метода} }

где тип_доступа может принимать одно из следующих значений: public, private, protected, internal. Члены класса с типом доступа public являются общедоступными (т.е. доступны из любой точки программы за пределами данного класса), с типом доступа protected – внутри членов данного класса и его производных, с типом доступа private – только для других членов данного класса. Тип доступа internal применяется для типов, доступных в пределах одной сборки.

Приведем пример описания класса:

class Animal{ public string Name; private int Weight; protected int Type; public int Animal(int W, int T, string N){ Weight=W; Type=T; Name=N; } public int GetWeight(){return Weight;} }

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

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

Синтаксис описания объекта:

class имя_класса : имя_родительского_класса { тело_класса }

Пример описания объекта:

class Predator:Animal{ private int Speed; }

Наследование формирует иерархию классов на основе отношения частичного порядка ISA ("являться").

Иерархия может быть построена и для объектов. В этом случае она имеет структуру, которая строится на основе отношения структурного вхождения ("часть-целое"), при котором один объект является частью другого.

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

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

Конструктор существует для любого класса, независимо от того, определен он в явном виде или нет. Умолчаниями языка С# предусмотрено наличие конструктора, который присваивает нулевые значения всем переменным экземпляра (для переменных типов-значений) и значения null (для переменных ссылочного типа). В случае явного определения конструктора класса конструктор по умолчанию не используется.

Синтаксис описания конструктора:

имя_класса(список_параметров) {тело_конструктора}

Под деструктором будем понимать метод, который автоматически вызывается при уничтожении объекта класса (непосредственно перед началом процедуры "сборки мусора"). Деструкторы не имеют параметров и не возвращают значений.

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

~имя_класса() {тело_деструктора}

Порядок выполнения работы

Разработать методы и свойства для каждого из определяемых классов.Реализовать программу на C# в соответствии с вариантом исполнения.

Создание обьекта

Синтаксис:

имя_класса имя_обьекта = new имя_класса();

При создании обьекта (т.е. экземпляра класса) происходит вызов соответствующего конструктора класса.

Варианты заданий

Построить иерархию классов в соответствии с вариантом задания:

Студент, преподаватель, персона, заведующий кафедройСлужащий, персона, рабочий, инженерРабочий, кадры, инженер, администрацияДеталь, механизм, изделие, узелОрганизация, страховая компания, нефтегазовая компания, заводЖурнал, книга, печатное издание, учебникТест, экзамен, выпускной экзамен, испытаниеМесто, область, город, мегаполисИгрушка, продукт, товар, молочный продуктКвитанция, накладная, документ, счетАвтомобиль, поезд, транспортное средство, экспрессДвигатель, двигатель внутреннего сгорания, дизель, реактивный двигательРеспублика, монархия, королевство, государствоМлекопитающее, парнокопытное, птица, животноеКорабль, пароход, парусник, корвет

Теория типов и типизация в .NET

Обсудим основы дисциплины типов в рамках .NET. Напомним, что история развития математических формализаций для типовых теорий изложена во вступительной лекции, а основа теории типов - в лекции 6.

Обобщим те преимущества, которые отличают языки программирования и формальные теории с типами.

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

Введение типизации облегчает и упорядочивает не только восприятие, но и управление предметной областью. Манипулирование типизированными элементами носит более целенаправленный характер, причем появляется возможность обрабатывать разнородные сущности предметной области различным образом, а однородные (или, точнее, однотипные) - единообразно.

Перейдем к языкам программирования и практике проектирования и реализации программных систем. В случае построения языка программирования по принципу строгой типизации несоответствия типов фиксируются до начала этапа выполнения программы (на этапе контроля соответствия типов в ходе трансляции), что гарантирует отсутствие семантических (смысловых) и логических ошибок и безопасность программного кода.

Напомним классификацию систем типизации в языках программирования.

Исторически наиболее распространенной для языков программирования является строгая типизация. При таком формировании системы типов в языке в любой момент существования любого языкового объекта существует однозначное соответствие между объектом и его типом. Другими словами, можно запрограммировать функцию, определяющую тип объекта, подобную ранее рассмотренной нами функции typeof языка программирования C#. Строго типизированными являются классические императивные языки программирования Pascal, FORTRAN, PL/I и др. Отметим, что классический вариант языка программирования C не является строго типизированным.

Сильная типизация необходима для обеспечения корректности связывания переменных со значениями до выполнения программы.
табл. 18.1):

При этом типы- значения распадаются на следующие подтипы:



элементарные (в частности, целочисленные и вещественные):

int i; float x;



перечислимые (в частности, моделирующие переключатели):

enum State {Off, On}



структурные (в частности, моделирующие точки на плоскости):

struct Point {int x,y;}



В свою очередь, ссылочные типы подразделяются на следующие подтипы:

корневой подтип (указатели на произвольные объекты в иерархии типов в Common Type System):

object



строковые (указатели на строки символов):

string



классы (указатели на объекты типа class):

class Foo: Bar, IFoo {...}



интерфейсы (указатели на объекты типа interface):

interface IFoo: IBar {...}



массивы (в частности, указатели на строки из 10 символов):

string[] a = new string[10];



делегаты (усовершенствованные указатели на функцию):

delegate void Empty();

Концепция наследования и ее реализация в языке C#

Формализуем понятие наследования и обсудим его значение для объектно-ориентированного подхода к программированию. Напомним, что эволюция теоретических основ наследования была рассмотрена во вступительной лекции.

Под наследованием в дальнейшем будем понимать свойство производного объекта сохранять поведение родительского объекта. Под поведением будем иметь в виду для математического объекта его атрибуты и операции над ним, а для языкового объекта ООП - поля и методы.

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

Теоретическая концепция наследования удовлетворительно моделируется посредством отношения (или, точнее, иерархии) частичного порядка. Существует целый ряд формализаций наследования, но наиболее адекватными и концептуально ясными являются графические модели. Среди них следует выделить уже упомянутые ранее подходы: фреймовую нотацию Руссопулоса и диаграммы Хассе.

Отношение частичного порядка обладает следующими теоретически интересными и практически полезными свойствами.

Во-первых, оно является рефлексивным, т.е. любой объект языка программирования или формальной модели предметной области находится в отношении частичного порядка с самим собой. Формальная запись свойства рефлексивности для отношения частичного порядка ISA выглядит следующим образом:

Другой важной особенностью отношения частичного порядка является транзитивность. Суть транзитивности состоит в том, что если существует цепочка из (трех) объектов, связанных отношением частичного порядка, то первый и последний элементы этой цепочки можно связать тем же отношением. Это свойство гарантирует построение на множестве графа отношения частичного порядка в виде "решетки".
Формальная запись свойства транзитивности для отношения частичного порядка выглядит следующим образом:

Концепция инкапсуляции и ее реализация в языке C#

Формализуем понятие инкапсуляции в рамках объектно-ориентированного подхода к программированию.

В неформальной постановке вопроса под инкапсуляцией будем понимать доступность объекта исключительно посредством его свойств и методов.

Другими словами, концепция инкапсуляции призвана обеспечивать безопасность проектирования и реализации программного обеспечения на основе локализации манипулирования объектом в областях его полей и методов.

Иначе говоря, свойствами объекта можно оперировать исключительно посредством его методов. Это замечание касается как свойств, явно определенных в описании объекта, так и свойств, унаследованных данным объектом от другого (других).

Практическая важность концепции инкапсуляции для современных языков объектно-ориентированного программирования (в том числе и для языка C#) определяется следующими фундаментальными свойствами.

Прежде всего, реализация концепции инкапсуляции обеспечивает совместное хранение данных (или, иначе, полей) и функций (или, иначе, методов) внутри объекта.

Как следствие, механизм инкапсуляции приводит к сокрытию информации о внутреннем "устройстве" объекта данных (или, в терминах языков ООП, свойств и методов объекта) от пользователя того или иного объектно-ориентированного приложения.

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

Рассмотрев определение понятия инкапсуляции (пока на интуитивном уровне), перейдем к описанию формализаций этой фундаментальной для объектно-ориентированного программирования концепции на основе уже известных нам формальных теорий computer science.

Оказывается, что понятие инкапсуляции вполне адекватно формализуется посредством таких теоретических формальных систем, как ламбда-исчисление А.Черча и комбинаторная логика Х.Карри.

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

Абстрактные классы

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

Для объявления абстрактного метода используется модификатор abstract. Поскольку абстрактный метод неявно является виртуальным, модификатор virtual при объявлении такого метода не используется.

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

Концепция полиморфизма

Понятие полиморфизма является одной из фундаментальных составляющих объектно-ориентированного программирования и позволяет определять в наследуемом классе методы, которые являются общими для всех наследующих классов. При этом наследующий класс может определять специфическую реализацию для некоторых (а возможно и всех) полиморфных методов. Важнейший принцип полиморфизма можно сформулировать фразой: "один интерфейс, несколько методов". Благодаря полиморфизму можно пользоваться методами, не обладая точными знаниями о типе объектов.

Основными механизмами для реализации концепции полиморфизма в ООП (в том числе, в языке C#) являются виртуальные методы и абстрактные классы.

Описание абстрактного класса

Синтаксис:

abstract class имя {тело_класса};

Пример:

abstract class Animal { public string Name; protected int Weight; private int Type; abstract void Feed(); public int Animal(int W, int T, string N) { Weight=W; Type=T; Name=N; } public int GetWeight(){ return Weight; } } class Predator:Animal { private int Speed; override void Feed(int Food){ Weight += Food; } }

Описание абстрактного метода

Синтаксис:

virtual тип имя (список_параметров) {тело_метода};

Порядок выполнения работы

Изменить иерархию классов и реализовать ее на С#.Показать на примере одного из методов, присутствующих в каждом классе, свойство полиморфизма.

Варианты заданий

Расширить иерархию классов из лабораторной работы №7 с использованием виртуального класса в качестве основы иерархии. Показать пример использования полиморфизма методов.

Виртуальные методы

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

Выбор конкретизации виртуального метода, которая будет использована, осуществляется в соответствии с типом объекта, на который указывает ссылочная переменная во время выполнения программы. Другими словами, именно тип объекта, на который указывает ссылка (а не тип ссылочной переменной), определяет вызываемую версию виртуального метода. Таким образом, если класс содержит виртуальный метод и от этого класса были унаследованы другие классы, в которых определены свои версии метода, при ссылке переменной типа наследуемого класса на различные типы объектов вызываются различные версии виртуального метода.

При определении виртуального метода в составе наследуемого класса перед типом возвращаемого значения указывается ключевое слово virtual, а при переопределении виртуального метода в наследующем классе используется модификатор override. В определении виртуального метода недопустимо использование модификаторов static и abstract.

Виртуальный метод не обязательно должен быть переопределенным (overridden). Если наследующий класс не предоставляет собственную версию виртуального метода, то используется метод наследуемого класса.

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

Расширенные возможности полиморфизма в языке C#

Предыдущая лекция была посвящена базовым аспектам полиморфизма. Обсудим более тонкие механизмы, предусмотренные в языке C# для реализации сложных полиморфных объектов.

Проиллюстрируем особенности использования абстрактных свойств и методов следующим фрагментом программы на языке C#:

abstract class Sequence { public abstract void Add(object x); // метод public abstract string Name{ get; } // свойство public abstract object this [int i] { get; set; } // индексатор }

class List : Sequence { public override void Add(object x) { ... }

public override string Name { get { ... } } public override object this [int i] { get { ... } set{ ... } } }

Как видно из приведенного примера, фрагмент программы на языке C# представляет собой описание абстрактных классов Sequence и List, реализующих потоковое чтение и запись данных (get и set).

Заметим, что описание абстрактного класса Sequence реализовано явно посредством зарезервированного слова abstract.

Необходимо обратить внимание на то обстоятельство, что поскольку в производных классах требуется замещение методов, методы Add и Name класса List оснащены описателем override.

Еще одним средством реализации расширенного полиморфизма в языке программирования C# является механизм, известный под названием "запечатанных" (sealed) классов.

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

Рассмотрим соображения, обосновывающие использование механизма "запечатанных" классов в языке программирования C#. Прежде всего, благодаря реализации данного механизма предотвращается изменение семантики класса. Таким образом, существенно повышается безопасность разрабатываемого программного обеспечения. А за счет того, что вызов "запечатанных" методов предполагает использование статического связывания, значительно возрастает эффективность реализуемых приложений.

Делегаты

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

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

Делегат объявляется с помощью ключевого слова delegate, за которым указывается тип возвращаемого значения, имя делегата и список параметров вызываемых методов.

Интерфейсы

В языке программирования C# с целью изоляции описательной части класса от его реализации используется механизм интерфейсов.

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

Членами интерфейса могут быть методы, свойства, индексаторы и события.

Интерфейс может реализовываться произвольным количеством классов. Один класс, в свою очередь, может реализовывать любое число интерфейсов.

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

Многоадресность делегатов

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

Для формирования цепочки методов следует создать экземпляр делегата, и, пользуясь операторами "+" или "+=", добавлять методы к цепочке. Для удаления метода из цепочки используется оператор "-" или "-=". Делегаты, хранящие несколько ссылок, должны иметь тип возвращаемого значения void.

Описание делегата

Синтаксис:

delegate тип_возвращаемого_значения имя_делегата (список_параметров);

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

Описание интерфейса

Синтаксис:

[атрибуты] [модификаторы] interface Имя_интерфейса[ :список_родительских_интерфейсов] { обьявление_свойств_и_методов}

Пример:

interface Species { string Species(); void Feed(); }

class Cheetah:Animal,Species{ private string ScientificName; public string Species() { return ScientificName; } public void Feed() { Weight++; } }

В языке C# допустимо объявление ссылочных переменных интерфейсного типа. Такие переменные могут ссылаться на любой объект, реализующий их интерфейсы. При вызове метода объекта по интерфейсной ссылке происходит вызов той конкретизации метода, которая реализуется данным объектом.

В языке C# допустимо наследование интерфейсов. При этом синтаксис аналогичен таковому для наследования классов. В случае, если класс реализует интерфейс, который наследует другой интерфейс, необходимо предусмотреть реализацию всех членов, определенных в составе иерархии наследования интерфейсов.

Порядок выполнения работы

Реализовать программу на C# в соответствии с вариантом исполнения.Для проверки всех методов данного класса следует использовать многоадресный делегат.

Варианты заданий

Реализовать для иерархии из лабораторной работы №8 механизм интерфейсов, при этом один из классов должен реализовывать как минимум два интерфейса. Использовать для проверки всех методов данного класса многоадресный делегат.

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

Исключения автоматически генерируются средой программирования. Однако исключение может быть и явно сгенерировано посредством оператора throw.

Исключительные ситуации

Исключительная ситуация (или, короче, исключение) представляет собой ту или иную ошибку или отклонение от обычного сценария во время выполнения программы. С помощью подсистемы обработки исключений языка С# можно обрабатывать такие ошибки, не вызывая аварийного завершения программы.

Для обработки исключений в языке С# примененяются следующие ключевые слова: try, catch, throw, finally. Перечисленные ключевые слова образуют взаимосвязанную подсистему, в которой использование одного из ключевых слов влечет за собой использование других.

Обработка исключений в языке C# реализуется на основе операторных блоков try и catch.

Конструкция try/catch с блоком finally

Синтаксис:

try { // Блок кода, выполняющий мониторинг ошибок } catch (ExcepTypel ех1) { //1 Обработка исключения ExcepTypel. }

catch (ЕхсерТуре2 ех2) { // 2 Обработка исключения ЕхсерТуре2 . finally { // Код блока finally. }

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

Наследование классов исключений

Можно создавать заказные исключения, выполняющие обработку ошибок в пользовательском коде. Генерация исключений не представляет принципиальных сложностей, для этого требуется всего лишь определить класс, наследуемый из класса Exception. В качестве общего правила следует руководствоваться тем, что определенные пользователем исключения наследуются из класса ApplicationException, так как они представляют собой иерархию зарезервированных исключений, связанных с приложениями. Наследуемые классы не нуждаются в фактической реализации в каком-либо виде, поскольку сам факт их существования в системе типов данных позволяет воспользоваться ими в качестве исключений.

Создаваемые пользователем классы исключений автоматически получают доступные для них свойства и методы, определенные в классе Exception.

Обработка событий

Под событием будем понимать автоматическое извещение о каком-либо действии среды программирования или пользователя. События являются членами класса и объявляются с использованием ключевого слова event. Реализация механизма событий в языке программирования C# основана на использовании делегатов.

Оператор throw

Синтаксис:

throw exceptOb;

Исключение, перехваченное одним оператором catch, может генерироваться повторно, и благодаря этому перехватываться внешним оператором catch. Для этого указывается ключевое слово throw без имени исключения.

Описание блока try и catch

Синтаксис:

try { Блок_кода_для_которого_выполняется мониторинг_ошибок} catch (ExcepTypel ехОb) { Обработчик_исключений_ExcepTypel } catch (ЕхсерТуре2 ехОb) {Обработчик_исключений_ЕхсерТуре2 }

Основные системные исключения приведены в таблице 10.

Тип исключения в операторе catch должен соответствовать типу перехватываемого исключения. Неперехваченное исключение непременно приводит к досрочному прекращению выполнения программы.

Таблица 10. Основные системные исключения

Для выполнения перехвата исключений вне зависимости от их типа (перехват всех исключений) возможно использование оператора catch без параметров.

Порядок выполнения работы

Реализовать программу на языке C# в соответствии с вариантом исполнения.Графически проиллюстрировать место реализованного исключения в общей иерархии.

Широковещательные события

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

Пример управления событиями посредством делегата:

// Объявление делегата, на основе которого // будет определено событие. delegate void MyEventHandler () ;

// Объявление класса, в котором // инициируется событие. class MyEvent { public event MyEventHandler activate; // В этом методе инициируется событие.

public void fire() { if (activate != null) activate(); } }

class X { public void Xhandler() { Console.WriteLine("Событие получено объектом класса X."); } }

class Y { public void Yhandler() { Console.WriteLine("Событие получено объектом класса Y."); } }

class EventDemo { static void handler() { Console.WriteLine("Событие получено объектом класса EventDemo.") }

public static void Main() { MyEvent evt = new MyEvent(); X xOb = new X(); Y yOb = new Y();

// Добавление методов handler (), XhandlerО // и YhandlerO в цепочку обработчиков события. evt.activate += new MyEventHandler(handler); evt.activate += new MyEventHandler(xOb.Xhandler); evt.activate += new MyEventHandler(yOb.Yhandler); evt.fire(); Console.WriteLine(); evt.activate -= new MyEventHandler(xOb.Xhandler); evt.fire(); } }

Варианты заданий

Реализовать обработку ошибок для лабораторной работы №9, при этом переопределив с помощью наследования событие:

StackOverflowExceptionArrayTypeMismatchExceptionDivideByZeroExceptionIndexOutOfRangeExceptionInvalidCastExceptionOutOfMemoryExceptionOverflowException

Возврат из исключения

Так как оператор catch не вызывается из программы, то после выполнения блока catch управление не передается обратно оператору программы, при выполнении которого возникло исключение. Выполнение программы продолжается с операторов, находящихся после блока catch.

С целью предотвращения этой ситуации возможно указание блока кода, который вызывается после выхода из блока try/catch, с помощью блока finally в конце последовательности try/catch.

Компонентное программирование в .NET

Пожалуй, наиболее существенным нововведением идеологии Microsoft .NET является компонентно-ориентированный подход к программированию.

Во-первых, следует отметить то обстоятельство, что компонентно-ориентированный подход к проектированию и реализации программных систем и комплексов является в некотором смысле развитием объектно-ориентированного и практически более пригоден для разработки крупных и распределенных систем (например, корпоративных приложений).

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

Говоря о свойствах компонентов, следует прежде всего отметить, что это существенно более крупные единицы, чем объекты (в том смысле, что объект представляет собой конструкцию уровня языка программирования). Другими отличиями компонентов от традиционных объектов являются возможность содержать множественные классы и (в большинстве случаев) независимость от языка программирования.

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

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

Прежде всего, поскольку основной вычислительной средой для исследования в данном курсе является Microsoft .NET, обсудим особенности модели для компонентно-ориентированной разработки программного обеспечения, предложенной корпорацией Microsoft.
Эта модель называется компонентной объектной моделью (или Component Object Model, COM) и является изначальным стандартом, принятым для компонентной разработки приложений в корпорации Microsoft.

Компонентная модель COM определяет протокол для конкретизации (т.е. создания экземпляров) и использования компонент (по аналогии с классами и объектами) как внутри одного и того же процесса, так и между различными процессами или компьютерами, предназначенными для выполнения того или иного программного проекта, основанного на компонентной технологии. Модель COM является достаточно универсальной и используется в качестве фундамента для таких технологий проектирования и реализации программного обеспечения, как ActiveX, OLE и целого ряда других технологий. Приложения для COM-модели могут создаваться средствами таких языков и сред разработки как Visual Basic, C++, .NET и т.д.

Другим известным стандартом для компонентной модели является стандарт компании Sun Microsystems, известный как JavaBeans, который не обладает свойством независимости от языка программирования. Еще один широко используемый стандарт компонентного программирования - архитектура объектных запросов CORBA (несмотря на поддержку многоязычной разработки приложений, существуют сложности, связанные с отображением одного языка реализации в другой; для этой цели применяется достаточно громоздкий интерфейс, основанный на специальном языке описания IDL).

В рамках компонентного подхода сборкой называется логическая единица, содержащая множество модулей, необходимых для осуществления инсталляции программного обеспечения. Сборка характеризуется уникальностью, которая обеспечивается идентификатором версии сборки и цифровой подписью автора. Сборка является самодостаточной единицей для установки программного обеспечения и не требует никаких дополнений. Возможно как индивидуальное, так и коллективное (сетевое) использование сборки на основе компонентной технологии. Сборка обеспечивает простой и удобный механизм инсталляции и экономит средства, необходимые для развертывания программного обеспечения, сводя к минимуму затраты времени и сил на установку.



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

Заметим, что промежуточный язык IL всегда компилируется в естественный (native) код до выполнения программы.

Для более эффективного манипулирования системой типизации компонент создаваемого программного обеспечения в рамках модели COM, концепция .NET предусматривает механизм пространств имен (namespace).

Пространством имен будем называть механизм среды Microsoft .NET, предназначенный для идентификации типов объектов языков программирования и среды реализации.

Описания пространств имен по аналогии с описаниями типов данных размещаются в файлах. Перечислим основные свойства, которыми характеризуются пространства имен в среде Microsoft .NET. Прежде всего, пространства имен могут как объединять различные сборки, так и быть вложенными друг в друга. Кроме того, файлы с описаниями могут содержать множественные пространства имен. Важно отметить, что между пространствами имен и файлами не существует однозначного соответствия. Наконец, полное имя типа должно содержать все необходимые пространства имен.

Приведем пример файла xxx.cs с описанием множественных пространств имен на языке C#:

xxx.cs namespace A { ... } namespace B { ... } namespace C { ... }

Приведем пример файла xxx.cs с описанием пространств имен на языке C# с неоднозначным (с учетом предыдущего примера) соответствием файлов и пространств имен:

xxx.cs namespace A { class C { ... } }

Кроме свойств, перечисленных выше, механизм пространств имен в среде вычислений .NET обладает еще целым рядом важных особенностей.

Так, допускается импорт пространств имен с использованием зарезервированного слова using языка программирования C# (похожий подход реализован в модулях языка Modula-2).Проиллюстрируем эту особенность фрагментом программы на языке C#:

using System;

Кроме того, существует возможность импорта одних пространств имен в другие. Проиллюстрируем это свойство фрагментом программы на языке C#:

using A; namespace B { using C; ... }

Отметим также, что для явного указания полных и сокращенных имен разрешаются псевдонимы (alias). Проиллюстрируем это свойство следующим примером программы на языке C#:

using F = System.Windows.Forms; ... F.Button b;

Как видно из приведенного фрагмента программы, для удобства вызова стандартного пространства имен .NET под именем System.Windows.Forms применяется псевдоним F.

Директива reference

Синтаксис:

Reference файл_с_кодом_компонента_1 [...]

Гетерогенные приложения

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

В качестве основной структурной единицы компонентного программирования выступает решение (solution), которое может состоять из сборок (assembly). Сборка представляет из себя управляемую динамическую библиотеку (DLL-файл) для .NET или приложение (EXE-файл). В каждом решении должна быть хотя бы одна сборка.

Для взаимодействия между сборками используется механизм ссылок. Ссылка (reference) - это пространство имен из одной сборки, доступное в другой. После добавления дополнительного проекта к решению и ссылки к основному проекту, в коде основного проекта можно пользоваться пространствами имен дополнительного.

Описание директивы export

Синтаксис:

export имя1[, имя2 ...]

При создании нового проекта SML.NET платформа автоматически заносит имя основной структуры SML-проекта в создаваемый файл. В случае добавления дополнительных файлов или создания дополнительных экспортируемых структур экспортом необходимо управлять вручную.

Для создания ссылки на другие проекты .NET в решении для SML.NET необходимо добавить директиву reference.

Порядок выполнения работы

Реализовать программу на C# в соответствии с вариантом исполнения.Представить в графическом виде взаимодействие компонентов в среде .NET.

Варианты заданий

Оснастить графическим интерфейсом на языке C# следующие функции на языке SML.

Реализовать функцию на языке программирования SML, которая выполняет синтаксический разбор следующего аппликативного выражения по ассоциации влево с построением бинарного дерева:

a(bc)ac(bc)(ac)(bc)(ab)(c(de))a(b(cd)(ef))a(b(cd)(ef)g)a(b((cd)(ef))(a(bc(de)f)gh)abb(cdd(e)fg)(ab(c(de))f(g(hi))j)

Реализовать функцию на языке программирования SML, которая выполняет синтаксический разбор следующего аппликативного выражения по ассоциации вправо с построением бинарного дерева:

a(bc)ac(bc)(ac)(bc)(ab)(c(de))a(b(cd)(ef))a(b(cd)(ef)g)a(b((cd)(ef))(a(bc(de)f)gh)abb(cdd(e)fg)(ab(c(de))f(g(hi))j)

Взаимодействие с SML.NET на компонентном уровне

Код SML.NET может создавать пространство имен, видимое в рамках других приложений. Для этого в файл script.smlnet добавляется директива export. Данная директива экспортирует фрагмент программы на языке программирования (скажем, SML) в форме объекта или структуры в пространство имен .NET. Последнее, в свою очередь, может быть использовано в любой сборке решения при добавлении соответствующей ссылки.

---