Автоматизированное рабочее место библиотекаря

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

Тема курсовой: Автоматизированное рабочее место библиотекаря

Предмет: Средства визуального программирования приложений

Условия: Для книг, хранящихся в библиотеке, задаются:

-номер по порядку

-автор книги (Ф.И.О.) ,

-название книги,

-год издания книги,

-издательство книги,

-количество страниц в книге

-регистрационный номер книги,

-номер стеложа где находится (лежит) книга (т.е.библиотекарь вручную должен всё это вписывать и оно должно сохраняться)

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

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

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

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

По примеру ниже лабораторных работ необходимо написать курсовую работу тема и условия которой были изложены выше только в Microsoft Visual Studio 2008 на языке С#.

1. Лабораторная работа: Создание главного окна приложения в среде С#

Цель работы: Изучить основные элементы среды разработки Visual Studio Integrated Development Environment ( IDE - интегрированная среда разработки) C# при создании на языке C# приложений с графически интерфейсом.

Основные сведения

Среда разработки Visual Studio Integrated Development Environment (IDE) - интегрированная среда разработки) включает набор инструментов и не зависит от используемых языков программирования, представленных в Visual Studio. Visual Studioможно использовать для создания кода и на различных языках программирования: управляемый C++ - Manadged C++, Visual Basic.NET, Java.NET, C#.

В лабораторной работе проводится изучении среды разработки на языке программирования C# и следующих средств проектирования Windows - приложений:

основные окна среды разработки C#;

· построение базовой инфраструктуры с помощью Application Wizard (мастер создания приложений);

· использование дизайнера форм Dialog Painter (программа для рисования диалоговых окон) для оформления диалоговых окон;

· добавление новых функциональных возможностей в приложение с использованием вкладки Properties(свойства).

Обзор среды разработки C#

Для начала работы с Visual Studio.NET необходимо из главного меню выбрать пункт "Microsoft Visual Studio.NET" (VS). При этом на компьютере загрузится Developer Studio (визуальная среда разработки Microsoft Visual ) на экране компьютера будет выведено окно, изображенное на рисунке 1.1.

Проектирование приложения

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

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

2. Для создания каркаса приложения можно использовать мастер создания приложений - Application Wizard.

3. Изменить внешний вид автоматически создаваемых мастером окон до желаемого вида.

Рис. 1.1 Стартовое диалоговое окно IDE

4. Добавить код C#, который будет вызывать отображение приветствия.

Создание рабочей области проекта

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

1. Щелкните на ссылке Project (Создать новый проект) метки Create на начальной странице (Start Page) VS.NET. При этом откроется окно создания нового проекта New Project (рисунок 1.2).

Рис. 1.2 Мастер создания нового проекта (New Project Wizard)

2. В дереве, отображаемом в подокне Project Type (Типы проектов) выберите "Visual C# /Windows". В подокнеTemplates (Шаблоны) выберите Windows Application (Приложение Windows ).

3. В поле Name (Название проекта) наберите имя проекта - Project_К4И_01 (имя проекта присваивается в соответствии со следующим синтаксисом: Project_"номер группы"_"номер бригады в группе" ).

4. Щелкните на кнопке ОК. (Да). Мастер создания нового проекта создаст новый класс Form1, производный отSystem.Windows.Forms.Form с правильно настроенным методом Main( ). В свойствах проекта автоматически будут созданы ссылки на необходимые сборки библиотеки базовых классов. На экране появится графический шаблон среды разработки (рисунок 1.3).

Рис. 1.3 Графический шаблон главного окна приложения

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

Для просмотра кода сгенерированного приложения можно в окне Solution Explorer щелкнуть правой кнопкой мыши на файле Form1.cs и в контекстном меню выбрать View Code (рисунок 1.4).

Рис. 1.4 Выбор режима View Code в контекстном меню

В результате будет выведен на экран следующий листинг кода приложения

using System;

using System.Collections.Generic;

using System.ComponentModel;

using System.Data;

using System.Drawing;

using System.Text;

using System.Windows.Forms;

namespace Project_К4И_01

{

public partial class Form1 : Form

{

public Form1()

{ InitializeComponent(); }

}

}

Инициализация компонент реализуется кодом, который можно отобразить, в окне Solution Explorer щелкнуть на пункте Form.Designer.cs (рисунок 1.5).



Рис. 1.5 Выбор режима Form.Designer.cs

namespace Project_К4И_01

{

partial class Form1

{

private System.ComponentModel.IContainer components = null;

protected override void Dispose(bool disposing)

{

if (disposing && (components != null))

{

components.Dispose();

}

base.Dispose(disposing);

}

#region Windows Form Designer generated code

private void InitializeComponent()

{

this.components = new System.ComponentModel.Container();

this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;

this.Text = "Form1";

}

#endregion

}

}

