Понятие компонента, компонентной модели

Размещено на http://www.allbest.ru/

Введение

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

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

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

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

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

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

консольный программирование icomponent



Глава 1. Понятие компонента, компонентной модели, компоненто-ориентированного программирования

1.1 Понятие компонента и компонентной модели

Компонент (от лат. Сomponent - составляющий)- составная часть, элемент чего-либо. В программировании компонент-- это «кирпичик» программы, состоящий из свойств (properties), методов (methods) и событий (events). Свойства дают возможность управлять видом и поведением компонента, методы -- использовать возможности, предоставляемые компонентом, а события-- реагировать на происходящие внутри компонента события, программировать реакцию компонента на внешние события и т. д.

Разработка программы с помощью компонентов называется компонентно-ориентированным программированием.

Начнем с определения термина компонент в программировании. Компонент -- это независимый модуль, предназначенный для многократного использования и предоставляемый пользователю в двоичном формате. Это определение описывает четыре ключевых характеристики компонента. Рассмотрим их по очереди.

Компонент определен как независимый модуль. Это означает, что каждый компонент вполне самодостаточен. Другими словами, компонент обеспечивает полный набор функций. Его внутренняя работа закрыта для «внешнего мира», но при этом реализация может быть изменена без последствий для кода, в котором используется этот компонент.

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

Компонент представляет собой отдельный модуль. Это очень важно.

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

Наконец, компонент должен быть представлен в двоичном формате. Это принципиально важно. Хотя использовать компонент могут многие клиенты, они не имеют доступа к его исходному коду. Функциональность компонента открыта для клиентов только посредством его public-членов. Другими словами, именно компонент управляет тем, какие функции оставлять открытыми для клиентов, а какие -- держать «под замком”.

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

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

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

До создания С# и среды .NET Framework большинство компонентов были СОМ-компонентами. Модель СОМ была разработана для традиционной среды Windows и языка С++. Поэтому она в принципе не

в состоянии использовать преимущества новых методов управления памятью, которые реализованы в С# и .NET Framework. Как следствие, СОМ-контракт был довольно трудным для реализации и ненадежным. К счастью, С# и среда . NET Framework лишены практически всех проблем своих предшественников.

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

Узел позволяет связывать компоненты и контейнеры.

1.2 Интерфейс Icomponent и класc Component

Благодаря особенностям работы средств языка С#, любой его класс полностью соответствует общему определению компонента. Например, будучи скомпилированным, класс (в его двоичной форме) можно использовать в различных приложениях. Но значит ли это, что любой класс является компонентом? Ответ: нет. Для того чтобы класс стал компонентом, он должен следовать компонентной модели, определенной средой .NET Framework. К счастью, этого совсем не трудно добиться: такой класс должен реализовать интерфейс System.ComponentModel.Icomponent. При реализации интерфейса Icomponent компонент удовлетворяет набору правил, позволяющих компоненту быть совместимым со средой . Framework.

Несмотря на простоту реализации интерфейса Icomponent, во многих ситуациях лучше использовать альтернативный вариант - класс System.ComponentModel.Component. Класс Component обеспечивает стандартную реализацию интерфейса Icomponent. Он также поддерживает другие полезные средства, свойственные компонентам. Опыт показывает, что большинству создателей компонентов удобнее выводить их из класса Component, чем самим реализовать интерфейс Icomponent, поскольку в первом случае нужно попросту меньше программировать. Следовательно, в С# на создание компонента не требуется «героических усилий» со стороны программиста.

Интерфейс Icomponent определяет правило, которому должны следовать все компоненты. В интерфейсе Icomponent определено только одно свойство и одно событие. Вот как объявляется свойство Site:

Isite Site{ get; set; }

Свойство Site получает или устанавливает узел компонента. Узел идентифицирует компонент. Это свойство имеет null-значение, если компонент не хранится в контейнере. Событие, определенное в интерфейсе Icomponent, носит имя Disposed и объявляется так:

event EventHandler Disposed

Клиент, которому нужно получить уведомление при разрушении компонента, регистрирует обработчик событий посредством события Disposed. Интерфейс Icomponent также наследует интерфейс System.Idisposable, в котором определен методDispose():

void Dispose().

Этот метод освобождает ресурсы, используемые объектом. Несмотря на то что для создания компонента достаточно реализовать интерфейс Icomponent, намного проще создать класс, производный от класса Component, поскольку он реализует интерфейс Icomponent по умолчанию. Если класс наследует класс Component, значит, он автоматически выполняет правила, необходимые для получения .NET -совместимого компонента.

