Разработка модуля для выполнения операций с натуральными числами в 16-ричной системе счисления (1 Выбор и проработка программных средств)

Содержание:

Введение

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

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

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

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

В вычислительной технике непозиционные системы не применяются.

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

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

где b – основание системы счисления; n – цифры в интервале от 0 до b-1.

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

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

Шестнадцатеричная система счисления (шестнадцатеричные числа) — позиционная система счисления по целочисленному основанию 16.

Обычно в качестве шестнадцатеричных цифр используются десятичные цифры от 0 до 9 и латинские буквы от A до F для обозначения цифр от 10 до 15, то есть (0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E, F). Широко используется в низкоуровневом программировании и компьютерной документации, поскольку в современных компьютерах минимальной единицей памяти является 8-битный байт, значения которого удобно записывать двумя шестнадцатеричными цифрами. Такое использование началось с системы IBM/360, где вся документация использовала шестнадцатеричную систему, в то время как в документации других компьютерных систем того времени (даже с 8-битными символами, как, например, PDP-11 или БЭСМ-6) использовали восьмеричную систему.

Глава 1. Выбор и проработка программных средств

Для разработки данного проекта был выбран достаточно молодой и прогрессивно развивающийся язык C#. В качестве среды проектирования использовался свободно-распространяемый проект Mono, как бесплатный аналог Microsoft Visual Studio и средство разработки с помощью платформы .NET на не- Windows платформах.