В определении класса Form1 используется ключевое слово partial, которое позволяет определять класс, структуру или интерфейс, распределенные по нескольким файлам. В Visual Studio 2005 классы Windows -форм формируются в двух файлах: Form1.cs и Form1.Designer.cs. В файле Form1.Designer.cs присутствует код, сгенерированный дизайнером Windows -формы, а файле Form1.cs - присутствует код инициализации класса и пользовательские члены класса (поля, свойства, методы, события, делегаты)

Код приложения (Program.cs) имеет следующий вид:

using System;

using System.Collections.Generic;

using System.Windows.Forms;

namespace Project_К4И_01

{

static class Program

{

[STAThread]

static void Main()

{

Application.EnableVisualStyles();

Application.SetCompatibleTextRenderingDefault(false);

Application.Run(new Form1());

}

}

}

Метод Main является точкой входа для приложения и вызывает Application.Run, который создает класс Form1.

Класс System.Windows.Forms.Application

Класс Application можно рассматривать как "класс низшего уровня", позволяющий нам управлять поведением приложения Windows Forms. Кроме того, этот класс определяет набор событий уровня всего приложения, например закрытие приложения или простой центрального процессора.

Наиболее важные методы этого класса (все они являются статическими) перечислены в таблице 1.1.

Таблица 1.1. Наиболее важные методы типа Application

Метод класса	Назначение Application
AddMessageFilter( )	Эти методы позволяют приложению перехватывать сообщения RemoveMessageFilter( ) и выполнять с этими сообщениями необходимые предварительные действия. Для того чтобы добавить фильтр сообщений, необходимо указать класс, реализующий интерфейсIMessageFilter
DoEvents( )	Обеспечивает способность приложения обрабатывать сообщения из очереди сообщений во время выполнения какой-либо длительной операции. Можно сказать, что DoEvents() - это "быстрый и грязный" заменитель нормальной многопоточности
Exit( )	Завершает работу приложения
ExitThred( )	Прекращает обработку сообщений для текущего потока и закрывает все окна, владельцем которых является этот поток
OLERequired( )	Инициализирует библиотеки OLE. Можете считать этот метод эквивалентом .NET для вызываемого вручную метода Olelnitialize( )
Run( )	Запускает стандартный цикл работы с сообщениями для текущего потока

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

Таблица 1.2. Наиболее важные свойства типа Application

Свойство	Назначение
CommonAppDataRegistry	Возвращает параметр системного реестра, который хранит общую для всех пользователей информацию о приложении
CompanyName	Возвращает имя компании
CurrentCulture	Позволяет задать или получить информацию о естественном языке, для работы с которым предназначен текущий поток
CurrentlnputLanguage	Позволяет задать или получить информацию о естественном языке для ввода информации, получаемой текущим потоком
ProductName	Для получения имени программного продукта, которое ассоциировано с данным приложением
ProductVersion	Позволяет получить номер версии программного продукта
StartupPath	Позволяет определить имя выполняемого файла для работающего приложения и путь к нему в операционной системе

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

Таким образом, при помощи многих свойств (например, CompanyName или ProductName ) можно очень просто получить метаданные уровня сборки. В сборке можно использовать любое количество встроенных и пользовательских атрибутов. В результате можно получить значение атрибута [assembly:AssemblyCompany(" ")] при помощи свойства Application.CompanyName без необходимости прибегать к использованию типов, определенных в пространстве имен System.Reflection.

Проектирование окна приложения

Для разметки окон приложения в соответствии с требованиями пользователя необходимо изменить свойства класса Forms1. Это можно сделать с помощью дизайнера окон ( Form Designer ), путем изменения свойств в окне Свойства ( Properties ) или в коде программы.

Размеры окна можно изменить непосредственно в Form Designer с помощью мыши захватывая и, растягивая/сжимая границы окна.

Для изменения других свойств окна необходимо окно свойств Properties.

На вкладке Properties измените значение в поле Text (Заголовок) наПроект К4И. При этом на форме изменится заголовок окна (рисунок 1.6).

Рис. 1.6 Изменение значения в поле Text на вкладке Properties

Откомпилируйте приложение, выбрав из главного меню команду Build Project_К4И_01 (рисунок 1.7)

Рис. 1.7 Выбор из главного меню команды Build

В строке состояний должно появиться сообщение:

Build succeeded

Для запуска приложения выберите из главного меню команду Debug/Start (F5). Приложение запустится в отладочном режиме и на экране появится разработанное окно (рисунок 1.8.).

Рис. 1.8. Окно приложения Project_К4И_01

Для закрытия окна щелкните мышью на кнопке

Добавление нового кода в приложение

Добавим в главную форму элемент контроля - кнопку. Для этого откроем вкладку ToolBox (рисунок 1.9) и сначала щелкнем мышью на элементе Button вкладки, а затем щелкнем мышью на форме.

Рис. 1.9 Вкладка ToolBox

В результате получим форму с кнопкой (рисунок 1.10).

Рис. 1.10 Форма с установленной кнопкой

Установите кнопку в требуемое место на форме с помощью мыши.