В классе Component определен конструктор только по умолчанию. Обычно программисты не создают объект класса Component напрямую, поскольку основное назначение этого класса -- быть базовым для создаваемых компонентов. В классе Component определено два открытых свойства. Объявление первого из них, свойства Container, такое:

public Icontainer Container {get; }

Свойство Container возвращает контейнер, который содержит вызывающий компонент. Если компонента нет в контейнере, возвращается значение null. Следует помнить, что свойство Container устанавливается не компонентом, а контейнером. Второе свойство, Site, определено в интерфейсе Icomponent. В классе Component оно реализовано как виртуальное:

public virtual Isite Site{ get; set; }

Свойство Site возвращает или устанавливает объект типа Isite, связанный с компонентом. Оно возвращает значение пи11, если компонента в контейнере нет. Свойство Site устанавливается не компонентом, а контейнером. В классе Component определено два открытых метода. Первый представляет собой переопределеие метода ToString(). Второй, метод Dispose(), используется в двух формах. Первая из них такова:

public void Dispose();

Метод Dispose(), вызванный в первой форме, освобождает любые ресурсы, используемые вызывающим компонентом. Этот метод реализует метод Dispose(), определенный в интерфейсе System.Idisposable. Для освобождения компонента и занимаемых им ресурсов клиент вызывает именно эту версию метода Dispose(). Вот как выглядит вторая форма метода Dispose():

protected virtual public void Dispose(bool how);

Если параметр how имеет значение true , эта версия метода освобождает как управляемые, так и неуправляемые ресурсы, используемые вызывающим объектом. Если how равно значению false, освобождаются только неуправляемые ресурсы. Поскольку эта версия метода Dispose() защищена (protected), ее нельзя вызвать из кода клиента. Поэтому клиент использует первую версию. Другими словами, вызов первой версии метода Dispose() генерирует обращение к методу Dispose(bool how). В общем случае компонент, в котором больше нет необходимости, переопределяет версию Dispose(bool how), если он содержит ресурсы, которые нужно освободить. Если компонент не занимает никаких ресурсов, то для его освобождения достаточно стандартной реализации метода Dispose(bool how), определенной в классе Component.

Класс Component наследует класс MarshalByRefObject, который используется в том случае, когда компонент создается вне локальной среды, например в другом процессе или на другом компьютере, связанном с первым по сети. Для обмена данными (аргументами методов и возвращаемыми значениями) должен существовать механизм, который определит способ пересылки данных. По умолчанию принимается, что информация должна передаваться по значению, но при унаследовании класса MarshalByRefObject данные будут передаваться по ссылке. Таким образом, С#-компонент обеспечивает передачу данных по ссылке.

1.3 Анализ пространства имен System ComponentModel

Пространства имен System.ComponentModel содержат типы, реализующие поведение компонентов и элементов управления во время разработки и выполнения. Дочерние пространства имен поддерживают Managed Extensibility Framework (MEF), обеспечивают классы атрибутов, определяющие метаданные для элементов управления платформы динамических данных ASP.NET, и содержат типы, позволяющие определять поведение компонентов и элементов управления во время разработки.

Пространство имен	Описание
System.ComponentModel	Пространство имен System.ComponentModel содержит классы, реализующие поведение компонентов и элементов управления во время проектирования и выполнения. Данное пространство имен включает базовые классы и интерфейсы, предназначенные для реализации преобразователей атрибутов и типов, для привязки к источникам данных и для лицензирования компонентов.
System.ComponentModel.Composition	Это пространство имен предоставляет классы, которые составляют основу платформы Managed Extensibility Framework (MEF).
System.ComponentModel.Composition.Hosting	System.ComponentModel.Composition.Hosting пространство имен предоставляет управляемые типы .NET Framework расширяемости (MEF), которые полезны для разработчиков расширяемых приложений или узлы.
System.ComponentModel.Design	Пространство имен System.ComponentModel.Design содержит классы, которые могут использоваться разработчиками для организации нужного поведения компонентов на этапе разработки и для создания интерфейсов пользователя, позволяющих настраивать компоненты во время разработки. Среда разработки предоставляет средства, позволяющие задавать расположение компонентов и значения их параметров. Чтобы некоторые компоненты правильно работали в среде режима разработки, нужно задать для них определенное поведение, используемое только на этапе разработки. Иногда важно также предоставить разработчикам специальные пользовательские интерфейсы для настройки компонентов или значений сложных типов данных. Классы и интерфейсы, определенные в этом пространстве имен, можно использовать для задания поведения компонентов на этапе разработки, для доступа к службам во время разработки и для реализации настраиваемых интерфейсов конфигурации в режиме разработки.
System.ComponentModel.Design.Data	Пространство имен System.ComponentModel.Design.Data содержит классы, которые можно использовать для построения пользовательского поведения компонентов, связанных с данными, во время разработки.
System.ComponentModel.Design.Serialization	Пространство имен System.ComponentModel.Design.Serialization предоставляет типы, поддерживающие настройку и осуществляющие контроль за сериализацией во время разработки.
System.ComponentModel.DataAnnotations.Schema	Пространство имен System.ComponentModel.DataAnnotations.Schema предоставляет поддержку классов атрибутов, используемых для определения метаданных для ASP.NET MVC и элементов управления данными ASP.NET.

