шпоргалка исис

Билет №1. Платформа Microsoft .Net Framework 2.0.

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

.NET Framework является надстройкой над операционной системой, в качестве которой может выступать любая версия Windows, Unix и вообще любая ОС (по заверению разработчиков), и состоит из ряда компонентов. Так, .NET Framework включает в себя:

1.Четыре официальных языка: С#, VB.NET, Managed C++ и JScript .NET.

2.Общеязыковую объектно-ориентированную среду выполнения CLR (Common Language Runtime), совместно используемую этими языками для создания приложений.

3.Ряд связанных между собой библиотек классов под общим именем FCL (Framework Class Library).

Основным компонентом платформы .NET Framework является общеязыковая среда выполнения программ CLR. Название среды – «общеязыковая среда выполнения» - говорит само за себя: это исполняющая среда, которая подходит для различных языков программирования. К функциям CLR относятся:

1)двухшаговая компиляция: преобразование программы, написанной на одном из языков программирования в управляемый код на промежуточном языке (Microsoft Intermediate Language, MSIL, или просто IL), а затем преобразование IL-кода в машинный код конкретного процессора, который выполняется с помощью виртуальной машины или JIT-компилятора (Just In Time compiler - компилирование точно к нужному моменту);

2)управление кодом: загрузка и выполнение уже готового IL-кода с помощью JIT-компилятора;

3)осуществление доступа к метаданным с целью проверки безопасности кода;

4)управление памятью при размещении объектов с помощью сборщика мусора (Garbage Collector);

5)обработка исключений и исключительных ситуаций, включая межъязыковые исключения;

6)осуществление взаимодействия между управляемым кодом (код, созданный для СLR) и неуправляемым кодом;

7)поддержка сервисов для разработки разнотипных приложений.

Следующим компонентом .Net Framework является FCL – библиотека классов платформы. Эта библиотека разбита на несколько модулей таким образом, что имеется возможность использовать ту или иную ее часть в зависимости от требуемых результатов. Так, например, в одном из модулей содержатся "кирпичики", из которых можно построить Windows-приложения, в другом — "кирпичики", необходимые для организации работы в сети и т.д.

Часть FCL посвящена описанию базисных типов. Тип — это способ представления данных; определение наиболее фундаментальных из них облегчает совместное использование языков программирования с помощью .NET Framework. Все вместе это называется Common Type System (CTS — единая система типов).

Кроме того, библиотека FCL включает в себя Common Language Specification (CLS –

общая языковая спецификация), которая устанавливает: основные правила языковой интеграции. Спецификация CLS определяет минимальные требования, предъявляемые к языку платформы .NET. Компиляторы, удовлетворяющие этой спецификации, создают объекты, способные взаимодействовать друг с другом. Поэтому любой язык, соответствующий требованиям CLS, может использовать все возможности библиотеки FCL.

Как уже отмечалось, основными языками, предназначенными для платформы .NET Framework, являются С#, VB.NET, Managed C++ и JScript .NET. Для данных языков Microsoft предлагает собственные компиляторы, переводящие программу в IL-код, который выполняется JIT-компилятором среды CLR. Кроме Microsoft, еще несколько компаний и академических организаций создали свои собственные компиляторы, генерирующие код, работающий в CLR. На сегодняшний момент известны компиляторы для Pascal, Cobol, Lisp, Perl, Prolog и т.д. Это означает, что можно написать программу, например, на языке Pascal, а затем, воспользовавшись соответствующим компилятором, создать управляемый код, который будет работать в среде

CLR.

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

.NET Framework не налагает никаких ограничений на возможные типы создаваемых приложений. Тем не менее, давайте рассмотрим некоторые наиболее часто встречающиеся типы приложений:

1)Консольные приложения позволяют выполнять вывод на «консоль», то есть в окно командного процессора.

2)Windows-приложения, использующие элементы интерфейса Windows, включая формы, кнопки, флажки и т.д.

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

4)Web-сервисы представляют собой распределенные приложения, которые позволяют обмениваться по Интернету практически любыми данными с использованием единого синтаксиса независимо от того, какой язык программирования применялся при создании web-службы и на какой системы она размещена.

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

Удобной средой разработки приложений является Visual Studio .Net.

Билет №2. Среда разработки Visual Studio .Net. Компиляция и выполнение программы в среде CLR

Компиляция и выполнение программы в среде CLR

В прошлом почти все компиляторы генерировали код для конкретных процессорных архитектур. Все CLR-совместимые компиляторы вместо этого генерируют IL-код, который также называется управляемым модулем, потому что CLR управляет его жизненным циклом и выполнением. Рассмотрим составные части управляемого модуля:

1.Заголовок PE32 или PE32+: Файл с заголовком в формате PE32 может выполняться в 32или 64разрядной ОС, а с заголовком PE32+ только в 64-разрядной ОС. Заголовок показывает тип файла: GUI, GUI или DLL, он также имеет временную метку, показывающую, когда файл был собран. Для модулей, содержащих только IL-код, основной объем информации в РЕ-заголовке игнорируется, Для модулей, содержащих процессорный код, этот заголовок содержит сведения о процессорном коде.

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

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

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

b.при компиляции IL-кода в машинный код CLR выполняет верификацию (проверку «безопасности» выполнения кода) используя метаданные, например, нужное ли число параметров передается методу, корректны ли их типы, правильно ли используется возвращаемое значение и т.д.

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

4.IL-код: управляемый код, создаваемый компилятором при компиляции исходного кода. Во время

исполнения CLR компилирует IL-код в команды процессора.

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

Непосредственно перед исполнением функции Main CLR находит все типы, на которые ссылается ее код. В нашем случае метод Main ссылается на единственный тип — Console, и CLR выделяет единственную внутреннюю структуру WriteLine.

Когда Main первый раз обращается к WriteLine, вызывается функция JITCompiler (условное название), которая отвечает за компиляцию IL-кода вызываемого метода в собственные команды процессора. Функции JITCompiler известен вызываемый метод и тип, в котором он определен. JITCompiler ищет в метаданных соответствующей сборки IL-код вызываемого метода, затем проверяет и компилирует IL-код в собственные команды процессора, которые сохраняются в динамически выделенном блоке памяти. После этого JITCompiler возвращается к внутренней структуре данных типа и заменяет адрес вызываемого метода адресом блока памяти, содержащего собственные команды процессора. В завершение JITCompiler передает управление коду в этом блоке памяти. Далее управление возвращается в Main, который продолжает работу в обычном порядке.