Для задания текста на кнопке выделите ее на форме и откройте вкладку Свойства и измените свойство Text на "Приветствие". В результате название кнопки изменится (рисунок 1.11).

Рис. 1.11 Форма с измененным свойством Text кнопки

Для связывания функций кнопки с диалоговым окном необходимо создать обработчик события на нажатие кнопки. Для этого сделайте двойной щелчок на кнопке. В результате в коде приложения сформируется шаблон функции обработчика события Click для кнопки.

private void button1_Click(object sender, EventArgs e)

{

}

В полученный шаблон добавим функцию вывода диалогового окна с сообщением.

private void button1_Click(object sender, EventArgs e)

{

// Сообщение

MessageBox.Show("Поздравляю с первым проектом на C#");

}

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

Рис. 1.12 Результат выполнения приложения

Рис. 1.13 Вывод сообщения

Структура и синтаксис функции

Рассмотрим код листинга функции:

private void button1_Click(object sender, EventArgs e)

{

// Сообщение

MessageBox.Show("Поздравляю с первым проектом на C#");

}

Первая строка является частью оболочки функции, сгенерированной Developer Studio на языке C#.

Первое слово в строке, private определяет видимость функции как внутреннюю, т.е. видимую только для членов класса Form1. Второе слово void, определяет тип данных возвращаемого значения (результата). Ключевое слово void, - перед именем функции, или в качестве аргумента функции (в скобках в конце строки), означает отсутствие соответствующего элемента. Третье слово в строке, button1_Click, обозначает имя функции. За именем функции следует список передаваемых ей аргументов, заключенный в круглые скобки. Круглые скобки нужно использовать всегда, даже когда у функции нет параметров.

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

В следующей строке листинга открывающая фигурная скобка ( { ) отмечает начало тела функции. В конце тела функции ставится закрывающая фигурная скобка ( } ).

Правило 2. Тело функции всегда заключается в фигурные скобки {}.

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

Последняя строка в добавленном нами коде (в тексте это две строки):

MessageBox.Show("Поздравляю с первым проектом на C#");

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

MessageBox.Show messageBox.Show messagebox.Show

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

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

2. Лабораторная работа: Создание главного меню приложения

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

Указания по использованию .NET

В любом языке программирования существуют традиционные стили программирования. Эти стили являются не частью самого языка, а соглашениями, скажем, по именованию переменных или использованию определенных классов, методов или функций. Если большинство разработчиков будут следовать одинаковым соглашениям, то им будет проще понять код друг друга, что, в свою очередь, облегчает поддержку программы. Так, общим соглашением в Visual Basic 6 было то, что строковые переменные должны иметь имена, начинающиеся с s или str, например String sResult или String strMessage. Однако соглашения зависят от языка и среды разработки. Программисты на C++ для платформы Windows традиционно используют префикс psz или lpsz для обозначения строк: char *pszResult; char *lpszMessage;. Но на Unix-машинах такие префиксы не применяются: char *Result; char *Message;.

В соответствии с соглашениями в С# имена переменных не должны иметь префиксов: string Result; string Message;.

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

В то время как для многих языков соглашения по именованию вырабатывались одновременно с развитием языка, для С# и платформы .NET Microsoft написала подробные рекомендации по использованию, которые приведены в документации MSDN для .NET/C#. Следовательно, с самого начала программы .NET будут иметь более высокий уровень совместимости по части понимания кода другими разработчиками. Эти рекомендации были разработаны с учетом опыта, полученного на протяжении более двадцати лет объектно-ориентированного программирования, и в результате являются тщательно продуманными и хорошо восприняты сообществом разработчиков.

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

Одним из важных моментов является выбор имен для элементов программы: переменных, методов, классов, перечислений и пространств имен.

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

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

Например, Height - хорошее название, a IntegerValue - нет. Однако этот принцип является труднодостижимым идеалом. В частности, при работе с элементами управления в большинстве случаев вам будет удобнее использовать имена переменных, подобные ConfirmationDialog и ChooseEmployeeListBox.

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

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

Например: EmployeeSalary, ConfirmationDialog, PlainTextEncoding.

Соединение слов с помощью знака подчеркивания не приветствуется, поэтому не придумывайте такие имена, как employee_salary. В других языках часто используют все прописные буквы в названиях констант. Это не рекомендуется в С#, поскольку такие имена трудно читать, лучше применять паскалевский стиль:

const int MaximumLength;

Еще одна рекомендуемая схема - именование в стиле camel. Именование camel аналогично паскалевскому стилю, за исключением того, что первая буква первого слова не является прописной: employeeSalary, confirmationDialog, plainTextEncoding.

Существуют две ситуации, в которых лучше применять такое именование. Имена всех параметров, передаваемых в методы, должны записываться в стиле camel:

public void RecordSale (string salesmanName,int guanuity);

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

private string employeeName;

public string EmployeeName

{ get

{ return employeeName; }

}

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