1.4 Достоинства и недостатки компонентов

Компонентно-ориентированная разработка имеет свои сильные и слабые стороны. Несомненными достоинствами является повторная используемость кода, согласованность пользовательского интерфейса, возможность быстрой и продуктивной разработки программ. Именно компоненты позволяют программистам составлять конечный продукт из «кирпичиков», не вдаваясь в детали реализации конкретного компонента. Конечно, наборы классов, используемые при объектно-ориентированном подходе, тоже дают возможность повторного использования кода, но компоненты делают повторное использование кода совершенно естественным. Если при разработке системы все программисты команды пользуются одним и тем же набором визуальных компонентов, то, само собой, интерфейс у программы будет выполнен в едином стиле. Более того, поменяв, например, вид одного из компонентов, мы изменим его вид везде, где он используется.

Компоненты дают возможность независимой разработки частей интерфейса. Изменения внутри компонента не затрагивают код модулей, в которых он используется. Разработка нескольких независимых классов дает примерно те же результаты, за исключением одной проблемы. Среди программистов средней квалификации наблюдается тенденция перемешивать функциональность классов, путая методы одного класса с другим. Компоненты разделяют код более качественно. Свойства компонентов позволяют наиболее эффективно объяснить другому программисту, как использовать компонент. Специальные редакторы свойств позволяют быстро настроить вид и поведение компонентов. Наконец, накопив достаточное количество компонентов, можно действительно быстро создать визуальный интерфейс программы, фактически, не написав более ни строчки кода!

Чем же придется заплатить за все это? Как это не удивительно звучит, но платить придется объектно-ориентированным подходом. Возможность гибкого управления поведением компонентов с помощью событий провоцирует написанием «событийно-ориентированного» кода. Пусть, например, нам нужен компонент для отображения цветных строк. Объектно-ориентированный подход обязывает нас создать наследника класса ListBox и, перекрыв метод Paint(), реализовать отрисовку цветных строк. Возможность реализовать событие OnPaint и не создавать никаких классов подталкивает многих программистов к использованию событий в ущерб объектно-ориентированному подходу. Именно «подталкивает», т. К. никто не мешает создать новый компонент, умеющий рисовать цветные строки на основе существующего компонента ListBox. Такой подход и будет наиболее верным -- ведь такие компоненты можно использовать повторно!

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

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

1.5 Визуальные и не визуальные компоненты в дизайнере формы

Библиотека .NET Framework имеет два типа компонентов: визуальные и не визуальные. Визуальные компоненты являются элементами пользовательского интерфейса. Это, например, компоненты: кнопка (Button), выпадающий список (ComboBox) или метка (Label). Не визуальные компоненты не имеют пользовательского интерфейса и не могут располагаться на форме. Дизайнер Visual Studio располагает их внизу окна дизайнера. Такими компонентами являются, например, компоненты работы с базами данных, таймер (Timer), компонент работы с последовательным портом (SerialPort) и др.



Глава 2. Разработка пользовательских компонентов

2.1 Создание визуального компонента и его тестирование

В качеств визуального компонента рассмотрим разработку приложения "Будильник" на языке программирования С#. Для его создания понадобится создать приложение Windows Forms.

Среди основных компонентов, которые понадобятся при создании будильника, можно выделить следующие элементы: текстовое поле TextBox для ввода некоторых значений, метки label, содержащие определенную информацию о файлах, три кнопки, по щелчку на которые будут происходить определенные действия, а также маска текстовое поля MaskedTextBox, которая позволяет задать значения элемента заданного поля в соответствии с выбранной пользователем маской. Последним элементом формы будет элемент AxWindowsMediaPlayer, содержащий стандартные элементы проигрывания музыкального трека, включающие воспроизведение, остановку, перемотку. После того, как все отмеченные элементы будут добавлены на форму, она примет вид, показанный на рисунке.

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