Затем Main обращается к WriteLine вторично. К этому моменту код WriteLine уже проверен и скомпилирован, так что производится обращение к блоку памяти, минуя вызов JITCompiler. Отработав, метод WriteLine возвращает управление Main.

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

Билет №3. Состав языка С#. Типы данных. Переменные, именованные константы.

Состав языка

Алфавит – совокупность допустимых в языке символов. Алфавит языка С++ включает:

1)прописные и строчные латинские буквы и буквы национальных алфавитов (включая кириллицу);

2)арабские цифры от 0 до 9, шестнадцатеричные цифры от A до F;

4)пробельные символы: пробел, символ табуляции, символ перехода на новую строку.

Из символов алфавита формируются лексемы языка: идентификаторы, ключевые (зарезервированные) слова, знаки операций, константы, разделители (скобки, точка, запятая, пробельные символы).

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

Идентификатор – это имя программного элемента: константы, переменной, метки, типа, класса, объекта, метода и т.д. Идентификатор может включать латинские буквы и буквы национальных алфавитов, цифры и символ подчеркивания. Прописные и строчные буквы различаются, например, myname, myName и MyName — три различных имени. Первым символом идентификатора может быть буква или знак подчеркивания, но не цифра.

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

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

В нотации Pascal каждое слово, входящее в идентификатор, начинается с заглавной буквы. Например:Age, LastName, TimeOfDeath.

Венгерская нотация отличается от предыдущей наличием префикса, соответствующего типу величины. Например: fAge, sName, iTime.

В нотации Camel с заглавной буквы начинается каждое слово идентификатора, кроме первого. Например: age, lastName, timeOfDeath.

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

Ключевые слова – это зарезервированные идентификаторы, которые имеют специальное значение для компилятора, например, include, main, int и т.д. Ключевые слова можно использовать только по прямому назначению. С ключевыми словами и их назначением можно ознакомиться в справочной системе С#.

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

Типы данных

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

д.).

В С# типы делятся на две группы: базовые типы, предлагаемые языком, и типы, определяемые пользователем. Кроме того, типы С# разбиваются на две другие категории: размерные типы (типы по значению) и ссылочные типы. Почти все базовые типы являются размерными типами. Исключение составляют типы Object и String. Все пользовательские типы, кроме структур, являются ссылочными. Дополнительно к упомянутым типам, язык С# поддерживает типы указателей, однако они используются только с неуправляемым кодом.

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

Замечание. Стек- это структура, используемая для хранения элементов по принципу первым пришел - последним ушел. В данном случае под стеком понимается область памяти, обслуживаемая процессором, в которой хранятся значения локальных переменных. Куча – область памяти, которая используется для хранения данных, работа с которыми реализуется через указатели и ссылки. Память для размещения таких данных динамически выделяется или освобождается в куче неявно (средствами CLR) или явно (программистом).

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

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

VB.NET).

Переменные и константы

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

В языке С# требуется, чтобы переменные были явно проинициализированы до их

использования.

Константа - это переменная, значение которой нельзя изменить. Константы бывают

const <тип> <идентификатор> = <значение>;

Перечисления (enumerations) являются альтернативой константам. Перечисление - это особый размерный тип, состоящий из набора именованных констант (называемых списком перечисления).

Синтаксис определения перечисления следующий: [атрибуты] [модификаторы] enum <имя> [ : базовый тип] {список-перечисления констант(через запятую)};

Базовый тип - это тип самого перечисления. Если не указать базовый тип, то по умолчанию будет использован тип int. В качестве базового типа можно выбрать любой целый тип, кроме char. Пример использования перечисления:

Билет №4. Выражения в C#. Преобразование типов.

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

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

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

Операции преобразования типов

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

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

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

1)при присваивании объекта переменной целевого типа;

2)при использовании объекта в выражении, содержащем переменные целевого типа;

3)при передаче объекта в метод параметра целевого типа;

4)при явном приведении типа.

Явное преобразование выполняется при использовании операции приведения типа. При определении операции преобразования типа следует учитывать следующие

особенности:

1)тип возвращаемого значения (целевой_тип) включается в сигнатуру объявителя операции;

2)ключевые слова explicit и implicit не включаются в сигнатуру объявителя операции. Следовательно, для одного и того класса нельзя определить одновременно и явную, и

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

Билет №5. Ввод-вывод данных. Форматирование данных.

Вывод данных

Вприведенных выше примерах мы уже рассматривали метод WriteLine,

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

1. Console.WriteLine(x); //на экран выводится значение идентификатора х

2.Console.WriteLine("x=" + x +"y=" + y); /* на экран выводится строка, образованная последовательным слиянием строки "x=", значения x, строки "у=" и значения у */

3.Console.WriteLine("x={0} y={1}", x, y); /* на экран выводится строка, формат которой задан первым аргументом метода, при этом вместо параметра {0} выводится значение x, а вместо {1} – значение y*/

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

1)Использование управляющих последовательностей:

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

1)Управление размером поля вывода:

Первым аргументом WriteLine указывается строка вида {n, m} – где n определяет номер идентификатора из списка аргументов метода WriteLine, а m – количество позиций (размер поля вывода), отводимых под значение данного идентификатора. При этом значение идентификатора выравнивается по правому краю. Если выделенных позиций для размещения значения идентификатора окажется недостаточно, то автоматически добавиться необходимое количество позиций.

2)Управление размещением вещественных данных:

Первым аргументом WriteLine указывается строка вида {n: ##.###} – где n определяет номер идентификатора из списка аргументов метода WriteLine, а ##.### определяет формат вывода вещественного числа. В данном случае под целую часть числа отводится две позиции, под дробную – три. Если выделенных позиций для размещения целой части значения идентификатора окажется недостаточно, то автоматически добавиться необходимое количество позиций.

3)Управление форматом числовых данных:

Первым аргументом WriteLine указывается строка вида {n: <спецификатор>m} – где n определяет номер идентификатора из списка аргументов метода WriteLine, <спецификатор> - определяет формат данных, а m – количество позиций для дробной части значения идентификатора. В качестве спецификаторов могут использоваться следующие значения:

Ввод данных

Для ввода данных обычно используется метод ReadLine, реализованный в классе Console. Особенностью данного метода является то, что в качестве результата он возвращает строку (string).

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

Билет №8. Операторы передачи управления (goto, break, continue).

В С# есть несколько операторов, изменяющих естественный порядок выполнения команд: оператор безусловного перехода goto, оператор выхода break, оператор перехода к следующей итерации цикла continue, оператор возврата из метода return и оператор генерации исключения throw.

Оператор безусловного перехода goto

Оператор безусловного перехода goto имеет формат:

goto <метка>;