В большинстве случаев следует применять соглашения Pascal. Тем не менее, соглашение camel рекомендуется для закрытых переменных, которые не видны вне класса, где две переменные имеют одинаковое назначение. Например, если есть public свойство, которое инкапсулирует private поле с тем же именем, то можно использовать соглашение camel для поля и соглашение Pascal для свойства, как в приведенном выше примереEmployeeName.

Также необходимо обращать внимание на чувствительность к регистру. С# чувствителен к регистру, поэтому синтаксически в С# допустимо, чтобы имена различались только регистром. Однако нужно помнить, что ваши сборки могут быть вызваны из приложений VB.NET, a VB.NET не является чувствительным к регистру. Поэтому использовать имена, отличающиеся только регистром, можно лишь в том случае, если они никогда не будут видны вне сборки. В противном случае код, написанный в VB.NET, не сможет корректно использовать вашу сборку.

Необходимо по возможности делать так, чтобы стиль всех имен совпадал. Например, если один из методов в классе называется ShowConfirmationDialog, то другому методу не следует давать имя ShowDialogWarning илиWarningDialogShow. Он должен называться ShowWarningDialog.

Имена пространств имен следует выбирать особенно тщательно для того, чтобы избежать использования такого же имени, которое применяется где-то еще. Необходимо помнить, что .NET различает имена объектов в разделяемых сборках только по именам пространств имен. Если использовать для двух пакетов программного обеспечения одно и то же имя пространства имен и установить оба пакета на один компьютер, возникнут проблемы. Рекомендуется создавать пространство имен верхнего уровня с именем вашей компании, а затем вкладывать пространства имен, постепенно сужая их названия до технологии, группы или отдела, где вы работаете, или до названия пакета, для которого предназначены ваши классы. Microsoft рекомендует имена пространств имен, которые начинаются с <НазваниеКомпании>.<НазваниеТехнологии>, например,

WeaponsOfDestructionCorp.RayGunControllers

или

WeaponsOfDestructionCorp.Viruses.

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

Создание меню

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

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

Элемент управления MenuStrip - это контейнер для структур меню в приложении. Этот элемент управлении наследуется от ToolStrip. Система меню строится добавлением объектов ToolStripMenu к menuStrip.

Класс ToolStripMenuItem служит для построения структур меню. Каждый объект ToolStripMenuItemпредставляет отдельный пункт в системе меню.

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

Рис. 2.1 Элемент управления MenuStrip

Элемент управления MenuStrip позволит вводить текст меню непосредственно в элементы меню. То, что должно получиться, представлено на рисунке 2.2.

Рис. 2.2 Простое меню на форме

При помощи графических средств можно настроить свойства любого элемента меню. Для пункта меню "Объект"зададим свойство Name равным objektToolStripMenuItem, для пункта меню "Выход" ) -exitToolStripMenuItem, а для пункта меню "Справка" - HelpToolStripMenuItem.

При двойном щелчке на пункте меню "Выход" (объект exitToolStripMenuItem ) Visual Studio автоматически сгенерирует оболочку для обработчика события Click и перейдет в окно кода, в котором нам будет предложено создать логику метода (в нашем случае exitToolStripMenuItem_Click ):

private void exitToolStripMenuItem_Click(object sender, EventArgs e)

{

// Здесь мы определяем реакцию на выбор пользователем

// пункта меню

}

На вкладке Свойства (Properties) при выводе окна событий, нажать кнопкусобытию Click будет соответствовать метод menuItemExit_Click (рисунок 2.3).

Рис. 2.3 Событие Click и обработчик события exitToolStripMenuItem_Click

Для корректного завершения приложения написать код для обработчика exitToolStripMenuItem_Click. Это можно сделать с помощью метода Exit класса Application:

private void exitToolStripMenuItem_Click(object sender, EventArgs e)

{

Application.Exit();

}

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

private void objektToolStripMenuItem_Click(object sender, EventArgs e)

{

MessageBox.Show("Пункт меню Объект");

}

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

3. Лабораторная работа: Создание многооконного приложения

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

Создание дочерней формы

Основа Интерфейса ( MDI ) приложения - MDI родительская форма. Это - форма, которая содержит MDI дочерние окна. Дочерние окна являются "подокнами", с которыми пользователь взаимодействует вMDI приложении. Создание MDI родительской формы описано в лабораторной работе 2.

Для определения главного окна ( Form1 ), как родительской формы в окне Свойств, установите IsMDIContainerсвойство - true. Это определяет форму как MDI контейнер для дочерних форм. Для того чтобы родительское окно занимало весь экран необходимо свойству WindowsState установить значение Maximized.

Создайте еще одно окно, которое будет дочерним ( FormEmployee ). Для этого выберите пункт меню Project/Add Windows Form.

Это окно должно вызываться из пункта главного меню "Сотрудник". Вставьте код, подобный следующему, чтобы создать новую MDI дочернюю форму, когда пользователь щелкает на пункте меню, например "Сотрудник" - имя объекта - employeeToolStripMenuItem (В примере ниже, указатель события обращается к событию Click дляemployeeToolStripMenuItem_Click ).