При этом код программы будет следующим:

string music;

private void button1_Click(object sender, EventArgs e)

{

OpenFileDialog open = new OpenFileDialog();

if (open.ShowDialog() == DialogResult.OK)

{

music = open.FileName;

textBox1.Text = open.SafeFileName;

}

}

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

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

private void button2_Click(object sender, EventArgs e)

{

label2.Text = maskedTextBox1.Text;

maskedTextBox1.Text = "";

timer2.Start();

}

В начале происходит запись значения из поля MaskedTextBox1 в поле label2. После этого значение поля MaskedTextBox1 и происходит вызов функции timer2.Start(). Данная функция проверяет, соответствует ли время, введенное в поле label2 тому, что находится в поле label1. Стоит отметить, что в поле label1 находится текущее время, которое записывается туда при помощи функции timer1_tick:

private void timer1_Tick(object sender, EventArgs e)

{

label1.Text = DateTime.Now.Hour.ToString("00") + ":" + DateTime.Now.Minute.ToString("00")+":"+DateTime.Now.Second.ToString("00);

}

Данная функция при помощи методов класса DateTime считывает текущее значение часов, минут и секунд, которые имеются на данном копмьютере. После этого идет проверка, соответствует ли введенное пользователем значение времени текущему времени на компьютере.

private void timer2_Tick(object sender, EventArgs e)

{

if (label1.Text == label2.Text)

axWindowsMediaPlayer1.URL = music;

}

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

Как только данная аудиозапись перестанет быть актуальной, то нужно нажать на кнопку Стоп, на которую также установлен обработчик события OnClick, содержащий следующий код:

private void button3_Click(object sender, EventArgs e)

{

axWindowsMediaPlayer1.Ctlcontrols.stop();

timer2.Stop();

}

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

2.2 Создание консольного компонента и его тестирование

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

Рассмотреть пример создания компонента CipherCom, который реализует очень простую стратегию шифрования. Ее суть состоит в том, что каждый символ шифруется путем добавления к его коду единицы. Дешифрирование заключается в вычитании единицы. Чтобы зашифровать таким способом строку, достаточно вызвать метод Encode (), передав незашифрованный текст в качестве аргумента. Чтобы дешифровать зашифрованную строку, вызовите метод Decode (), передав ему как аргумент зашифрованный текст. В обоих случаях возвращаются строки, содержащие результат (шифрования или дешифрирования).

Для этого запускаем программу Microsoft Visual Studio.

Назовем класс CipherLib.

Добавить директиву using System.ComponentModel;

namespace CipherLib

{

// Обратите внимание на то, что класс CipherComp

// наследует класс Component.

public class CipherCom : Component

{

// Шифруем строку.

public string Encode(string msg)

{

string temp = "";

for (int i = 0; i < msg.Length; i++)

temp += (char)(msg[i] + 1);

return temp;

}

// Дешифруем строку,

public string Decode(string msg)

{

string temp = "";

for (int i = 0; i < msg.Length; i++)

temp += (char)(msg[i] - 1);

return temp;

}

}

}

Итак, рассмотрим этот код подробнее. Прежде всего, как предлагается в комментарии, назовем этот файл CipherLib.cs. Это упростит использование рассматриваемого компонента, если вы работаете в среде разработки Visual Studio IDE. Затем обратите внимание на включение пространства имен System.ComponentModel. Как упоминалось выше, оно как раз и предназначено для поддержки программирования компонентов.

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

Класс CipherComp наследует класс Component. Это означает, что класс CipherComp удовлетворяет всем требованиям для того, чтобы быть .NET-совместимым компонентом. Поскольку класс CipherComp очень простой, ему не нужно обеспечивать выполнение специфических для компонентов функций. Его действия можно определить как тривиальные.

Обратите также внимание на то, что класс CipherComp не распределяет системных ресурсов. Другими словами, он не хранит ссылок на другие объекты. Он просто определяет два метода Encode () и Decode (). А поскольку в классе CipherComp ссылки не хранятся, ему не нужно реализовать метод Dispose (bool). Безусловно, оба метода Encode () и Decode () возвращают ссылки на строки, но эти ссылки принадлежат вызывающему коду, а не объекту класса CipherComp.

Кимпиляция компонента CipherLib:компонент должен быть скомпилирован с получением dll-, а не ехе-файла.

Клиент, использующий компонент CipherComp: после создания компонент "готов к употреблению". Например, следующая программа является клиентом компонента CipherComp, который она использует для шифрования и дешифрирования символьной строки.

Создаём новый проект с имени CipherCompClient :

Для этого запускаем программу Microsoft Visual Studio.

(будем сохранять этот проект на своей папке).

При использовании среды разработки Visual Studio IDE необходимо для программы-клиента добавить компонент CipherLib.dll как ссылку().

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using CipherLib; // Импортируем пространство имен

// компонента CipherComp..

namespace CipherCompClient

{

class CipherCompClient

{

public static void Main()

{

CipherComр cc = new CipherCom();

string text = "Гурдова Оразгул ";

string ciphertext =cc.Encode(text);

Console.WriteLine(ciphertext);

string plaintext = cc.Decode(ciphertext);

Console.WriteLine(plaintext);

cc.Dispose(); // Освобождаем ресурсы.

}

}

}

Заметьте, что клиент включает пространство имен компонента CipherLib. Благодаря этому компонент CipherComp попадает в "поле зрения" клиента. Можно было бы полностью определять каждую ссылку на компонент CipherComp, но включение его пространства имен упрощает работу с компонентом. Во всем остальном компонент CipherComp используется подобно любому другому классу.

Обратите внимание на обращение к методу Dispose() в конце программы. Как разъяснялось выше, посредством вызова метода Dispose () клиент освобождает ресурсы, которые использовал компонент. Компоненты, подобно другим объектам С#, используют один и тот же механизм сбора мусора, который выполняется спорадически. Однако вызов метода Dispose() заставляет компонент немедленно освободить свои ресурсы. Это очень важно в некоторых ситуациях, например, когда компонент удерживает такой ограниченный ресурс, как подключение к сети. Поскольку компонент CipherComp не занимает ресурсы, вызов метода Dispose() в этом примере не актуален. Но так как метод Dispose() является частью контракта компонентной модели, имеет смысл всегда вызывать его при завершении работы с компонентом.

При выполнении программы client получаем следующие результаты:

2.3 Создание ссылки на компонент

Можно создавать ссылки на компоненты .NET, которые находятся в глобальном кэше сборок (GAC) или на компоненты COM, зарегистрированные на компьютере. Также можно делать ссылки на компоненты, которые находятся на жестком диске, но не внесены в глобальный кэш сборок (GAC). Создание ссылки на компонент делает его доступным для использования в коде.

Добавление ссылок на компоненты .NET, зарегистрированные в платформе .NET Framework: в меню Веб-узел выбрать команду Добавить ссылку и щелкните вкладку .NET в диалоговом окне. Выбрать необходимый компонент из списка компонентов .NET и нажмите кнопку ОК. Если необходимый компонент отсутствует, выбрать вкладку Обзор и найдите файл сборки на собственном жестком диске.

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

Рассмотрим программу-клиент, которая использует компонент CipherCom (см. 2.2 Создание консольного компонента и его тестирование) и для его освобождения вместо прямого обращения к методу Dispose() применяет инструкцию using:

using System.Text;

using CipherLib; // Импортируем пространство имен

// компонента CipherComp.

namespace CipherCompClient

{

class CipherCompClient

{

public static void Main()

{

// Объект ее разрушится по завершении этого блока,

using (CipherCom cc = new CipherCom())

{

string text = "Инструкция using.";

string ciphertext = cc.Encode(text);

Console.WriteLine(ciphertext);

string plaintext = cc.Decode(ciphertext);

Console.WriteLine(plaintext);

}

}

}

}

Результаты выполнения этой программы таковы:



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



Заключение

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

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

При такой мощности компонентов и простоте их создания в С# на вопрос: "Компоненты -- это будущее программирования?" многие программисты отвечают без колебаний: "Да!"

В ходе курсовой работы было рассмотрено понятие компонента и компонентной модели в языке программирования С#. Были определены достоинства и недостатки такого подхода к решению задач.

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



Литеритура

1. Троелсен Э. Язык программирования С# 2010 и платформа .NET 4.0/ Э. Троелсен. - Москва: Вильямс, 2011.- 1392 с.

2. Шилдт Г. С# 4.0: полное руководство / Г. Шилдт. - Москва: Вильямс, 2012.- 1056 с.

3. Стиллмен Э. Изучаем С# / Э. Стиллмен, Дж. Грин.- Санкт - Петербург: Мир книг ,2012 .- 694 с.

Размещено на Allbest.ru

...