В теле той же функции должна присутствовать ровно одна конструкция вида: <метка>: <оператор>;

Оператор goto передает управление на помеченный меткой оператор.

Следует учитывать, что использование оператора goto затрудняет чтение больших по объему программ, поэтому использовать метки нужно только в крайних случаях, например, в операторе switch.

Оператор выхода break

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

Мы уже применяли оператор break для выхода из оператора switch, аналогичным образом он может применяться для выхода из других операторов.

Оператор перехода к следующей итерации цикла continue

Оператор перехода к следующей итерации цикла continue пропускает все операторы, оставшиеся до конца тела цикла, и передает управление на начало следующей итерации (повторение тела цикла).

Билет №6. Основные операции С#.

1. Инкремент (++) и декримент(--).

Эти операции имеют две формы записи — префиксную, когда операция записывается перед операндом, и постфиксную – операция записывается после операнда. Префиксная операция инкремента (декремента) увеличивает (уменьшает) свой операнд и возвращает измененное значение как результат. Постфиксные версии инкремента и декремента возвращают первоначальное значение операнда, а затем изменяют его.

2. Операция new. Используется для создания нового объекта. С помощью ее можно создавать как объекты ссылочного типа, так и размерные, например:

object z=new object();

int i=new int(); // то же самое, что и int i =0;

3. Отрицание:

Арифметическое отрицание (-) – меняет знак операнда на противоположный.

Логическое отрицание (!) – определяет операцию инверсия для логического типа.

4. Явное преобразование типа. Используется для явного преобразования из одного типа в другой. Формат операции:

(тип) выражение;

5.Умножение (*), деление (/) и деление с остатком (%). Операции умножения и деления применимы для целочисленных и вещественных типов данных. Для других типов эти операции применимы, если для них возможно неявное преобразование к целым или вещественным типам. При этом тип результата равен «наибольшему» из типов операндов, но не менее int. Если оба операнда при делении целочисленные, то и результат тоже целочисленный.

6.Сложение (+) и вычитание (-).Операции сложения и вычитания применимы для целочисленных и вещественных типов данных. Для других типов эти операции применимы, если для них возможно неявное преобразование к целым или вещественным типам.

7.Операции отношения ( <, <=, >, >=, ==, !=). Операции отношения сравнивают значения левого и правого операндов. Результат операции логического типа: true – если значения совпадают, false – в противном случае.

8.Логические операции: И (&&), ИЛИ (||).

Логические операции применяются к операндам логического типа.

Результат логической операции И имеет значение истина тогда и только тогда, когда оба операнда принимают значение истина.

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

9. Условная операция.

Операнд1 – это логическое выражение, которое оценивается с точки зрения его эквивалентности константам true и false. Если результат вычисления операнда1 равен true, то результатом условной операции будет значение операнда2, иначе — операнда3. Фактически условная операция является сокращенной формой условного оператора if, который будет рассмотрен позже.

10. Операции присваивания: =, +=, -= и т.д.

Формат операции простого присваивания (=):

операнд_2 = операнд_1;

В результате выполнения этой операции вычисляется значение операнда_1, и результат записывается в операнд_2.

Билет №7. Операторы ветвления (if, switch).

Операторы ветвления

Операторы ветвления позволяют изменить порядок выполнения операторов в программе. К операторам ветвления относятся условный оператор if и оператор выбора switch.

Условный оператор if

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

Форма сокращенного оператора if:

if (B) S;

где В – логическое или арифметическое выражение, истинность которого проверяется; S – оператор: простой или составной.

При выполнении сокращенной формы оператора if сначала вычисляется выражение B, затем проводится анализ его результата: если B истинно, то выполняется оператор S; если B ложно, то оператор S пропускается. Таким образом, с помощью сокращенной формы оператора if можно либо выполнить оператор S, либо пропустить его.

Форма полного оператора if:

if (B) S1; else S2;

где B – логическое или арифметическое выражение, истинность которого проверяется; S1, S2- оператор: простой или составной.

При выполнении полной формы оператора if сначала вычисляется выражение B, затем анализируется его результат: если B истинно, то выполняется оператор S1, а оператор S2 пропускается; если B ложно, то выполняется оператор S2, а S1 – пропускается. Таким образом, с помощью полной формы оператора if можно выбрать одно из двух альтернативных действий процесса обработки данных.

Оператор выбора switch

Оператор выбора switch предназначен для разветвления процесса вычислений по нескольким направлениям. Формат оператора:

switch ( <выражение> )

{

case <константное_выражение_1>: [<оператор 1>]; <оператор перехода>;

case <константное_выражение_2>: [<оператор 2>]; <оператор перехода>;

...

case <константное_выражение_n>: [<оператор n>]; <оператор перехода>;

[default: <оператор>; ]

}

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

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

Билет №9. Операторы цикла (while, do, for)

Операторы цикла

Операторы цикла используются для организации многократно повторяющихся вычислений. К операторам цикла относятся: цикл с предусловием while, цикл с постусловием do while, цикл с параметром for и цикл перебора foreach..

Цикл с предусловием while

Оператор цикла while организует выполнение одного оператора (простого или составного) неизвестное заранее число раз. Формат цикла while:

while (B) S;

где B – выражение, истинность которого проверяется (условие завершения цикла); S – тело цикла - оператор (простой или составной).

Перед каждым выполнением тела цикла анализируется значение выражения В: если оно истинно, то выполняется тело цикла, и управление передается на повторную проверку условия В; если значение В ложно – цикл завершается и управление передается на оператор, следующий за оператором S.

Цикл с постусловием do while

Оператор цикла do while также организует выполнение одного оператора (простого или составного) неизвестное заранее число раз. Однако в отличие от цикла while условие завершения цикла проверяется после выполнения тела цикла. Формат цикла do while:

do S while (B);

где В – выражение, истинность которого проверяется (условие завершения цикла); S – тело цикла - оператор (простой или блок).

Сначала выполняется оператор S, а затем анализируется значение выражения В: если оно истинно, то управление передается оператору S, если ложно - цикл завершается, и управление передается на оператор, следующий за условием B. Так как условие В проверяется после выполнения тела цикла, то в любом случае тело цикла выполнится хотя бы один раз.

Цикл с параметром for

Цикл с параметром имеет следующую структуру:

for ( <инициализация>; <выражение>; <модификация>) <оператор>;

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

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

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

Оператор (простой или составной) представляет собой тело цикла.

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

Билет №10. Массивы: одномерные.

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

Одномерные массивы

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

0, 1, 2, 3, 4, 5, 6, 7, 8, 9.