private void menuItemEmploye_Click(object sender,

System.EventArgs e)

{ // Создать объект FEmployee класса FormEmployee

FormEmployee FEmployee = new FormEmployee();

// Установить родительское окно для дочернего

FEmployee.MdiParent = this;

// Вывести на экран дочерее окно

FEmployee.Show();

}

Данный обработчик приведет к выводу на экран дочернего окна.

Создание меню в дочерней форме

Добавьте в (Свойствах в графе Name) дочернее окно пункт меню "Действие" ( actionToolStripMenuItem ) с подпунктами "Отменить" (undoToolStripMenuItem ), "Создать" ( createToolStripMenuItem ), "Редактировать" ( editToolStripMenuItem ), "Сохранить" ( saveToolStripMenuItem ) и "Удалить" ( removeToolStripMenuItem ). Перед пунктом удалить вставьте разделитель ( Separator - name = toolStripSeparator1 ).

Добавьте в дочернее окно еще один пункт меню "Отчет" ( reportToolStripMenuItem ) c подпунктами "По сотруднику" ( reportToolStripMenuItem1 ), "По всем сотрудникам" ( reportToolStripMenuItem2 ). Дочернее окно будет иметь вид, представленный на рисунке 3.1

Рис. 3.1 Дочернее окно с меню

В главном меню родительской формы ( Form1 ) имеются пункты "Объект", "Справочник" и "Справка". В дочерней форме ( FormEmployee ) сформированы пункты меню "Действие" и "Отчет". При загрузке дочерней формы меню родительской и дочерних форм должны были объединены и составлять следующую последовательность: "Объект", "Действие", "Отчет", "Справочник" и "Справка". Объединение пунктов меню производится с помощью задания значений свойств MergeAction и MergeIndex для объектов ToolStripMenuItem.

Проверьте, чтобы в меню главного окна(материнская форма) для объекта objectToolStripMenuItem свойство MergeAction было установлено Append, а MergeIndex было равно 0, а для объектов dictionaryToolStripMenuItem иhelpToolStripMenuItem - соответственно 1 и 2. С учетом этого, в окне "Сотрудник" для объектовactionToolStripMenuItem (Действие) и "Отчет" ( reportToolStripMenuItem ) свойству MergeAction необходимо задать значение Insert, а свойству MergeIndex задаем порядковый номер который определяет позицию данного пункта меню обновленном главном меню, т.е. 1 (после объекта objectToolStripMenuItem ).

После компиляции программы, запуска ее на выполнение и вызова пункта меню "Сотрудник" экран должен иметь вид, представленный на рисунке 3.2.

Рис. 3.2 Дочернее окно с подключенным меню

Создание обработчиков для меню дочерней формы

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

Описанную функциональность целесообразно реализовать в программе в виде методов класса созданного FormEmployee. В приложении необходимо создать следующие методы:

· Undo - отменить;

· New - создать;

· Edit - редактировать;

· Save - сохранить;

· Remove - удалить.

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

Для создания метода Undo в коде файла FormEmployee.cs добавьте следующий метод:

private void Undo( )

{ MessageBox.Show("метод Undo"); }

Далее создаем обработчик события вызова пункта меню "Отменить". Для этого в дизайнере формы классаFormEmployee делаем двойной щелчок на пункте меню "Отменить". Инструментальная среда VS сгенерирует следующий код:

private void undoToolStripMenuItem_Click(object sender, EventArgs e)

{

}

В код обработчика undoToolStripMenuItem_Click добавим вызов метода Undo:

private void undoToolStripMenuItem_Click(object sender, EventArgs e)

{

Undo();

}

Откомпилируем приложение и протестируем вызов метода Undo. В результате выбора пункта меню "Отменить" должно быть выведено диалоговое окно с сообщением, приведенным на рисунке 3.3.

Рис. 3.3 Дочернее окно с подключенным меню

Аналогичным образом создайте методы-заглушки для функций "Создать", "Редактировать", "Сохранить" и "Удалить".

4. Лабораторная работа: Создание пользовательских диалоговых окон

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

Основные сведения

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

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

Простейшее модальное диалоговое окно можно создать на базе класса MessageBox, входящего в библиотеку Microsoft .NET Framework. В лабораторной работе 3 иллюстрировалось применение простейшего модального диалогового окна для вывода сообщения об активизации метода Undo. Для отображения диалогового окна использовался метод Show, передав ему через параметр текст сообщения "метод Undo". Прототип использованного методаShow следующий:

public static DialogResult Show(string message);

Когда пользователь щелкает кнопку ОК, метод Show возвращает значение, равное DialogResult.OK

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

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

public static DialogResult Show

{

string message, // текст сообщения

string caption, // заголовок окна

MessageBoxButtons btns, // кнопки, расположенные в окне

MessageBoxIcon icon, // значок, расположенный в окне

MessageBoxDefaultButton defButton, // кнопка по умолчанию

MessageBoxOptions opt // дополнительные параметры

};