"Си шарп" (официально C#) является новым объектно-ориентированным языком программирования, разработанным для максимально удобного использования всех возможностей платформы Microsoft.NET. Во многом является схожим с другими популярными объектно-ориентированными языками, такими как C++ и Java, но имеет свои особенности. Благодаря появлению нового свободного проекта Mono, в Linux появилась возможность разрабатывать приложения на C#.

Mono — программная платформа, позволяющая разработчикам достаточно просто создавать развитые кроссплатформенные приложения. Технология Mono разрабатывается в виде open source реализации технологии .NET Framework от Microsoft и поддерживает стандарты ECMA-334 (стандарт языка C#) и ECMA-335 (стандарт среды исполнения Common Language Runtime, CLI). Открытость указанных стандартов позволяет уменьшить проблемы создания кроссплатформенных приложений.

В настоящее время в рамках этого проекта реализованы два стандарта: язык программирования C# (Стандарт ECMA-334) и "инфраструктура обобщенного языка программирования" (CLI) (Стандарт ECMA-335). Обе спецификации были разработаны в корпорации Microsoft и представлены ECMA (Европейской Ассоциации Производителей Компьютеров) в октябре 2000 г. Формальное одобрение было получено в декабре 2001 г., и эти предложения становятся стандартами ISO (благодаря соглашению, существующему между ISO и ECMA).

Проект Mono спонсируется компанией Ximian — той самой, которая предоставила миру графический рабочий стол GNOME. Лидером проекта является мексиканский программист, главный технический директор компании Ximian — Miguel de Icaza. Специалисты, привлеченные к разработке проекта Mono, в очень короткое время проделали огромный объем работ.

В базовом варианте Mono состоит из нескольких компонентов:

- компилятор языка C# — компилятор с полной поддержкой версий 1.0 и 2.0 языка C#. Кроме того в последних версиях поддерживаются практически все возможности версии C# 3.0, а начиная с версии Mono 2.6 включена поддержка возможностей версии C# 4.0 (пока только как опция, полноценная поддержка заявлена в версии 2.8);

- среда исполнения Mono — состоит из среды исполнения (CLI) непосредственно, компилятора среды исполнения (Just-In-Time, JIT), генератора машинного кода (Ahead-Of-Time, AOT), загрузчика сборок, сборщика мусора, подсистемы управления многопоточностью и компонентов поддержки взаимодействия между сборками и COM (или аналогами в Linux, например XCOM);

- базовая библиотека классов — набор стандартных классов, совместимых с классами Microsoft .NET Framework;

- библиотека классов Mono — набор классов, поддерживающих дополнительные функции для разработки Linux-приложений. Например, классы для поддержки Zip, OpenGL, Cairo, Gtk+.

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

Компилятор Mono C# поддерживает версии языков C# 1.0-4.0 (про совместимость с .NET 4.5 данных нет). Для создания кода можно использовать один из нескольких вариантов компилятора, в зависимости от потребностей:

- mcs — компилятор, поддерживающий версию 1.1 среды исполнения. Компилирует код на языке C# (без поддержки generic и всего, что с ним связано). Данный компилятор планируется исключить в версии Mono 2.8, как устаревший.

-gmcs — компилятор, поддерживающий версии от 2.0 до 3.5 среды исполнения и обладающий полной поддержкой C# 3.0.

- smcs — опциональный компилятор для создания Moonlight (аналог Microsoft Silverlight) приложений.

- dmcs — опциональный компилятор, реализованный в тестовом варианте в версии Mono 2.6 и планируемый к включению в версию 2.8. Поддерживает среду исполнения версии 4.0 и язык C# 4.0.

Рисунок 1.1 – Логическая модель работы C#-программы, написанной с использованием проекта Mono

Начиная с версии Mono 2.2 реализована поддержка классов компилятора Mono.CSharp.Evaluator (сборка Mono.Sharp.dll) для создания собственных сервисов компиляции.

Среда исполнения Mono поддерживает инфраструктуру промежуточного языка CLI (Common Language Infrastructure), соответствующую стандарту ECMA-335. Виртуальная машина среды исполнения допускает возможность запуска приложений и сборок, скомпилированных в других системах (например, возможно запускать в Linux без перекомпиляции приложения, созданные при помощи Microsoft Visual Studio для исполнения в Microsoft Windows).

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

В среде Mono реализован Ahead-Of-Time (AOT) компилятор промежуточного языка. Цель этого компилятора в том, чтобы уменьшить время запуска программы и оптимизировать ее код, путем компиляции промежуточного языка CLI в машинный код. Аналогом в Microsoft .NET Framework является утилита Ngen. Для запуска приложения в этом режиме можно воспользоваться опцией --aot среды исполнения (также можно включить полную оптимизацию кода при помощи опцее -O=all).

В качестве сборщика мусора в данный момент используется Boehm's GC, однако в текущей разрабатываемой ветке SVN присутствует совершенно новый сборщик мусора, разработанный специально для Mono.

Глава 2. Проект программы

Проект программы представлен в виде четырех основных классов: класс Program, являющийся классом по умолчанию, содержащем в себе точку входа приложения (static void Main(string[] args)), класса HEX, описывающего основную логику создания и взаимодействия шестнадцатеричных чисел, а также оставшиеся два класса в пространстве имен HEXNumbers.test для проведения тестов и проверки правильности разработанного приложения: Sorting и Involution.

Приведем данные о представленных классах и опишем их сигнатуру.

Program

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

HEX


Представление этого класса обозначено на рисунке 2.1.

Рисунок 2.1 – Класс HEX

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

Перегруженный метод ToString() возвращает строковый вариант текущего hex- значения.

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

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

- ConvertFromHEX – позволяет провести конвертацию из шестнадцатеричного представления в десятичное. Метод перегружен и может принимать в качестве аргумента строковую константу либо объект типа НЕХ. Метод возвращает значение типа int.

- ConvertFromDecimal – проводит конвертацию числа из десятичной системы счисления. Метод принимает в качестве аргумента объект типа int, а возвращаемое значение – HEX.

- «operator +», «operator –«, «operator *», «operator /» – статические операторы, проводящие арифметические операции. Все методы возвращают значение типа HEX, в качестве аргументов принимаются два аргумента того же типа.

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

Sorting

Статический класс, находящийся в пространстве имен HEXNumbers.test предназначен для решения задачи сортировки массива по убыванию. Единственный публичный метод Start начинает тестирование. Для более компактного и осмысленного прочтения кода весь процесс тестирования был разнесен на методы:

- creating – метод, добавляющий в динамический масив заданное параметром количество случайных шестнадцатеричных чисел;

- showArray и showArrayDec – методы, выводящие в консоль представление массива в шестнадцатеричном и десятичном соответственно представлении элементы массива, созданном ранее;

- sortList – производит сортировку массива с помощью указанного правила. Метод возвращает число типа int для вывода в консоль интервала времени в миллисекундах, затраченного на выполнение сортировки.

Involution

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

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

Структурная схема разработанного приложения представлена на рисунке 2.2.

Рисунок 2.2 – Структурная схема приложения HEXNumbers

Глава 3. Описание алгоритмов и текст программы

3.1 Создание и конвертация шестнадцатеричных чисел

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

public HEX(int decNumber)


{ _number = decNumber; }

public HEX(string hexNumber)

: this(ConvertFromHEX(hexNumber))

{}

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

public static int ConvertFromHEX(string hex)

{

ThrowExceprtionIfNotValidHEX(hex);

return int.Parse(hex, NumberStyles.HexNumber);

}

В этом случае производится проверка на правильность указания шестнадцатеричного числа в строке с помощю метода ThrowExceprtionIfNotV alidHEX.

static void ThrowExceprtionIfNotValidHEX(string hex)

{

if (!CorrectHEXNumber(hex)) throw new ApplicationException();

}

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

public static bool CorrectHEXNumber(string hex)


{

return HEXExpression.Match(hex).Value == hex;

}

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

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

static Regex HEXExpression;


HEXExpression = new Regex("[0-9a-fA-F]+");

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

Открытый рефлектором метод Parse выглядит следующим образом.

public static int Parse(string s, NumberStyles style)

{

NumberFormatInfo.V alidateParseStyleInteger(style);

return Number.ParseInt32(s, style, NumberFormatInfo.CurrentInfo);

}

internal static unsafe int ParseInt32(string s, NumberStyles style, NumberFormatInfo info)

{

byte* stackBuffer = stackalloc byte[114];


Number.NumberBuffer number = new Number.NumberBuffer(stackBuffer);

int num = 0;
Number.StringToNumber(s, style, ref number, info, false);


if ((style & NumberStyles.AllowHexSpecifier) != NumberStyles.None)


{

if (!Number.HexNumberToInt32(ref number, ref num))
throw new OverflowException (Environment.GetResourceString ("Overflow_Int32"));

}
else if (!Number.NumberToInt32(ref number, ref num))

throw newOverflowException(Environment.GetResourceString("Overflow_Int32"));

return num;

}

Метод ConvertFromHEX перегружен и может иметь следующее представление.

public static int ConvertFromHEX(HEX hex)

{

return ConvertFromHEX(hex.ToString());

}

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

public static HEX ConvertFromDecimal(int dec)

{

return new HEX(dec.ToString("X"));

}

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

public string ToString(string format)

{

return Number.FormatInt32(this, format, NumberFormatInfo.CurrentInfo);

}

3.2 Арифметические операции HEX

По условию задания класс должен обеспечивать следующие математические операции над HEX-числами:

- сложение;

- вычитание;

- умножение;

- деление.

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

Представим код разработанных операторов.

public static HEX operator +(HEX h1, HEX h2)

{ return new HEX(h1._number + h2._number); }

public static HEX operator -(HEX h1, HEX h2)

{ return new HEX(h1._number - h2._number); }

public static HEX operator *(HEX h1, HEX h2)

{ return new HEX(h1._number * h2._number); }

public static HEX operator /(HEX h1, HEX h2)

{ return new HEX(h1._number / h2._number); }

Так как операторы принадлежит тому типу данных, над которым происходят операции, у методов есть доступ к скрытым данным, в данном случае это член _number.

3.3 Сортировка чисел

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

public static void Start(int count)

{

Console.WriteLine(string.Format("создание массива из {0} случайных HEX-чисел:", count));

creating(count);


showArray();


Console.Write("\nсортировка массива...");

Console.WriteLine(string.Format("{0} ms", sortList())); Console.WriteLine("\nрезультат в шестнадцатиричном представлении:"); showArray();
Console.WriteLine("\nрезультат в десятичном представлении:"); showArrayDec();
Console.WriteLine("\nнажмите любую клавишу для завершения..."); Console.ReadKey();

}

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

Все действия класса оповещаются соответствующими подсказками в консоли. Первым этапом является создание массива в коде creating.

static List<HEX> _array; static void creating(int count) {

_array.Clear();
for (int i = 0; i < count; i++)

_array.Add(new HEX(_random.Next(byte.MaxValue))); }

Сам массив представляет собой динамическую коллекцию объектов типа HEX. Особенностью такого выбора явился широкий спектр возможностей данного типа коллекций. В частности, размер коллекции не является фиксированным, что удобно при создании массивов, истинное число членов которого не может быть неизвестно заранее, или блоки данных могут добавляться в несколько заходов. Также интерфейсы IList и IList<T> позволяют конвертировать коллекцию в массив типа T[], производить сортировку по заданному алгоритму, динамически добавлять и удалять данные, производить поиск по определенному выражению и так далее.

Метод showArray выводит данные массива на консоль. Также присутствует похожий метод showArrayDec, который выводит данные этого же массива, но в десятичном представлении. Код этих методов представлен ниже.

static void showArray()

{

foreach (HEX h in _array) Console.Write(string.Format("{0}, ", h.ToString()));

Console.WriteLine();

}

static void showArrayDec()

{

foreach (HEX h in _array)
Console.Write(string.Format("{0}, ", HEX.ConvertFromHEX(h.ToString())));

Console.WriteLine();

}

Оба метода используют для вывода форматированную строку, которая создается методом string.Format. Использование этого метода позволяет создавать новый объект строчного типа в одну строку без создания «временных» строковых констант и конкатенаций строк. Такой способ, как известно, существенно экономит ресурсы управляемой кучи .NET. Для перебора всех значений массива используется итератор foreach, который поддерживается типом данных List<T>.

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

static long sortList()

{

long time = DateTime.Now.Ticks;

_array.Sort((h1, h2) =>


{

int _h1 = HEX.ConvertFromHEX(h1.ToString()),

_h2 = HEX.ConvertFromHEX(h2.ToString());

return _h1 == _h2 ? 0 : _h1 > _h2 ? -1 : 1;

});

return (DateTime.Now.Ticks - time) / 10000;

}

Сортировка массива производится по заданному в параметрах метода Sort делегата возвращаемому значению. Начиная с версии .NET Framework 3.5 пользователю предоставляется возможность оперировать лямбда-выражениями, которые во многих случаях заменяют многострочные операции создания и инициализацию предикатов и делегатов.

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

Для упрощения записи использовался тринарный оператор ?:, который заменяет присваивание данных в конструкции if-else.

Блок-схема алгоритма сортировки объектов класса HEX представлена на рисунке 3.1.

Рисунок 3.1 – Блок-схема алгоритма сортировки объектов HEX

3.4 Возведение в степень

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

public static void Start()

{

creatingNumbers();

Console.WriteLine(string.Format("число '{0}' будет возведено в степень '{1}'", _number, _power));

Console.WriteLine(string.Format("результат в шестнадцатеричном представлении: {0}", _result

new HEX((int)Math.Pow(HEX.ConvertFromHEX(_number.ToString()), HEX.ConvertFromHEX(_power.ToString())))));

Console.WriteLine(string.Format("результат в десятичном представлении: {0}", HEX.ConvertFromHEX(_result.ToString())));

Console.WriteLine(string.Format("нажмите любую клавишу для завершения...{0}", Console.ReadKey()));

}

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

Для начала пользователю предлагается ввести необходимые число и показатель степени с консоли. Следующим этапом является проверка правильности введенного шестнадцатеричного числа методом HEX.CorrectHEXNumber. Если обе проверки прошли успешно, инициализируются соответствующие HEX-члены класса, которые далее, в методе Start, участвуют в вычислениях.

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

static HEX _number, _power, _result; static void creatingNumbers()


{

string number, power; do


{

Console.Clear();
Console.Write("введите число, возводимое в степень в HEX-представлении: ");

number = Console.ReadLine();


Console.Write("введите степень в HEX-представлении: ");


power = Console.ReadLine();

}
while (!(HEX.CorrectHEXNumber(number) && HEX.CorrectHEXNumber(power)));

_number = new HEX(number);

_power = new HEX(power);

}

Блок-схема алгоритма возведения числа в степень представлена на рисунке 3.2.

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

Рисунок 3.2 – Блок-схема алгоритма возведения числа в степень

Глава 4. Тестирование и анализ результатов работы программы

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

Рисунок 4.1 – Сортировка массива

Как видно на рисунке, данные отсортированы по убыванию от 253 до 1, а на процесс сортировки ушло 20 миллисекунд.

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

В качестве теста введем неверные данные (“az” и “-15”). Так как программа не приняла один из ответов (а в нашем случае оба) правильными, данные не записываются, и предлагается повторить попытку еще раз.

Введем для числа, возводимого в степень значение 10, что соответствует шестнадцатеричному представлению «А», а для показателя степени – 4, в hex-виде значение будет таким же.

Приложение оповестило, что число «А» будет возведено в степень «4» и представила результаты – в десятичном представлении это 10000, в представлении hex – 2710.

Рисунок 4.2 – Ввод неверных данных в окно тестирования

Рисунок 4.3 – Возведение А в степень 4

В качестве проверки на правильность расчетов воспользуемся стандартным Windows-калькулятором, в котором есть возможность конвертировать текущее число в различные системы счисления. 10000 в представлении hex отображена на рисунке 4.4.

Рисунок 4.4 – Проверка правильности расчетов стандартными средствами

Заключение

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

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

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

Для разработки проекта использовался платформа .NET и поддерживаемый ею язык программирования C#. В качестве IDE использовался open-source проект Mono.

Список использованной литературы

1. Троелсен Э. Язык программирования C# 2010 и платформа .NET 4.0, 5-е изд.: Пер. с англ. – М.: ООО «И.Д.Вильямс», 2011. – 1392 с.: ил. – Парал. тит. англ.

2. Ватсон К. C#. – М.: Издательство «Лори», 2001. – 879 с.: ил.

3. Шилдт Г. Полный справочник по C#.: Пер. с англ. – М.: Издательский дом «Вильямс», 2004. – 752 с.: ил. – Парал. тит. англ.

4. Фаулер М. Рефакторинг: улучшение существующего кода. – Пер. с англ. – СПб.: Символ-Плюс, 2003. – 432 с.: ил.