Одномерный массив в С# реализуется как объект, по этому его создание представляет собой двухступенчатый процесс. Сначала объявляется ссылочная переменная на массив, затем выделяется память под требуемое количество элементов базового типа, и ссылочной переменной присваивается адрес нулевого элемента в массиве. Базовый тип определяет тип данных каждого элемента массива. Количество элементов, которые будут храниться в массиве, определяется размер массива.

Объявление: базовый_тип [] имя__массива; Например: int [] a;

базовый_тип [] имя__массива = new базовый_тип [размер]; Например: int []a=new int [10]; базовый_тип [] имя__массива={список инициализации}; Например: int []a={0, 1, 2, 3};

Обращения к элементам массива происходи с помощью индекса, для этого нужно указать имя массива и в квадратных скобках его номер. Например, a[0], b[10], c[i].

Так как массив представляет собой набор элементов, объединенных общим именем, то обработка массива обычно производится в цикле.

Билет №21. Индексаторы классов

Индексаторы

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

Спецификаторы аналогичны спецификаторам свойств и методов. Индексаторы чаще всего объявляютсясоспецификатором public,посколькуонивходятвинтерфейс объекта.Атрибутыиспецификаторымогут отсутствовать.

Код доступа представляет собой блоки операторов, которые выполняются при получении (get) или установке (set) значения некоторого элемента класса. Может отсутствовать либо часть get, либо set, но не обе одновременно. Если отсутствуетчастьset,индексатордоступентолькодлячтения,еслиотсутствуетчастьget,индексатордоступентолькодлязаписи.

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

Билет №11. Массивы: многомерные и ступенчатые.

Многомерные массивы

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

Объявить двумерный массив можно одним из предложенных способов:

тип [,] имя__массива;

тип [,] имя__массива = new тип [размер1, размер2];

тип [,] имя__массива={{элементы 1-ой строки}, … , {элементы n-ой строки}};

тип [,] имя__массива= new тип [,]{{элементы 1-ой строки}, … ,{элементы n-ой строки}}; строки}};

Ступенчатые массивы

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

Объявление ступенчатого массива:

тип [][] имя_массива;

Например: int [][]a;

Фактически мы объявили одномерный массив ссылок на целочисленные одномерные массивы. При таком описании потребуется не только выделять память под одномерный массив ссылок, но и под каждый из целочисленных одномерных массивов. Такое распределение памяти позволяет определять произвольную длину каждой строки массива (отсюда и произошло название массива – ступенчатый). Например:

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

int [][] a= {new int [2], new int [3], new int [10]};

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

Билет №12. Символьный тип char, неизменяемы строки string и изменяемые строки StringBuider. Символы и строки

Обработка текстовой информации является одной из самых распространенных задач современного программировании. С# предоставляет для ее решения широкий набор средств: символы char, неизменяемые строки string, изменяемые строки StringBuider и регулярные выражения Regex.

Символы char

Символьный тип char предназначен для хранения символа в кодировке Unicode. Символьный тип относится к встроенным типам данных С# и соответствует стандартному классу Сhar библиотеки .Net из пространства имен

System

Неизменяемые строки string

Тип string, предназначенный для работы со стоками символов в кодировке Unicode, является встроенным типом С#. Ему соответствует базовый тип класса System.String библиотеки .Net. Каждый объект string - это неизменяемая последовательность символов Unicode, т.е. методы, предназначенные для изменения строк, возвращают измененные копии, исходные же строки остаются неизменными.

Создать строку можно несколькими способами:

5)int x = 12344556;

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

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

Изменяемые строки

Чтобы создать строку, которую можно изменять, в С# предусмотрен класс StringBuilder, определенный в пространстве имен System.Text. Объекты этого класса всегда объявляются с явным вызовом конструктора класса (через операцию new) . Примеры создания изменяемых строк:

StringBuilder a =new StringBuilder(); //создание пустой строки, размер по умолчанию 16 символов //инициализация строки и выделение необходимой памяти

StringBuilder b = new StringBuilder("abcd");

//создание пустой строки и выделение памяти под 100 символов

StringBuilder с = new StringBuilder(100);

//инициализация строки и выделение памяти под 100 символов

StringBuilder d = new StringBuilder("abcd", 100);

//инициализация подстрокой "bcd", и выделение памяти под 100 символов

StringBuilder d = new StringBuilder("abcd", 1, 3,100);

Билет №13. Методы: основные понятия. Перегрузка методов.

Методы: основные понятия

Метод – это функциональный элемент класса, который реализует вычисления или другие действия, выполняемые классом или его экземпляром (объектом). Метод представляет собой законченный фрагмент кода, к которому можно обратиться по имени. Он описывается один раз, а вызываться может многократно. Совокупность методов класса определяет, что конкретно может делать класс. Например, стандартный класс Math содержит методы, которые позволяют вычислять значения математический функций.

Синтаксис метода:

[атрибуты] [спецификторы] тип_возвращаемого_результаты имя_метода ([список_параметров])

{

тело_метода; return значение

}

где:

1)Атрибуты и спецификторы являются необязательными элементами синтаксиса описания метода. На данном этапе атрибуты нами использоваться не будут, а из всех спецификаторов мы в обязательном порядке будем использовать спецификатор static, который позволит обращатся к методу класса без создания его экземпляра

2)Тип_возвращаемого_результата определяет тип значения, возвращаемого методом. Это может быть любой тип, включая типы классов, создаваемые программистом. Если метод не возвращает никакого значения, необходимо указать тип void (в этом случае в теле метода отсутсвует оператор return).

3)Имя_метода – идентификатор, заданный программистом с учетом требований накладываемыми на идентификаторы в С#, отличный от тех, которые уже использованы для других элементов программы в пределах текущей области видимости.

4)Список_параметров представляет собой последовательность пар, состоящих из типа данных и идентификатора, разделенных запятыми. Параметры — это переменные или константы, которые получают значения, передаваемые методу при вызове. Если метод не имеет параметров, то список_параметров остается пустым.

5)Значение определяет значение, возвращаемое методом. Тип значения должен соответствовать

типу_возвращаемого_результата или приводится к нему.

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

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

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

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

Перегрузкаметодов

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

Перегрузка методов является проявлением полиморфизма, одного из основных свойств ООП. Программистугораздоудобнеепомнить одноимяметода ииспользовать егодля работыс различнымитипамиданных,а решениео том, какой вариант метода вызвать, возложить на компилятор. Этот принцип широко используется в классах библиотеки .NET. Например,встандартномклассеConsoleметодWriteLineперегружен19 раздлявывода величинразныхтипов.

Билет №16. Работа с файловой системой: классы Directory и Fi1е и классы DirectoryInfo и FileInfo.