Параметр caption позволяет задать текст заголовка диалогового окна MessageBox. С помощью параметра btns можно указать, какие кнопки необходимо расположить в окне диалогового окна. Этот параметр задается константами из перечисления MessageBoxButtons (таблица 4.1)

Таблица 4.1 Перечисление MessageBoxButtons

Константа	Кнопки, отображаемые в окне MessageBox
ОК	OK
OKCancel	OK, Cancel
YesNo	Yes, No
YesNoCancel	Yes, No, Cancel
RetryCancel	Retry, Cancel
AbortRetryIgnore	Abort, Retry, Ignore

Параметр icon метода MessageBox.Show позволяет выбрать один из нескольких значков для расположения в левой части диалогового окна. Он задается в виде константы перечисления MessageBoxIcon (таблица 4.2).

Таблица 4.2 Перечисление MessageBoxIcon

Константа	Значок
Asterisk, Information
Error, Stop
Exclamation, Warning
Question
None	Значок не отображается

Параметр defButton метода MessageBox.Show предназначен для выбора кнопки, которая получит фокус сразу после отображения диалогового окна. Этот параметр должен иметь одно из значений перечисления MessageBoxDefaultButton (таблица 4.3).

Таблица 4.3. Перечисление MessageBoxDefaultButton

Константа	Номер кнопки, получающей фокус ввода по умолчанию
Button l	1
Button 2	2
Button 3	3

Если в диалоговом окне отображаются кнопки Yes, No и Cancel, то они будут пронумерованы последовательно: кнопка Yesполучит номер 1 (константа Button1 ), кнопка No - номер 2 (константа Button2 ), а кнопка Cancel - номер 3 (константаButton3 ).

Параметр opt метода MessageBox.Show позволяет задать дополнительные параметры. Эти параметры должны иметь значения из перечисления MessageBoxOptions (таблица 4.4).

графический интерфейс меню development

Таблица 4.4. Перечисление MessageBoxOptions

Константа	Описание
DefaultDesktopOnly	Окно с сообщением отображается только на рабочем столе, выбранном по умолчанию
RightAlign	Текст сообщения выравнивается по правому краю диалогового окна
RtlReading	Текст отображается справа налево
ServiceNotification	Окно отображается на активном рабочем столе, даже если к системе не подключился ни один пользователь. Данный параметр предназначен для приложений, работающих как сервисы ОС Microsoft Windows

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

Метод MessageBox.Show может вернуть одно из нескольких значений перечисления DialogResult (таблица 4.5).

Таблица 4.5. Перечисление DialoqResult

Константа	Кнопка, при щелчке которой возвращается эта константа
Abort	Abort
Cancel	Cancel
Ignore	Ignore
No	No
None	Модальное диалоговое окно продолжает работать
OK	OK
Retry	Retry
Yes	Yes

Изменим метод Remove, добавив в него предупреждение перед удалением данных по сотруднику. Текст кода метода Removeдолжен иметь следующий вид:

private void Remove()