Работа с файловой системой

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

Первые два типа — Directory и Fi1е реализуют свои возможности с помощью статических методов, поэтому данные классы можно использовать без создания соответствующих объектов (экземпляров классов).

Следующие типы – DirectoryInfo и FileInfo обладают схожими функциональными возможностями c Directory и Fi1е, но порождены от класса FileSystemInfo и поэтому реализуются путем создания соответствующих экземпляров классов.

Работа с каталогами

Абстрактный класс FileSystemInfo

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

В FileSystemInfo предусмотрено и несколько методов. Например, метод Delete() - позволяет удалить объект файловой системы с жесткого диска, a Refresh() — обновить информацию об объекте файловой системы

Класс DirectoryInfo

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

Работа с типом DirectoryInfo начинается с того, что мы создаем экземпляр класса (объект), указывая при вызове конструктора в качестве параметра путь к нужному каталогу. Если мы хотим обратиться к текущему каталогу (то есть каталогу, в котором в настоящее время производится выполнение приложения), вместо параметра используется обозначение ".".

Класс Directory

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

Работа с файлами

Класс Filelnfo

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

Как мы видим, большинство методов FileInfo возвращает объекты (FIleStream, StreamWriter, StreamReader и т. п.),

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

Класс File

Доступ к физическим файлам можно получать и через статические методы класса File. Большинство методов объекта Fileinfo представляют в этом смысле зеркальное отражение методов объекта File.

Билет №14. Обработка исключений: операторы try, checked и unchecked. Генерация собственных исключений.

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

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

Даже если программист исправил все свои ошибки в программе, предвидел все ошибочные ситуации, он все равно может столкнуться с непредсказуемыми и неотвратимыми проблемами -

исключительными ситуациями.

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

Оператор try

В С# исключения представляются классами. Все классы исключений порождены от встроенного класса исключений Exception, который определен в пространстве имен System.

Управление обработкой исключений основывается на использовании оператора try.

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

catch //один или несколько блоков обработки исключений

}

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

Операторы checked и unchecked

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

Для управления подобными исключениями в С# используются операторы checked и unchecked. Чтобы указать, что некоторое выражение должно быть проконтролировано на предмет переполнения, используйте ключевое слово checked. А чтобы проигнорировать переполнение, используйте ключевое слово unchecked. В последнем случае результат будет усечен так, чтобы его тип соответствовал типу-результату выражения.

Оператор checked имеет две формы:

1)проверяет конкретное выражение и называется операторной checked-формой

{

// Инструкции, подлежащие проверке.

}

Оператор unchecked также имеет две формы:

1) операторная форма, которая позволяет игнорировать переполнение для заданного выражения unchecked ((тип-выражения) expr)

где ехрr — выражение, которое не проверяется на предмет переполнения. В случае переполнения это выражение усекается.

2) игнорирует переполнение, которое возможно в блоке инструкций unchecked

{

// Инструкции, для которых переполнение игнорируется.

}

Генерация собственных исключений

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

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

Билет №15. Организация С#-системы ввода-вывода: стандартные, байтовые, символьные и двоичные потоки данных

Организация С#-системы ввода-вывода С#-программы выполняют операции ввода-вывода посредством потоков, которые построены на иерархии

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

1)FileAccess.Read – только чтение;

2)FileAccess.Write – только запись;

3)FileAccess.ReadWrite - и чтение, и запись.

После установления связи байтового потока с физическим файлом внутренний указатель потока устанавливается на начальный байт файла.

Для чтения очередного байта из потока, связанного с физическим файлом, используется метод ReadByte(). После прочтения очередного байта внутренний указатель перемещается на следующий байт файла. Если достинут конец файла, то метод ReadByte() возвращает значение -1.

Для побайтовой записи данных в поток используется метод WriteByte().

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

Символьный поток

Чтобы создать символьный поток нужно поместить объект класса Stream (например, FileStream) «внутрь» объекта класса StreamWriter или объекта класса StreamReader. В этом случае байтовый поток будет автоматически преобразовываться в символьный.

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

StreamWriter(Stream stream);

где параметр stream определяет имя уже открытого байтового потока.

Например, создать экземпляр класса StreamWriter можно следующим образом:

StreamWriter fileOut=new StreamWriter(new FileStream("text.txt", FileMode.Create, FileAccess.Write));

Другой вид конструктора позволяет открыть поток сразу через обращения к файлу:

StreamWriter(string name);

где параметр name определяет имя открываемого файла.

Например:

StreamWriter fileOut=new StreamWriter("t.txt", true);

Теперь для записи данных в поток fileOut можно обратиться к методу WriteLine. Это можно сделать следующим образом:

fileOut.WriteLine("test");

В данном случае в конец файла t.txt будет дописано слово test.

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

StreamReader(Stream stream);

где параметр stream определяет имя уже открытого байтового потока.

Этот конструктор генерирует исключение типа ArgumentException, если поток stream

не открыт для ввода.

Например, создать экземпляр класса StreamWriter можно следующим образом:

StreamReader fileIn = new StreamReader(new FileStream("text.txt", FileMode.Open, FileAccess.Read));

Как и в случае с классом StreamWriter у класса StreamReader есть и другой вид конструктора, который позволяет открыть файл напрямую:

StreamReader (string name);

где параметр name определяет имя открываемого файла.

Обратиться к данному конструктору можно следующим образом:

StreamReader fileIn=new StreamReader ("c:\temp\t.txt");

Двоичные потоки

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

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

Билет №19. Данные классов: поля и константы Данные: поля и константы

Данные, содержащиеся в классе, могут быть переменными или константами.

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

Для констант можно использовать только спецификаторы 1-6.

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

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

Билет №17. Технология объектно-ориентированного программирования

Технология объектно-ориентированного программирования В основе языка С# лежит технология объектно-ориентированного

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

ООП основано на таких понятиях как «класс», «объект», «интерфейс», «инкапсуляция», «наследование», «полиморфизм», «событие».

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

Класс – это множество объектов с одинаковыми атрибутами и поведением, представляемое в языке программирования в виде абстрактного типа данных, который включает в себя члены класса. Рассмотрим некоторые из них:

поля – непосредственно данные определенного типа для описания атрибутов;

методы - функции, предназначенные для обработки внутренних данных объекта данного класса;

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

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

экземпляром класса.

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

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

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

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

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

Windows.

Билет №18. Классы. Основные понятия

Класс – это обобщенное понятие, определяющие характеристики и поведение некоторого множества объектов, называемых экземплярами класса. «Классический» класс содержит данные, определяющие свойства объектов класса, и методы, определяющие их поведение. Для Windows-приложений в класс добавляется третья составляющая – события, на которые может реагировать объект класса. Все классы библиотеки .Net, а также все классы, которые создает программист в среде .Net, имеют одного общего предка – класс object.

Все программы, рассмотренные ранее, состояли из одного класса с одним методом Main и несколькими вспомогательными статическими методами. Теперь рассмотрим понятие «класс» более подробно.

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

[ атрибуты ] [ спецификаторы ] class имя_класса [ : предки ] {тело_класса} Простейший пример класса:

class Demo{}

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

Спецификаторы 2-6 называются спецификаторами доступа. Они определяют, откуда можно непосредственно обращаться к данному классу. Спецификаторы доступа могут комбинироваться с остальными спецификаторами.

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

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

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

1.Данные: переменные или константы.

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

3.Конструкторы (реализуют действия поинициализацииэкземпляровиликлассавцелом).

4.Свойства (определяют характеристики класса всоответствиисо способамиихзадания и получения).

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

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

7.Операции (задают действия с объектами с помощью знаков операций).

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

9.Типы (типы данных, внутренние по отношению к классу).

Билет №23. Иерархия классов. Наследование. Наследование конструкторов.

Иерархия классов

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

Наследование применяется для следующих взаимосвязанных целей:

5)исключения из программы повторяющихся фрагментов кода;

6)упрощения модификации программы;

7)упрощения создания новых программ на основе существующих.

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

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

Класс в С# может иметь произвольное количество потомков и только одного предка. При описании класса имя его предка записывается в заголовке класса после двоеточия. Если имя предка не указано, предком считается базовый класс всей иерархии System.Object. Синтаксис наследования:

[атрибуты] [спецификаторы] class имя_класса [: предки] { тело_класса}

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

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

Наследование конструкторов

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

Если же конструкторы определены и в базовом, и в производном классе, то процесс создания объектов несколько усложняется, т.к. должны выполниться конструкторы обоих классов. В этом случае используется ключевое слово base, которое имеет два назначения:

1) позволяет вызвать конструктор базового класса:

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

конструктор_производного_класса (список_параметров) : base (список_аргументов) { тело конструктора }

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

2)позволяет получить доступ к члену базового класса, который скрыт "за" членом производного класса.

Вэтом случае ключевое слово base действует подобно ссылке this, за исключением

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

base.член_класса

Здесь в качестве элемента член_класса можно указывать либо метод, либо поле экземпляра. Эта форма ссылки base наиболее применима в тех случаях, когда имя члена в производном классе скрывает член с таким же именем в базовом классе.

Билет №26. Интерфейсы.

Интерфейсы

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

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

Синтаксис интерфейса:

[атрибуты] [спецификаторы] interface имя_интерфейса : [предки]

{

//объявление функциональных членов интерфейса без реализации

…

}

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

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

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

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

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

Операции класса описываются с помощью методов специальноговида,синтаксис которых выглядит

следующим образом:

true иfalse.Приэтом,если была перегруженаконстанта true,тодолжна бытьперегруженаиконстантаfalse, и наоборот. Синтаксисобъявителя унарнойоперации:

типoperatorунарная_операция(параметр)

Примерызаголовков унарных операций: publicstaticintoperator +(DemoArraym)

publicstatic DemoArrayoperator--(DemoArraym) publicstatic booloperator true(DemoArraym)

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

Бинарные операции

При разработкекласса можноперегрузить следующиебинарныеоперации: + - * / % & | ^ << >> == != < > <= >=.Обратитевнимание,операцийприсваиваниявэтомспискенет.

Синтаксисобъявителя бинарнойоперации: типoperatorбинарная_операция(параметр1,параметр2)

Примерызаголовков бинарныхопераций: publicstatic DemoArrayoperator +(DemoArraya,DemoArrayb)

publicstatic booloperator ==(DemoArraya,DemoArrayb)

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

Билет №24. Переменные базового класса и производного класса. Виртуальные методы.

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

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

class DemoPoint

{

public int x; public int y; public void Show()

{

Console.WriteLine("точка на плоскости: ({0}, {1})",x, y);

Console.WriteLine("точка в пространстве: ({0}, {1}, {2})", x, y, z);

}

public DemoShape(int x, int y, int z):base(x, y)

{

this.z=z;

}

}

class Program

{

static void Main()

{

DemoPoint point1 = new DemoPoint(0,1); Console.WriteLine("({0}, {1})",point1.x,point1.y); DemoShape pointShape = new DemoShape(2,3,4);

Console.WriteLine("({0}, {1}, {2})",pointShape.x, pointShape.y, pointShape.z); DemoPoint point2=pointShape; //допустимая операция

//ошибка - не соответствие типов указателей

//pointShape=point1;

Console.WriteLine("({0}, {1})", point2.x, point2.y);

//ошибка, т.к. в классе DemoPoint нет поля z

//Console.WriteLine("({0}, {1}, {2})", point2.x, point2.y, point2.z);

}

}

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

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

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

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

Билет № 25. Абстрактные методы и классы

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

или целые абстрактные классы.

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

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

Demo a = new Demo();

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

Demo [] Ob=new Demo[5];

Если производный класс наследует абстрактный, то он должен полностью переопределить все абстрактные методы базового класса или также быть объявлен как абстрактный. Таким образом, спецификатор abstract наследуется до тех пор, пока в производном классе не будут реализованы все абстрактные методы.

Билет №27. Стандартные интерфейсы .Net.

Стандартные интерфейсы .Net

В библиотеке классов .Net определено множество стандартных интерфейсов, задающих желаемую функциональность объектов. Например, интерфейс IComparable задает метод сравнения объектов по принципу больше и меньше, что позволяет переопределить соответствующие операции в рамках класса, наследующего интерфейс IComparable. Реализация интерфейсов IEnumerable и IEnumerator дает возможность просматривать содержимое объекта с помощью оператора foreach.

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

Более подробно рассмотрим стандартный интерфейс IComparable.

Интерфейс IComparable определен в пространстве имен System и содержит единственный метод CompareTo, возвращающий результат сравнения двух объектов – текущего и переданного ему в качестве параметра:

interface IComparable

{

int CompareTo(object obj);

}

Реализация данного метода должна возвращать:

1)0 – если текущий объект и параметр равны;

2)отрицательное число, если текущий объект меньше параметра;

3)положительное число, если текущий объект больше параметра.

Используя собственную реализацию метода CompareTo можно перегрузить операции отношения. Напомним, что операции отношения должны перегружаться парами: < и >, <= и >=, == и !=.

Билет №28. Структуры.