{

DialogResult result = MessageBox.Show(" Удалить данные \n по сотруднику? ",

"Предупреждение", MessageBoxButtons.YesNo, MessageBoxIcon.Warning,

MessageBoxDefaultButton.Button2);

switch (result)

{

case DialogResult.Yes:

{

//выполнить действия по удалению данных по сотруднику

MessageBox.Show("Удаление данных");

break;

}

case DialogResult.No:

{

//отмена удаления данных по сотруднику

MessageBox.Show("Отмена удаления данных");

break;

}

}

В результате исполнения кода приложения и выбора пункта меню "Удалить" будет выводиться предупреждение, приведенное на рисунке 4.1

Рис. 4.1 Модальное диалоговое окно предупреждения

Диалоговое окно можно создать не только на основе класса MessageBox, но и с использованием Windows - формы.

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

Рис. 4.2 Общий вид Windows - формы FormAbout

Для этого добавим в проект новый компонент (рисунок 4.3), выбрав из списка AboutBox (рис. 4.4).

Рис. 4.3 Выбор режима добавления нового компонента в проект

Рис. 4.4 Добавление нового компонента в проект

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

Мы введем собственную информацию. Для этого изменим фрагмент кода конструктора класса AboutBox1 следующим образом.

public AboutBox1()

{

InitializeComponent();

this.Text = String.Format("О программе {0}", AssemblyTitle);

this.labelProductName.Text = AssemblyProduct;

this.labelVersion.Text = String.Format("Version {0}", AssemblyVersion);

this.labelCopyright.Text = "@БГУ, 2012";

this.labelCompanyName.Text = "Данилова Г.В.";

this.textBoxDescription.Text = "Дисциплина Средства визуального программирования приложений.";

}

Для открытия пользовательского модального диалогового окна используется метод ShowDialog. В лабораторной работе диалоговое окно должно открываться при щелчке пользователем на пункте в меню "Справка/О программе". Код для открытия диалогового окна может выглядеть следующим образом:

// Открываем модальное диалоговое окно

private void aboutToolStripMenuItem_Click(object sender, EventArgs e)

{

AboutBox1 aboutBox = new AboutBox1();

aboutBox.ShowDialog(this);

}

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

После компиляции и загрузки приложения, вызвав пункт меню "Справка/О программе" на дисплеи будет выведено диалоговое окно, приведенное на рисунке 4.5.

Рис. 4.5 Вызов модального окна

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

5. Лабораторная работа: Создание панели инструментов и контекстного меню

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

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

Разработка панели инструментов

Элемент управления ToolStrip используется непосредственно для построения панелей инструментов. Данный элемент использует набор элементов управления, происходящих от класса ToolStripItem.

В Visual Studio.NET предусмотрены средства, которые позволяют добавить панель инструментов при помощи графических средств. Для этого необходимо открыть панель Toolbox и добавьте элемент управленияToolStrip (рисунок 5.1) на разрабатываемую форму FormEmployee.

Рис. 5.1 Окно свойств панели инструментов

В выпадающем меню элемента управления ToolStrip на форме FormEmployee необходимо выбрать элемент управления button - кнопка (рисунок 5.2). При этом в панели инструментов добавится кнопка.

Рис. 5.2 Окно свойств панели инструментов

Добавьте на панель инструментов кнопки с именами toolStripButtonUndo, toolStripButtonNew, toolStripButtonEdit, toolStripButtonSave, toolStripButtonRemove. В результате должна быть сформирована панель инструментов с кнопками (рисунок 5.3).

Рис. 5.3 Форма FormEmployee с панелью инструментов

Для кнопок панели инструментов сформируем графическое представление. Это можно сделать путем задания свойства Image соответствующей кнопке (рисунок 5.4).

При открытии коллекции свойства Image соответствующей кнопки, нажатии кнопкиоткрывается окно мастера выбора графического ресурса (рисунок 5.5).

Рис. 5.4 Свойство Image для кнопки панели инструментов

Рис. 5.5 Добавление изображения в ImageList

С помощью кнопки Import в локальный ресурс добавляют ссылки на необходимые графические файлы, для формирования изображения кнопок. Результаты формирования графического представления кнопок панель инструментов приведены на рисунке 5.6. Графические файлы расположены в папке Visual Studio 2005\VS2005ImageLibrary\bitmaps\commands\16color (для лабораторной работы графические файлы можно найти в папке Лабораторные работы).

Рис. 5.6 Форма с панелью инструментов

Каждая кнопка панели инструментов, которая является объектом класса toolStripButton, может содержать текст, или изображение, или и то и другое.

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

Для удобства пользователя целесообразно снабдить кнопки панели инструментов всплывающими подсказками при фокусировке курсора на данной кнопке. Это можно сделать, если свойству ToolTipText классаtoolStripButton задать значение текстовой строки с содержанием подсказки. На рисунке 5.7 для кнопки "Отменить" ( toolStripButtonUndo ) строка подсказки ToolTipText соответствует строке "Отменить".

Рис. 5.7 Формирование подсказки для кнопки

На рисунке 5.8 показан вывод подсказки при фокусировке курсора на кнопке панели инструментов.

Рис. 5.8 Вывод подсказки для кнопки

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

private void toolStripButtonUndo_Click(object sender, EventArgs e)

{

Undo();

}

Контекстное меню

Класс ContextMenuStrip применяется для показа контекстного меню, или меню, отображаемого по нажатию правой кнопки мыши. Для создания объекта класса ContextMenuStrip необходимо открыть панель Toolbox и добавить элемент управления contextMenuStrip на форму FormEmployee (рисунок 5.9).

Рис. 5.9 Формирование на форме контекстного меню

В результате получаем форму FormEmployee с контекстным меню (рисунок 5.10)

Рис. 5.10 Форма с контекстным меню

Формирование пунктов контекстного меню производится аналогично формированию пунктов главного меню (смотри лабораторную работу 2). Сформированное контекстное меню приведено на рисунке 5.11.

Рис. 5.11 Вид контекстного меню

После формирования пунктов контекстного меню необходимо его подключить к форме FormEmployee. Для этого на вкладке Свойства ( Properties ) формы FormEmployee строке, соответствующей свойству ContextMenuStripнужно установить значение созданного объекта contextMenuStrip1 (рис. 5.12)

Рис. 5.12 Подключение контекстного меню к форме

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

Рис. 5.13 Активизация контекстного меню

Привязка пунктов контекстного меню к конкретным функциям осуществляется путем создания кода обработчика событий для каждого пункта меню. Для формирования обработчика необходимо перейти в окно дизайнера формы FormEmployee, выделить на форме класс ContextMenuStrip и сделать двойной щелчок на соответствующем пункте меню, например "Отменить". В сгенерированном обработчике необходимо добавить вызов метода, для функции "Отменить" - метод Undo( ). Листинг обработчика метода приведен ниже.

private void undo1ToolStripMenuItem_Click(object sender, EventArgs e)

{

Undo();

}

6. Лабораторная работа: Создание строки состояния

Цель работы: Изучить основные способы построения строки состояния и получить практические навыки в разработке

Создание строки состояния

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

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

В окне Toolbox выделим пункт StatusStrip и перетащим его на форму (рисунок 6.1).

Рис. 6.1 Добавляем на форму строку состояния

Объекту класса StatusStrip присвоим имя statusStripEmployee. Откроем выпадающий список объекта классаstatusBarEmployee и выберем объект StatusLable (рисунок 6.2). Присвоим ему имяtoolStripStatusLabelEmployee.

Рис. 6.2 Добавляем метку в строку состояния

При компиляции, запуске приложения и выборе пункта меню "Сотрудник" экранная форма будет иметь вид, представленный на рисунке 6.3.

Рис. 6.3 Окно приложения со строкой состояния

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

Для формы FormEmployee в строке состояний необходимо вывести информацию при наведении курсора мыши на пунктах меню "Действие". Первоначально в дизайнере формы необходимо выделить пункт меню "Действие", перейти на вкладку Properties и открыть окно событий, нажав кнопкуНа данной вкладке необходимо выделить событие MouseEnter и в поле ввода сделать двойной щелчок. (рисунок 6.4).

Рис. 6.4 Окно событий

Система сгенерирует код обработчика, приведенного ниже.

private void actionToolStripMenuItem_MouseEnter(object sender, EventArgs e)

{ }

Добавим в обработчик следующий код:

private void actionToolStripMenuItem_MouseEnter(object sender, EventArgs e)

{

toolStripStatusLabelEmployee.Text =

"Выбор действий по сотрудникам";

}

Если откомпилировать программу, запустить её, выбрать пункт меню "Сотрудник" и навести указатель мыши на пункт "Действие", то сгенерируется событие "MouseEnter" и в строке состояния выведется текстовое сообщение "Выбор действий по сотрудникам" (рисунок 6.5).

Рис. 6.5 Вывод сообщения в строке состояния

Если теперь переместить указатель мыши с пункта меню "Действие", то текст в строке состояния не изменится. Такой режим работы программы является неправильным, так как если указатель мыши перемещается с пункта меню "Действие", то строка состояния должна становиться пустой. Для обеспечения правильной работы программы воспользуемся ещё одним событием "MouseLeave", которое генерируется, когда мышь перемещается (покидает) с пункта меню "Действие". Обработчик данного события имеет следующий вид:

private void actionToolStripMenuItem_MouseLeave(object sender, EventArgs e)

{

toolStripStatusLabelEmployee.Text = "";

}

Вышеприведенные обработчики будут вызываться только тогда, когда пользователь наведет указатель мыши на пункт меню "Действие". Для того чтобы обработчики реагировали на все строки пунктов главного меню"Действие" и "Отчет" формы FormEmployee необходимо сформировать соответствующие события MouseEnter иMouseLeave для всех подпунктов меню и создать для них обработчики.

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

Рис. 6.6 Экранная форма со строкой состояния

7. Лабораторная работа: Создание элементов управления

· Цель работы: Изучить основные элементы управленияWindows -форм, их свойства и методы, а также получить практические навыки в разработке Windows -форм с элементами контроля

· Общие сведения

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

· Класс Control, как общий предок, обеспечивает все производные классы общим набором важнейших возможностей. В числе этих возможностей можно перечислить события мыши и клавиатуры, физические размеры и местонахождение элемента управления (свойства Height, Width, Left, Right, Location ), установку цвета фона и цвета переднего плана, выбор шрифта и т.п.

· При создании приложения можно добавить элементы управления на форму при помощи графических средствVisual Studio. Обычно достаточно выбрать нужный элемент управления в окне ToolBox и поместить его на форме.Visual Studio автоматически сгенерирует нужный код для формы. После этого можно изменить название элемента управления на более содержательное (например, вместо button1, предлагаемого по умолчанию, - buttonPrimer) Visual Studio позволяет не только размещать на форме элементы управления, но и настраивать их свойства. Для этого достаточно щелкнуть на элементе управления правой кнопкой мыши и в контекстном меню выбратьProperties (Свойства).

Рис. 7.1 Иерархия элементов управления Windows Forms

Все изменения, которые необходимо произвести в открывшемся окне (рисунок 7.2), будут добавлены в код метода InitializeComponents().

Рис. 7.2 Настройка элементов управления средствами Visual Studio

То же самое окно позволяет настроить не только свойства данного элемента управления, но и обработку событий этого элемента. Перейти в список событий можно при помощи кнопкив закладке Properties(рисунок 7.3). Можно выбрать в списке нужное событие и рядом с ним сделать двойной щелчок или ввести имя метода или выбрать метод из списка.

Рис. 7.3 Настройка обработчиков событий

После задания имени метода или двойного щелчка Visual Studio сгенерирует заготовку для обработчика события.

...