Структуры

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

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

[атрибуты][спецификаторы] struct имя_структуры [: интерфейсы]

{

тело_структуры

}

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

Интерфейсы, реализуемые структурой, перечисляются через запятую.

Тело структуры может содержать: константы, поля, конструкторы, методы, свойства, индексаторы, операторные методы, вложенные типы и события.

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

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

Так как структуры не могут участвовать в иерархии, то для ее членов недопустимо использовать спецификаторы protected и protected internal. Методы структур не могут быть абстрактными и виртуальными. А переопределяться могут только те методы, которые унаследованы от базового класса object.

Экземпляр структуры, как и экземпляр класса, создаются с помощью оператора new, но это не обязательно. Если оператор new не используется, то структура все равно создается, но не инициализируется. Если при объявлении структуры не был вызван конструктор, то поля нужно инициализировать вручную:

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

Билет №29. Классификация ИС.

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

По степени распределённости:

•настольные (desktop), или локальные ИС, в которых все компоненты (БД, СУБД, клиентские приложения) находятся на одном компьютере;

•распределённые (distributed) ИС, в которых компоненты распределены по нескольким компьютерам.

Распределённые ИС разделяют на:

•файл-серверные ИС (ИС с архитектурой «файл-сервер»). В файл-серверных ИС база данных находится на файловом сервере, а СУБД и клиентские приложения находятся на рабочих станциях.

•клиент-серверные ИС (ИС с архитектурой «клиент-сервер»). В клиент-серверных ИС

база данных и СУБД находятся на сервере, а на рабочих станциях находятся клиентские приложения.

Клиент-серверные ИС разделяют на:

•В двухзвенных (англ. two-tier) ИС всего два типа «звеньев»: сервер баз данных, на котором находятся БД и СУБД,и рабочие станции, на которых находятся клиентские приложения. Клиентские приложения обращаются к СУБД напрямую.

•В многозвенных (англ. multi-tier) ИС добавляются промежуточные «звенья»: серверы приложений (application servers). Пользовательские клиентские приложения не обращаются к СУБД напрямую, они взаимодействуют с промежуточными звеньями. Типичный пример применения многозвенности — современные веб-приложения, использующие базы данных. В таких приложениях помимо звена СУБД и клиентского звена, выполняющегося в веб-браузере, имеется как минимум одно промежуточное

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

•автоматизированные: информационные системы, в которых автоматизация может быть неполной (то есть требуется постоянное вмешательство персонала);

•автоматические: информационные системы, в которых автоматизация является полной, то есть вмешательство персонала не требуется или требуется только

эпизодически. Классификация по охвату задач (масштабности)

•Персональная ИС предназначена для решения некоторого круга задач одного человека.

•Групповая ИС ориентирована на коллективное использование информации членами рабочей группы или подразделения.

•Корпоративная ИС в идеале охватывает все информационные процессы целого предприятия, достигая их полной согласованности, безызбыточности и прозрачности.

Такие системы иногда называют системами комплексной автоматизации

предприятия.

Классификация по характеру обработки данных

•информационно-справочные, или информационно-поисковые ИС, в которых нет сложных алгоритмов обработки данных, а целью системы является поиск и выдача информации в удобном виде;

•ИС обработки данных, или решающие ИС, в которых данные подвергаются обработке

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

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

ознакомления с объектом и выработкой концептуального (чернового) проекта АИС; второй — полное обследование производства после заключения договора и подписания технического задания (ТЗ может быть заменено специфицированным описанием будущей компьютерной системы). Работы ведутся квалифицированным персоналом, в зависимости от количества специалистов, размеров предприятия и создаваемой системы, в среднем, могут выполняться в сроки от 6 месяцев до 1 года. Так как данный этап является длительным разработку желательно вести параллельно.

На основе собранного материала можно создать пакет черновой АИС, подобрать прототип или купить макет, можно использовать готовые разработки. Часто выбирается вариант разработки комплексов задач. На данном этапе необходимо выяснить:

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

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

Этап обработки результатов обследования Цель данного этапа получить комплексное представление о предприятии, объекте, получить формальное

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

Главная задача систематизировать весь собранный материал и на его основании составить грубую схему АИС для исследуемого объекта.

Билет №31. Формирование технического задания (ТЗ). Этап составления общей схемы (проекта ИС). Реализация системы.

Формирование технического задания (ТЗ)

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

Техническое задание должно состоять из следующих разделов:

1.Наименование;

2.Основание для создания;

3.Назначение и цель;

4.Требования к АИС;

5.Состав, содержание, ограничение работ по подготовке объекта к вводу АИС в действие;

6.Показатели эффективности АИС;

7.Порядок контроля и приемки АИС;

8.Источники разработки.

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

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

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

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

Обычно ТЗ включает экономическое обоснование — это экономические затраты на создание системы, направление за счет которого будет получен экономический эффект и его расчет.

Билет №32. Содержание работ на этапах создания ИС. Организация предпроектного обследования. Организация работ на стадии технического проектирования.

Содержание работ на этапах создания АИС Основная цель рабочего проекта - это разработка технической, рабочей

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

Внедрение разработанной системы - это процесс постепенного перехода от существующей системы обработки данных к новой, автоматизированной.

Организация предпроектного обследования Предпроектная стадия включает комплекс научно-исследовательских

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

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

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

ТЗ – документ, завершающий предпроектную стадию создания АИС и

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

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

Организация работ на стадии технического проектирования

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

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

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

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

Билет №33. Организация работ на стадии рабочего проектирования. Организация работ на стадии внедрения системы.

Организация работ на стадии рабочего проектирования

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

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

Программная документация рабочего проекта включает:

Руководство программиста, содержащее описания

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

Руководство оператора, в составе которого можно

выделить описание его действий при запросах программы, правила организации программ на внешних носителях, тестирование.

Эксплуатационные программы, если используется ППП,

или тексты программ.

Контрольный пример, который включает описание

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

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

Организация работ на стадии внедрения системы

Внедрение разработанной системы - это процесс постепенного перехода от существующей системы обработки данных к новой, автоматизированной.

Ввод в эксплуатацию проводится силами заказчика при участии

разработчика и осуществляется поэтапно:

подготовка объекта к внедрению АИС

опытная эксплуатация отдельных задач или их комплексов

сдача системы в промышленную эксплуатацию.

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

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

Билет №34. Средства автоматизации проектирования ИС. Основные возможности СASЕ-средств.

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

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

Большинство современных case-средств поддерживает методологии структурного и объектно-ориентированного анализа и проектирования ИС.

Основные функции case-средств:

1.Единый графический язык. Case-технологии обеспечивают всех участников проекта, включая заказчика, единым, строгим наглядным и интуитивно понятным графическим языком, позволяющим получить обозримые компоненты простой и ясной структуры.

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

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

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

5.Генерация документации. Вся документация по проекту генерируется автоматически на базе репозитория.

6.Верификация проекта. Обеспечивает автоматическую верификацию и контроль проекта на полноту и состоятельность на ранних этапах разработки.

7.Автоматическая генерация программного кода.

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

Билет №35. Средства быстрой разработки приложений.

Быстрая разработка приложений (RADRapid Application Development) основывается на визуализации процесса создания программного кода. Технологии RAD представляют программисту средства ускоряющие разработку программ, их модификацию и оплату. Для максимального упрощения работы используются графические инструменты, основанные на компонентной архитектуре. Каждый компонент является объектом, объединяющих в себе данные, методы и свойства для работы с ними. При этом компоненты являются объектами, которые позволяют изменять данные и свойства объектов. Свойства позволяют работать с данными также как и с членами классов, а с другой стороны скрывают за операциями чтения и записи вызовы методов, переводя операции над объектами на более высокий уровень абстракции. Для разработки и проектирования пользовательского интерфейса используются инструменты визуального проектирования( экранный редактор…), которые позволяют выполнять следующие операции: размещение компонента интерфейса в нужном месте, задание моментов времени их появления на экране, настройка связанных с ними атрибутов и событий. Эффективность визуального программирования определено наличием визуальных компонентов и их взаимодействием с традиционными средствами.

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

Билет № 36. Разработка информационных систем на основе шаблонов. Шаблоны на этапе анализа, построения архитектуры решений, кода, шаблоны тестов.

Шаблон проектирования или паттерн (англ. design pattern) в разработке программного обеспечения — повторимая архитектурная конструкция, представляющая собой решение проблемы проектирования в рамках некоторого часто возникающего контекста.

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

Классификация паттернов

Архитектурные паттерны, являются наиболее высокоуровневыми паттернами, описывают структурную схему программной системы в целом. В данной схеме указываются отдельные функциональные составляющие системы, называемые подсистемами, а также взаимоотношения между ними. Архитектурные паттерны (Architectural patterns) - множество предварительно определенных подсистем со спецификацией их ответственности, правил и базовых принципов установления отношений между ними. Архитектурные паттерны предназначены для спецификации фундаментальных схем структуризации программных систем. Наиболее известными паттернами этой категории являются паттерны GRASP (General Responsibility Assignment Software Pattern). Эти паттерны относятся к уровню системы и подсистем, но не к уровню классов. Как правило, формулируются в обобщенной форме, используют обычную терминологию и не зависят от области приложения.

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

Паттерны проектирования описывают схемы детализации программных подсистем и отношений между ними, при этом они не влияют на структуру программной системы в целом и сохраняют независимость от реализации языка программирования. Паттерны GoF относятся именно к этой категории. Под паттернами проектирования объектноориентированных систем понимается описание взаимодействия объектов и классов, адаптированных для решения общей задачи проектирования в конкретном контексте. В русскоязычной литературе обычно встречаются несколько вариантов перевода оригинального названия design patterns - паттерны проектирования, шаблоны проектирования, образцы. Здесь в основном используется первый вариант, иногда второй. Наиболее известными паттернами этой категории являются паттерны GoF (Gang of Four), названные в честь Э. Гаммы, Р. Хелма, Р. Джонсона и Дж. Влиссидеса, которые систематизировали их и представили общее описание. Паттерны GoF включают в себя 23 паттерна. Эти паттерны не зависит от языка реализации, но их реализация зависит от области приложения.

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

Паттерны реализации (Implementation patterns) - совокупность компонентов и других элементов реализации, используемых в структуре модели при написании программного кода. Эта категория паттернов делится на следующие подкатегории: паттерны организации программного кода, паттерны оптимизации программного кода, паттерны устойчивости кода, паттерны разработки графического интерфейса пользователя и др. Паттерны этой категории описаны в работах М. Гранда, К. Бека, Дж. Тидвелла и др. Некоторые из них реализованы в популярных интегрированных средах программирования в форме шаблонов создаваемых проектов. В этом случае выбор шаблона программного приложения позволяет получить некоторую заготовку программного кода.

Паттерны анализа (Analysis patterns) - специальные схемы для представления общей организации процесса моделирования. Паттерны анализа относятся к одной или нескольким предметным областям и описываются в терминах предметной области. Наиболее известными паттернами этой группы являются паттерны бизнесмоделирования ARIS (Architecture of Integrated Information Systems), которые характеризуют абстрактный уровень представления бизнес-процессов. В дальнейшем паттерны анализа конкретизируются в типовых моделях с целью выполнения аналитических оценок или имитационного моделирования бизнес-процессов.

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

Билет №38. Современные технологии тестирования. Основные понятия тестирования. Фазы и этапы тестирования.

Тестирование является одним из наиболее устоявшихся способов обеспечения качества разработки программного обеспечения. С технической точки зрения тестирование заключается в выполнении приложения на некотором множестве исходных данных. Из сверке получаемых результатов с заранее известными (эталонными) с целью установить соответствие различных свойств и характеристик приложения заказанным свойствам. При разработки программ тестирование занимает 40 % от суммарной трудоемкости разработки продукта.

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

Динамическое тестирование (собственно тестирование) осуществляет выявление ошибок только на выполняющейся программе с помощью специальных инструментов автоматизации тестирования (– Testbed или

Testbench.)

Фазы тестирования:

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

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

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

вприменении и тому подобное. Системное тестирование производится над проектом

вцелом с помощью метода «черного ящика».

Этапы тестирования:

Каждая фаза тестирования включает в себя следующие этапы:

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

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

3.Разработка тестов (тестового кода для тестируемой системы)

4.Выполнение тестов: реализация тестовых циклов.

5.Анализ результатов.

Билет №39. Типы тестов. Разработка, управляемая тестами (Test Driven Development).

Типы тестов:

В тестовом плане определяются и документируются различные типы тестов. Типы тестирования по виду подсистемы или продукта:

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

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

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

работоспособность примеров и т.п. Типы тестирования по способу выбора входных значений:

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

TDD определяет следующий порядок этапов программирования:

•Красный – напишите небольшой тест, который не работает, а возможно, даже не компилируется.

•Зеленый – заставьте тест работать как можно быстрее, при этом не думайте о правильности дизайна и чистоте кода. Напишите ровно столько кода, чтобы тест сработал.

•Рефакторинг – удалите из написанного вами кода любое дублирование.

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