Компьютерные технологии (программирование на C#)

Следующий условный оператор в методе IntegrateTo

if ( Double.IsNaN (stepSize) )

проверяет, имеет ли текущий шаг интегрирования stepSize осмысленное значение. Значение NaN поля stepSize означает, что шаг еще не определен. Тогда вызывается метод StartStepSize

stepSize = StartStepSize (Math.Abs (tEnd - currt));

Он вычисляет оптимальный начальный шаг интегрирования. Параметром метода StartStepSize является максимальный шаг - длина всего интервала интегрирования от начальной точки currt до конечной tEnd.

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

if ( Double.IsNaN (stepSize) || Double.IsInfinity (stepSize) )

{

throw (new ApplicationException

("\nОшибка при вычислении начального шага интегрирования!"));

}

Здесь метод IsInfinity класса Double проверяет, имеет ли аргумент (шаг stepSize) бесконечное значение.

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

protected internal abstract bool BasicLoop (double tEnd);

Это последний член класса TIntegrator. На этом описание класса TIntegrator завершается. Можете посмотреть весь текст модуля с описанием класса TIntegrator. Обратите внимание на структуру комментариев и операторы, из которых состоят тела не рассмотренных методов FirstEstimate, SecondEstimate и StartStepSize. В теле этих методов встречаются обращение к стандартным математическим функциям, сосредоточенным в классе Math библиотеки .NET. Это такие функции, как абсолютное значение Abs, квадратный корень Sqrt, степень числа Pow, минимальное Min и максимальное Max из двух чисел. Алгоритм вычисления начального оптимального шага взят из работы E. Hairer, S.P. Norsett and G. Wanner, Solving ordinary differential equations I, nonstiff problems, 2nd edition, Springer Series in Computational Mathematics, Springer-Verlag (1993).

http://scitation.aip.org/getabs/servlet/GetabsServlet?prog=normal&id=SIREAD000032000003000485000001&idtype=cvips&gifs=yes.

Класс RK4

В качестве следующего примера рассмотри класс интегратора, построенный на основе алгоритма Рунге-Кутта 4-ого порядка и позволяющий создавать объекты. Назовем новый класс RK4. Наследуем RK4 от абстрактного класса TIntegrator.

В начале приведем общий список членов класса RK4 с комментариями

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

public class RK4 : TIntegrator

{

/*Класс RK4 добавляет новые поля, описанные без модификатора доступа и, следовательно, имеющие доступ private - только для членов класса RK4. Это одно поле lowestAcc типа double и пять рабочих массивов tempY, tempLocalVector, oneStepLocalVector, firstHalfStepLocalVector, secondHalfStepLocalVector, элементами которых являются также объекты типа double.

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

double lowestAcc;

double [ ] tempY, tempLocalVector, oneStepLocalVector,

firstHalfStepLocalVector, secondHalfStepLocalVector;

/*Ниже описано виртуальное свойство погрешности Tolerance. В описании свойства Tolerance присутствует модификатор доступа override. Этим указывается, что виртуальное свойство Tolerance перекрыто в классе RK4. Внутри методов set и get свойства Tolerance есть оператор, вызывающий методы set и get предка. Это base.Tolerance. Как видно метод get свойства Tolerance просто вызывает метод get предка. В перекрытом методе set проводится дополнительная установка значения пороговой погрешности lowestAcc. */

public override double Tolerance

{

get { return base.Tolerance; }

set

{

base.Tolerance = value;

// Пороговая погрешность

lowestAcc = 0.025 * tolerance;

}

}

/*Дальше описывается метод Initialize, который так же перекрывает виртуальный метод Initialize класса TIntegrator. Код метода Initialize рассмотрим несколько ниже.*/

protected internal override void Initialize ()

{

//…

}

/*Конструкторы класса-предка должны быть обязательно перекрыты в наследниках, даже, если они не вносят никакого дополнительного кода. Это правило языка. Обратите внимание, что конструкторы класса RK4 описаны с модификатором public. Класс RK4 не является абстрактным - он не содержит не реализованных свойств и методов. Поэтому его конструкторы должны быть доступны.

В описании конструкторов RK4 следует обратить внимание на операторы вида base (N, Equations), отделенные двоеточием от имени конструктора. Это вызов конструкторов предка. Тела новых конструкторов RK4 в данном случае пусты, но фигурные скобки писать необходимо. */

public RK4 (ushort N, TEquations Equations) : base (N, Equations) { }

public RK4 (ushort N, TEquations Equations,

CallBackEventHandler CallBack)

: base (N, Equations, CallBack) { }

/*Класс вводит новый метод DoStep, который реализует формулу Рунге-Кутта 4-ого порядка. Тело метода DoStep будет прокомментировано ниже. Здесь лишь отметим, что этот метод доступен только классам-наследникам из той же библиотеки (модификатор доступа protected internal) и он является виртуальным.*/

protected internal virtual void DoStep (double tStart, double currStep,

double [ ] yStart, double [ ] yEnd)

{

// Метод Рунге-Кутта 4-ого порядка

}

// Класс реализует метод BasicLoop, содержащий цикл интегрирования.

protected internal override bool BasicLoop (double tEnd)

{

//…

}

}

Метод Initialize, реализованный классом RK4, добавляет к унаследованной версии инициализацию рабочих массивов-полей.

protected internal override void Initialize ()

{

base.Initialize ();

try

{

oneStepLocalVector = new double [n];

firstHalfStepLocalVector = new double [n];

secondHalfStepLocalVector = new double [n];

tempY = new double [n];

tempLocalVector = new double [n];

}

catch ( Exception e )

{

throw (new ApplicationException

(e.Message + "\nПрерывание в методе Initialize."));

}

}

Первый оператор метода base.Initialize (); вызывает унаследованную версию метода Initialize. Обратите внимание на блоки try и catch, предназначенные для обнаружения и обработки исключительной ситуации в том случае, если рабочие массивы займут слишком много памяти.

Метод DoStep реализует формулу Рунге-Кутта 4-ого порядка (см. Г. Корн, Т. Корн, Справочник по математике, стр. 702, Таблица 20.8-1, формула c), которая имеет вид

yEnd = yStart + (k1/2 + k2+ k3+ k4/2) / 3, где

k1/2 = f (tStart, yStart)*h/2;

k2 = f (tStart + h/2, yStart + k1/2)*h;

k3 = f (tStart + h/2, yStart + k2/2)*h;

k4/2 = f (tStart + h, yStart + k3)*h/2;

Здесь функция f является вектором правой части уравнений yi = fi (t, y1,…,yN). Ссылка на этот вектор возвращается методом equations в третьем параметре (tempLocalVetor в методе DoStep). Независимая переменная tStart, вектор неизвестных функций yStart, шаг h, обозначенный currStep, и возвращаемый вектор yEnd являются параметрами метода DoStep. Сам метод DoStep вычисляет вектор yEnd, последовательно применяя приведенные формулы.

protected internal virtual void DoStep (double tStart, double currStep,

double [ ] yStart, double [ ] yEnd)

{

// Метод Рунге-Кутта 4-ого порядка

// Реализуется формула yEnd=yStart+(k1/2+k2+k3+k4/2)/3

double HalfStep = 0.5 * currStep;

try

{

// tempLocalVector=f(tStart,yStart);

// k1/2 =tempLocalVector*currStep/2

equations (tStart, yStart, tempLocalVector);

equationsCallNmb++;

for ( ushort count = 0; count < n; count++ )

{

// k1/2

yEnd [count] = HalfStep * tempLocalVector [count];

// yStart + k1/2

tempY [count] = yStart [count] + yEnd [count];

};

// tempLocalVector=f(tStart+currStep/2,yStart+k1/2);

// k2=tempLocalVector*currStep

equations (tStart + HalfStep, tempY, tempLocalVector);

equationsCallNmb++;

for ( ushort count = 0; count < n; count++ )

{

// yS+k2/2

tempY [count] = yStart [count] + HalfStep * tempLocalVector [count];

// k1/2+k2

yEnd [count] = yEnd [count] + currStep * tempLocalVector [count];

};

// tempLocalVector=f(tStart+currStep/2,yStart+k2/2);

// k3=tempLocalVector*currStep

equations (tStart + HalfStep, tempY, tempLocalVector);

equationsCallNmb++;

for ( ushort count = 0; count < n; count++ )

{

//yStart+k3

tempY [count] = yStart [count] + currStep * tempLocalVector [count];

//k1/2+k2+k3

yEnd [count] = yEnd [count] + currStep * tempLocalVector [count];

};

// tempLocalVector=f(tStart+currStep,yStart+k3);

// k4/2=tempLocalVector*currStep/2

equations (tStart + currStep, tempY, tempLocalVector);

equationsCallNmb++;

}

catch ( Exception e )

{

throw (new ApplicationException

(e.Message + "\nОшибка при обращении к уравнениям!"));

}

//Результирующие значения функций после данного шага

for ( ushort count = 0; count < n; count++ )

{

// yEnd = yStart+(k1/2+k2+k3+k4/2)/3

yEnd [count] = yStart [count] + 0.333333333333333333 *

(yEnd [count] + HalfStep * tempLocalVector [count]);

if ( Double.IsNaN (yEnd [count]) || Double.IsInfinity (yEnd [count]) )

throw (new ApplicationException

("\nКомпонента NaN или Infinity в методе DoStep!"));

};

}

Комментарии в тексте расшифровывают эту формулу и алгоритм ее реализации.

Обратите внимание на то, что практически все тело метода DoStep помещено в блок try…catch. Если при выполнении метода возникает исключительная ситуация (это, скорее всего, происходит во время одного из обращений к методу equations), обработчик блока catch возбуждает новую исключительную ситуацию, добавляя к сообщению e.Message о возникшей ситуации свое сообщение.

Теперь рассмотрим подробнее реализацию метода BasicLoop.

protected internal override bool BasicLoop (double tEnd)

{

double currStep, currHalfStep, Divergence, maxDivergence;

bool isGoodAcc, isLastStep, isStepTooSmall;

try

{

// Текущий шаг currStep выбирается равным оптимальному.

currStep = stepSize;

// Перед входом в цикл вызывается обработчик

if ( callBack != null && DoCallBack () ) return false;

// Цикл прохождения всего полного шага интегрирования

do

{

// Если текущий шаг составляет более 80% всего интервала,

// он выбирается равным интервалу tEnd-FCurrt.

// Флаг isLastStep регулирует выход из основного цикла.

if ( (currt + 1.25 * currStep - tEnd) * direction >= 0 )

{

// Шаг является последним

currStep = tEnd - currt; isLastStep = true;

}

else isLastStep = false; //Это не последний шаг

// Флаг isGoodAcc регулирует возможность увеличения шага,

// если погрешность излишне мала

isGoodAcc = true; //Допустим рост шага

//Делается один текущий шаг

DoStep (currt, currStep, currY, oneStepLocalVector);

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

do

{ //Делаются две половины шага

currHalfStep = 0.5 * currStep;

DoStep (currt, currHalfStep, currY, firstHalfStepLocalVector);

DoStep (currt + currHalfStep, currHalfStep,

firstHalfStepLocalVector, secondHalfStepLocalVector);

// Вычисляется макс. относительное расхождение

// в результатах одного шага и двух половинок

maxDivergence = 0.0;

for ( ushort count = 0; count < n; count++ )

{

if ( Double.IsInfinity (1.0 / oneStepLocalVector [count]) &&

Double.IsInfinity (1.0 / secondHalfStepLocalVector [count]) )

continue;

if ( oneStepLocalVector [count] != secondHalfStepLocalVector [count] )

{

// Абсолютное расхождение

Divergence = Math.Abs (oneStepLocalVector [count] -

secondHalfStepLocalVector [count]);

// Относительное расхождение вычисляется

// при достаточно большом абсолютном

if ( Divergence > epsilon )

Divergence =

2.0 * Divergence /

(Math.Abs (oneStepLocalVector [count]) +

Math.Abs (secondHalfStepLocalVector [count]));

if ( Double.IsInfinity (Divergence) || Double.IsNaN (Divergence) )

throw (new ApplicationException

("\nПроблема при вычислении maxDiv"));

// Корректируется значение максимального расхождения

if ( Divergence > maxDivergence ) maxDivergence = Divergence;

}

}

//Делаются выводы по сравнению с требуемой точностью

if ( maxDivergence > tolerance )

{

isGoodAcc = false; // Рост шага запрещен

currStep = currHalfStep; // Шаг уменьшается вдвое

stepSize = currHalfStep;

isLastStep = false;

firstHalfStepLocalVector.CopyTo (oneStepLocalVector, 0);

}

isStepTooSmall = currt == 0.0 && Math.Abs (currStep) <= epsilon

|| Math.Abs (currStep) <= Math.Abs (currt) * epsilon;

}

// Процесс проверки и уменьшения шага продолжается

// до достижения требуемой точности

while

( maxDivergence > tolerance && !isStepTooSmall );

if ( isStepTooSmall )

{ throw (new ApplicationException ("\nШаг слишком мал")); }

// Точность достигнута. Устанавливаются скорректированные значения

// функций в конце сделанного шага

for ( ushort count = 0; count < n; count++ )

currY [count] =

secondHalfStepLocalVector [count] + 0.0666666666666666667 *

(secondHalfStepLocalVector [count] -

oneStepLocalVector [count]);

//Если шаг не последний

if ( !isLastStep )

{

currt += currStep; //Изменение переменной

//Вызывается обработчик

if ( callBack != null && DoCallBack () ) return false;

if ( maxDivergence < lowestAcc && isGoodAcc )

{

//Слишком мелкий шаг удваивается

currStep += currStep;

if ( Math.Abs (currStep) > Math.Abs (tEnd - currt) )

currStep = tEnd - currt;

stepSize = currStep;

}

}

//Прерывание цикла, если сделан последний шаг

else break;

}

while ( true );

//Текущее значение переменной совпадает с конечным

currt += currStep; //tEnd

//Вызывается обработчик

return !(callBack != null && DoCallBack ());

}

catch (Exception e)

{

throw (new ApplicationException

(e.Message+ "\nBasicLoop прерван"));

}

}

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

Затем вызывается обработчик callBack, который может быть задан пользователем класса. В условном операторе логическая формула callBack != null && DoCallBack () возвращает true лишь в том случае, если обработчик callBack задан (ссылка на него не равна null - ссылке в «никуда») и метод DoCallBack, вызывающий обработчик, возвращает значение true. В этом случае выполнение метода BasicLoop прерывается, а сам метод возвращает false. Если обработчик callBack не определен (тогда ссылка на него имеет значение null), либо он определен, но DoCallBack возвращает после своего выполнения значение false, выполнение метода BasicLoop продолжается.

Далее в методе BasicLoop находится оператор цикла do…while(true). Он охватывает большую часть операторов метода BasicLoop. Такой оператор (условие while(true) всегда выполняется) является бесконечным циклом, и выход из него производится стандартной командой break, прерывающей выполнение любого цикла в C#. Внутри оператора do…while происходят оценки, позволяющие провести интегрирование уравнений от значения currt независимой переменной до tEnd - параметра метода BasicLoop.

В начале цикла длина всего интервала интегрирования |tEnd - currt| сравнивается с величиной текущего шага |currStep|. Если шаг превышает 80% длины интервала, то он выбирается равным всему интервалу и флаг isLastStep, указывающий на то, что это последний шаг, устанавливается в true. В противном случае флагу isLastStep присваивается значение false.

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

Затем, с помощью метода DoStep вычисляется результат оптимального шага currStep по формуле Рунге-Кутта. Этот результат возвращается в виде вектора приближенного решения oneStepLocalVector в точке currt + currStep.

Следующим оператором метода BasicLoop является новый цикл do…while, который «настраивает» шаг currStep в соответствии с допустимой погрешностью.

Для этого с помощью метода DoStep вычисляется результат шага той же длины currStep, но выполненного двумя половинными шагами. Результирующие вектора запоминаются в массивах firstHalfStepLocalVector и secondHalfStepLocalVector. Между компонентами вектора secondHalfStepLocalVector и компонентами вектора oneStepLocalVector, полученного одним полным шагом, устанавливается максимальное относительное расхождение maxDivergence. Если полученное расхождение превышает допустимую погрешность tolerance, то текущий шаг currStep (как и поле оптимального шага stepSize) уменьшается вдвое, флаги «хорошего приближения» isGoodAcc и «последнего шага» isLastStep «опускаются» (принимают значение false), а компоненты вектора последней точки искомой функции oneStepLocalVector принимают значения компонент вектора, полученного после половинного шага, firstHalfStepLocalVector.

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

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

Условием окончания цикла уменьшения шага является либо условие достижения требуемой точности maxDivergence < tolerance, либо недопустимо малое значение шага (флаг isStepTooSmall поднят).

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

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

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

устанавливается новое значение поля независимой переменной currt,

вызывается обработчик callBack (если он задан)

и при условии, что флаг isGoodAcc поднят (т.е. рост шага допустим) и максимальное расхождение maxDivergence меньше нижней границы погрешности lowestAcc, текущий шаг currStep удваивается и передает свое значение полю оптимального шага stepSize. При этом если удвоенный шаг выводит точку за границу интервала tEnd, значение currStep корректируется.

Далее цикл возвращается к началу, имея новые значения currt, соответствующий вектор currY и, возможно, новое значение текущего шага currStep и поля оптимального шага stepSize.

После завершения цикла поле независимой переменной currt принимает конечное значение tEnd, делая последний шаг, и вызывается обработчик callBack.

Занятие 1. .NET - C# - MS Visual Studio

Частью платформы .NET является мощная библиотека классов. Библиотека написана на языке C#, который, пожалуй, лучше всего приспособлен для программирования на платформе .NET. Использование среды MS Visual Studio значительно облегчает создание приложений на языке C#.

1.1 Введение

Особенности программирования на платформе .NET

Конечной целью программиста на платформе .NET (произносится дот-нет) является создание и компиляция кода программы в форме одного или нескольких исполняемых модулей (module). Исполняемым модулем является файл типа .dll или .exe, содержащий исполняемый код. Модуль типа .exe отличается от .dll тем, что содержит точку входа в программу.

Файлы исполняемых модулей не являются окончательным исполняемым кодом, доступным процессору, но представляют собой перевод кода программиста на так называемый «промежуточный язык» (MSIL - Microsoft Intermediate Language). Достоинством такого подхода является кросс-платформенность - код с промежуточного языка может быть транслирован в любой локальный код, понятный конкретному процессору. Для этого, естественно, на компьютере должна быть установлена платформа .NET.

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

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

На уровне программиста будущий исполняемый модуль типа .dll или .exe представляет собой один или несколько текстовых файлов - компилируемых модулей (compiled units). Термины компилируемый модуль и исполняемый модуль относятся к разным объектам, и их следует различать. Несколько компилируемых модулей, обычно формирующих приложение, собираются в процессе компиляции; к ним добавляются сведения, описывающие отличительные свойства исполняемого модуля, или сборки (assembly). Сведения о сборке, образующие так называемый манифест сборки, включают в себя имя, версию, ссылки на другие исполняемые модули, описание типов, доступных внешним модулям и самой среде (self-describing), и т.п.

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

Пространство имен (namespace)

Пространство имен служит для изоляции имен одной части кода от другой. (В Delphi такую изоляцию обеспечивают модули, unit.) Имена из одного пространства имен не вступают в конфликт с такими же именами из другого пространства имен. Так, имя name в пространстве имен ns1 не конфликтует с таким же именем name в пространстве имен ns2, так как их полные имена ns1.name и ns2.name разные.

Весь текст компилируемых модулей, формирующих сборку, может принадлежать одному или нескольким пространствам имен (namespace).

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

Один компилируемый модуль может содержать несколько пространств имен. Класс с именем class1, описанный внутри пространства имен с именем name1, имеет для внешних пространств имен имя name1.class1.

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

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

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

В пространство имен может входить описание одного или нескольких из перечисленных ниже типов классов.

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

interface - тип класса, все методы которого не реализованы, но объявлены. Это так называемые интерфейсы. Предполагается, что для каждого интерфейса существует хотя бы один class или struct, реализующий его методы. Класс типа class или struct, реализующий некоторый интерфейс, является наследником этого интерфейса.

enum - тип структур, объекты которых содержат элементы конечного счетного множества имен-обозначений целых чисел. Например, некий класс Жених может содержать качества-имена красивый, молодой, богатый и, вообще говоря, их произвольные сочетания. Под именами скрываются целые числа, например, красивый - 0, молодой - 2, богатый - 4. Такие структуры называются нумераторы, или перечислимые типы (enum).

delegate - тип класса, полями которого являются ссылки на методы заданного типа. Тип метода определяется числом параметров, типами параметров и типом возвращаемого объекта. Это так называемая сигнатура метода (signature). Объекты делегатов хранят и передают (делегируют) ссылки на методы с определенной сигнатурой одного (делегирующего) класса другому (делегируемому). Обычно делегаты используют для создания методов-обработчиков событий. Событие, наступающее в делегируемом классе, обрабатывается с участием метода делегирующего класса.

Структура классов

Типы class и struct состоят из членов класса (class member). К членам класса относятся

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

методы (method), объединяющие операторы кода и отличающиеся друг от друга именами и/или сигнатурой;

свойства (property) - поименованная пара методов доступа (accessors) set (установить) и get (возвратить) (или, по крайней мере, один из них), обычно используемых для доступа к значениям (value) полей класса;

индексаторы (indexer) - поименованная пара методов доступа (accessors) set и get (или, по крайней мере, один из них), устанавливающие и возвращающие некоторую величину (value), ассоциирующую значение объекта с элементом индексированного множества (массива);

события (event) - специальное свойство типа делегата с парой методов доступа (accessors) add (добавить) и remove (исключить), позволяющих удлинять или укорачивать цепочку методов (обработчиков), делегируемых для обработки события. Делегируемые методы выполняются в определенной точке кода и при выполнении определенного условия, т.е. при определенном событии. Например, при опросе очереди событий от мышки обнаруживается, что клавиша мышки была нажата - click-событие. Если цепочка делегатов click-события не пуста, все делегаты из цепочки вызываются при наступлении события.

константы (const) - неизменные поля данных, имеющие одинаковые значения для всех экземпляров класса; интерфейсы не имеют констант;

операторы (operator) - это операторы из числа стандартных операторов арифметических и логических действий, операторов сравнения и т.п., действия которых переопределяются в отношении объектов описываемого класса;

конструкторы (constructor) - специальные методы, носящие имя класса и вызываемые при создании экземпляра класса - объекта; интерфейсы не имеют конструкторов;

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

Кроме того, в структуру типов class и struct могут входить описания вложенных типов class, struct, delegate, enum, interface, но не пространств имен (namespace).

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

Описание одного типа class, struct или interface может охватывать несколько компилируемых модулей (частичное, или partial описание), но в любом случае должно принадлежать одной сборке (assembly).

Библиотека классов (Class Library)

Платформа .NET содержит библиотеку классов. Классы библиотеки имеют свои собственные имена, но доступ к ним осуществляется через расширенные (или, полные) имена. Например, базовый класс, наследниками которого являются все остальные классы библиотеки, имеет собственное имя Object. Полное его имя System.Object, так как класс Object принадлежит пространству имен System. Еще один пример. Класс Stream (поток) принадлежит пространству имен System.IO (Input-Output) и имеет полное имя System.IO.Stream. Пространство имен IO является вложенным в пространство имен System.

Физически библиотека классов находится в исполняемых модулях (сборках, или assemblies) типа .dll (библиотека классов). К этим модулям относятся mscorlib.dll, System.dll, System.Data.dll и т.д. Названия пространств имен не обязательно совпадают с именами модулей. Так классы System.Object и System.IO.Stream физически находятся в модуле mscorlib.dll. А, например, класс DataSet принадлежит пространству имен System.Data и находится в модуле System.Data.dll.

Среда и настройки

Прежде всего, следует установить на компьютере среду программирования (IDE - Integrated Development Environment), содержащую средства, необходимые для программирования на языке C#. Хотя тексты предлагаемых ниже примеров можно набирать и в обычном текстовом редакторе (например, в Блокноте), но транслятор с языка C# в любом случае необходим. Удобнее с самого начала работать в готовой среде. В дальнейшем мы предполагаем, что у читателя установлена среда MS Visual Studio 2005.

Все команды, которые мы будем использовать (их число невелико), находятся в различных меню среды. Ссылки на эти команды мы будем писать в форме, к примеру, File.New.Project…. Здесь File имя меню, New - команда из меню File, Project… - команда подменю команды New. Многоточие в конце имени команды означает, что ее выполнение приводит к появлению диалогового окна.

Среда имеет кнопки быстрого вызова многих команд меню, расположенные непосредственно под строкой меню. Кнопки сгруппированы в отдельные панели - Toolbars. Присутствие на экране панелей и кнопок регулируется настройками среды командой Tools.Customize…. В появившемся окне на странице Toolbars регулируется наличие на экране отдельных панелей инструментов, а на странице Commands - отдельных кнопок на панели. Для добавления к Toolbars кнопки с командой, например, Open Project обратитесь к странице Commands. В категории команд File (список категорий находится слева) найдите в правом списке команду Open Project. Нажав левую кнопку мышки, «захватите» эту команду и перенесите ее в какое-либо место стандартной панели. Удалить кнопку с панели можно обратным маневром - «захват» и перенос в окно настроек.

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

1.2 Solution и Project

Так называются два логических контейнера, которые заполняются файлами с кодом программы. Solution - самый большой, внешний контейнер. Project - внутренний контейнер. Контейнер Solution может заполняться любым количеством контейнеров Project. Любой контейнер Project должен быть частью какого-либо контейнера Solution. На конечном этапе создания программы файлы контейнера Project компилируются в один исполняемый модуль (.dll или .exe). Объединение различных проектов в общий контейнер Solution несет чисто логическую нагрузку.

Создадим пустой контейнер типа Solution. Для этого

Вызовем команду File.New.Project….

В левой панели Project Types: появившегося окна New Project выберем узел Other Project Types и в нем команду Visual Studio Solutions.

На правой панели Templates: (шаблоны) выберем шаблон Blank Solution.

Согласившись с именем Solution1 по умолчанию и с местом размещения каталога с тем же именем (по умолчанию среда организует каталог Solution1 в каталоге My Documents\Visual Studio 2005\Projects текущего профиля-пользователя), щелкнем OK.

В каталоге Solution1 среда формирует два файла с тем же именем и расширениями sln (solution) и suo (solution user options). В файл с расширением sln среда помещает информацию о том, из каких проектов состоит Solution1 и где эти проекты размещены. В файле suo сохраняется информация о пользовательских опциях, связанных с Solution1.

Добавим в Solution1 пустой проект. Для этого

Вызовем окно View.Solution Explorer (если оно автоматически не появилось на экране).

Щелкнем правой кнопкой над верхним узлом дерева Solution `Solution1'(0 projects).

В появившемся контекстном меню вызовем команду Add.New Project….

В правой панели Templates: появившегося окна Add New Project выберем Empty Project.

В строке Name появится имя по умолчанию Project1. Оставим его без изменения. Щелкнем OK.

В результате наших действий в каталоге Solution1 появится новый каталог Project1. Этот каталог должен содержать внутренние каталоги bin и obj, созданные средой для размещения в них скомпилированных модулей, и файл с именем проекта Project1 и расширением csproj, который используется средой разработки и содержит информацию, специфическую для проекта. В нашу задачу не входит полный анализ содержимого вспомогательных файлов, поддерживаемых средой в ходе работы над проектом. Отметим лишь, что не следует уничтожать или перемещать какие-либо из образованных средой каталогов и файлов в процессе работы над проектом.

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

Проект

В древесной структуре окна Solution Explorer имеется узел Project1. Щелкнув по этому узлу правой кнопкой, вызовем контекстное меню. Командой Add.New Item… откроем окно с заголовком Add New Item - Project1. На панели Templates: выберем шаблон Code File. Согласимся с именем CodeFile1.cs, предложенным средой по умолчанию, и нажмем кнопку Add.

В результате наших действий в древесной структуре окна Solution Explorer появится новый узел - ссылка на файл CodeFile1.cs и откроется пустое окно с тем же именем. Расширение cs (от CSharp) добавляется ко всем текстовым файлам, содержащим код, написанный на языке C#. Если требуется удалить кодовый файл из проекта, следует в окне Solution Explorer открыть контекстное меню над именем удаляемого файла и выбрать команду Delete.

Наберем в окне CodeFile1.cs простой код - описание пока пустого класса с именем _1.

class _1

{

}

Сохраним новую редакцию файла командой File.Save CodeFile1.cs.

Обратите внимание на то, что слева от текста появились вертикальные скобки с квадратом и знаком минус в верхнем углу. Такие скобки ограничивают сворачиваемую область текста (collapsible region). Использование такого рода областей существенно упрощает обзор структуры кода и его логическое описание (блок-схема). Щелчком мышки по квадратику-метке поименованная область сворачивается, оставляя лишь первую строку текста. Знак минус заменяется знаком плюс, новый щелчок по которому разворачивает текст.

IntelliSense

Обратите внимание на действия среды при наборе текста. Сразу после набора первого символа слова class среда предлагает список возможных слов, подходящих по контексту. Можно выбрать в этом списке требуемое слово class и, нажав Enter, внести его в текст кода. Этот инструмент, именуемый IntelliSense, значительно облегчает набор кода.

Служебные слова (keywords)

Слово class является служебным словом (keyword) транслятора C#. Служебные слова выделяются средой. Везде в тексте служебные слова будут выделены полужирным шрифтом.

Идентификаторы

Имя класса _1 относится к словам-идентификаторам.

Идентификатор может быть любым сочетанием букв, цифр и символа подчеркивания. Первым символом может быть либо буква, либо символ подчеркивания. Большие и малые буквы различаются компилятором. Поэтому идентификаторы aB, Ab, ab и AB - это четыре разных идентификатора.

Замечания.

Ключевое слово компилятора может служить идентификатором, если его предварить символом @. Например, @class может использоваться в качестве идентификатора.

Место любого допустимого символа в идентификаторе может занимать так называемая escape-последовательность - последовательность некоторых символов, следующих за символом \ (backslash). Записью одного символа в идентификаторе может быть сочетание \u (от Unicode) и двухбайтового целого числа в шестнадцатеричной системе счисления. Это число является двухбайтовым унифицированным кодом символа. Например, выражение \u0041\u0042 означает AB, а сочетание \u042f\u044f есть escape-последовательности двух букв кириллицы Яя.

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

1.3 Метод Main

Строка

class _1

является простейшим заголовком описания класса. За заголовком класса следует описание членов класса (class members). Описание членов класса ограничено фигурными скобками. Это блок членов класса.

Сейчас класс _1 пуст.

Попытка скомпилировать проект с пустым классом командой Build.Build Solution закончится неудачей. Появится сообщение об ошибке. У проекта Project1 отсутствует некий статический метод Main, служащий точкой входа проекта.

Добавим внутрь блока членов класса _1 (между фигурными скобками) описание метода Main следующего вида

static void Main()

{

}

На этот раз компиляция пройдет успешно.

Первым (и пока единственным) членом класса _1 является метод класса с именем Main. Метод Main является входной точкой программы. С него начинается выполнение программы и на нем выполнение программы заканчивается. Хотя бы один класс программы должен иметь метод Main. Измените в методе Main букву M на m. Опять проведите компиляцию. Результат будет отрицательный. Важно, чтобы имя метода было именно Main, а не main. Уберите слово static в описании метода Main. Проведите компиляцию. Она вновь будет ошибочной.

Правила следующие

Метод Main должен иметь модификатор static.

Метод Main может ничего не возвращать (иметь тип void), или возвращать значение типа int (целое). В последнем случае внутри метода должен быть оператор возврата вида return expr, где expr - выражение целого типа.

Метод Main может не иметь параметров вовсе или иметь один параметр типа массива строк string[].

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

1 вариант кода

static int Main()

{

return 1;

}

2 вариант кода

static void Main(string[] args)

{

}

3 вариант кода

static int Main(string[] args)

{

return 0;

}

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

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

1.4 Модификатор static

Пусть имя класса _1. Пусть член класса имеет имя Member. Наличие модификатора static перед описанием Member указывает на то, что член класса Member может быть использован вне класса только в форме _1.Member. Говорят, что член класса типа static принадлежит самому типу этого класса, но не его экземплярам. Вспомним, что каждому классу отвечает область памяти с таблицей виртуальных методов. В этом смысле идентификатор _1 в нашем случае является ссылкой на ту область памяти, где эта таблица помещена. Статический метод класса это функция, неявным параметром которой является ссылка на область VMT. Так же, обычный метод (метод экземпляра, нестатический метод) является функцией, неявным параметром которой является ссылка на область, где расположены поля экземпляра. Кроме VMT в области данных класса как типа могут размещаться статические поля, и они будут управляться статическими методами.

1.5 Метод класса и его тип

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

Параметры метода

За указанием типа метода и его имени следует список параметров метода в круглых скобках. Даже если метод не имеет параметров, круглые скобки все-таки пишутся. Каждый параметр должен быть обозначен идентификатором, перед которым следует указать тип параметра. Так одна из версий метода Main имеет один параметр с именем args типа string[] - массив строк.

1.6 Работающий проект

Оставим первоначальную редакцию метода

static void Main()

{

}

Активизируем проект командой Debug.Start Debugging. В результате получим мелькнувшее на мгновение черное окно и возврат в среду.

Ничего удивительного. Метод Main пуст. Чтобы зафиксировать черное окно добавим внутрь блока метода Main (между фигурными скобками) строку

System.Console.ReadLine();

и вновь стартуем проект.

Теперь черное окно осталось на экране. Войдя в это окно и нажав Enter, завершим проект. Замечание.

В некоторых версиях среда может предоставить свое черное окно Console. Следует войти в окно Console и нажать Enter или завершить проект командой Debug.Stop Debugging.

Еще об IntelliSense

Обратите внимание на действия инструмента IntelliSense при наборе последней строки.

Сразу же после набора первой буквы S IntelliSense показывает список возможных имен, начинающихся с буквы S. В списке слева от каждого имени дается значок. Имени System отвечает значок из фигурных скобок вида {}. Так помечаются пространства имен.

После выделения в списке какого-либо элемента (мышкой, либо клавишами курсора) появляется окно с кратким описанием выбранного элемента.

После появления точки в выражении System. список IntelliSense содержит все пространства имен, вложенные в System, и все имеющиеся в System классы.

Далее, после набора класса Console, список IntelliSense содержит все статические члены класса Console.

У IntelliSense есть «память». Если начать писать новый оператор с буквы S (поставив точку с запятой после System.Console.ReadLine();), то IntelliSense сразу выделит элемент System, который недавно использовался.

1.7 Перегруженные методы (overloaded)

Изменим код так, чтобы получить какой-либо текст в черном окне. Для этого обратимся к другому методу класса System.Console. А именно, добавим перед уже имеющейся строкой System.Console.ReadLine(); внутри метода Main строку вида

System.Console.WriteLine("Hello C#!");

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

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

1.8 Константы типа string

Была выбрана реализация метода WriteLine с параметром типа string. В качестве фактического параметра подставлена постоянная типа string "Hello C#!". Заметим, что любая постоянная типа string заключается в двойные кавычки. Внутри кавычек можно писать как любые символы, так и их escape-последовательности. Например, вместо "Hello C#!" можно набрать строку "\u0048ello C#!”. Программа выведет на экран ту же строку. Проверьте.

Внутрь строки можно вставлять escape-последовательности другого формата. Например, \n означает перенос строки. Проверьте результат выполнения программы, набрав строку "Hello\nC#!". Другой символ \t означает табуляцию. В общем случае при формировании escape-последовательности за символом \ (backslash) могут стоять только определенные символы. Среди них " (двойные кавычки), \(backslash), a (звуковой сигнал). Полный список можно найти в справочной системе.

Строка может предваряться символом @. В этом случае все символы, находящиеся внутри кавычек, будут восприниматься дословно (verbatim). Проверьте вывод текста @”Hello\nC#!”. Такой способ записи строки часто используется для маршрутных строк типа @”C:\Мои документы\Visual Studio 2005\”, где в качестве содержательного символа строки используется служебный символ escape-последовательности \ (backslash). Если внутри дословно записываемой строки необходимо поместить двойные кавычки, их надо предварить двойными кавычками. Например, @”””Hello”” - said C#”.

1.9 Директива using

В теле метода Main дважды использовался класс из пространства имен System. Если указание на пространство имен System опустить, то компилятор не сможет найти класс System.Console и выдаст ошибку. Попробуйте сделать это.

Однако использование длинного расширенного имени System.Console можно избежать, введя в начале файла (перед заголовком класса) строку вида

using System;

В этом случае можно заменить расширенное имя класса System.Console более коротким Console. Текст файла CodeFile1 т.о. будет иметь вид

using System;

class _1

{

static void Main()

{

Console.WriteLine("Hello C#!");

Console.ReadLine();

}

}

Строка using System; указывает на то, что проект будет использовать стандартные классы из библиотеки System. Директива using в начале компилируемого модуля используется для сокращенной записи имен в тексте модуля.

Существует еще один аспект использования директивы using. Вслед за строкой

using System;

или, даже, вместо нее наберите строку

using C=System.Console;

После этого везде в тексте вместо идентификатора Console поставьте символ C. Так что новая версия кода будет иметь вид

using C=System.Console;

class _1

{

static void Main()

{

C.WriteLine("Hello C#!");

C.ReadLine();

}

}

Вновь активизируйте программу командой Debug.Start Debugging. Результат будет прежним - программа работает. Таким образом, директиву using можно использовать для объявления псевдонимов (alias) классов.

Замечание.

После любого редактирования текста файла справа от его имени на закладке страницы появляется знак * (asterisk). Если новую редакцию сохранить командой File.Save CodeFile1.cs, asterisk исчезает. При больших объемах редактирования регулярно сохраняйте новую редакцию файла. Тогда при сбое в работе компьютера редакция не будет утеряна. Заметим также, что при компиляции среда автоматически сохраняет последние редакции файлов, участвующих в компиляции.

1.10 Параметры по значению и по ссылке

Параметры по значению

Добавьте внутрь блока членов класса _1 (между фигурными скобками, но вне метода Main) описание метода UseValue с одним параметром целого типа

static void UseValue(int i)

{

i = i + 1; // Изменение значения параметра i

C.WriteLine(i);// Распечатка значения параметра i

}

Внутри метода Main поместите операторы

int j = 0;// описание и инициализация локальной переменной j

UseValue(j);// вызов метода UseValue с фактическим параметром j

C.WriteLine(j);// распечатка значения j

Дайте команду Debug.Start Debugging и посмотрите результат. В окне должны быть 1 и 0. Значение j, переданное методу UseValue в качестве фактического параметра, было помещено в стек метода UseValue в качестве параметра-значения i. Значение копии i было изменено и распечатано внутри метода UseValue. При этом значение оригинала j осталось без изменений (ноль).

Параметры по ссылке

В описании параметра метода могут присутствовать служебные слова (keywords) ref и out.

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

Для примера опишите еще один метод класса _1 (до или после метода UseValue, но вне метода Main)

static void UseRef(ref int i)

{

i = i + 1;

C.WriteLine(i); // Распечатается 1

}

Добавьте внутрь метода Main операторы

UseRef(ref j);

C.WriteLine(j);// Также распечатается 1

Результат должен отличаться - две единицы. Теперь значения j и i будут совпадать, поскольку это значения одного и того же объекта j, на который ссылается параметр i метода UseRef при его вызове. Копирования значения j в стек метода UseRef не происходит, а параметр i является фактически псевдонимом того же объекта, что и j.

Обратите внимание, что служебное слово ref должно использоваться как при описании метода, так и при его вызове. Заметим, что в Delphi слову ref отвечает символ var.

Другое служебное слово out так же, как и ref, определяет параметр по ссылке. Отличие out от ref в том, что фактический параметр, описанный как out, может вовсе не иметь никакого значения до вызова метода, а описанный как ref должен иметь какое-либо значение перед вызовом метода. В предыдущем примере фактический параметр j имеет значение ноль в момент вызова метода UseRef.

Наберите новый метод UseOut в классе _1

static void UseOut(out int i)

{

i = 0;

C.WriteLine(i);

}

Наберите в методе Main код

int k;

UseOut(out k);

C.WriteLine(k);

Посмотрите результат; распечатаются два нуля - значения i и k. Они совпадают, так как переменная i является псевдонимом того же объекта, что и k, как и в случае параметра типа ref.

Перед вызовом метода UseOut значение объекта k не определено. Если попытаться распечатать значение k перед вызовом метода UseOut, возникнет ошибка компиляции (попробуйте). Сравните с предыдущими примерами.

1.11 Два метода Main

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

В окне Solution Explorer щелкнем правой кнопкой узел проекта Project1, вызвав контекстное меню.

Командой Add.New Item… откроем окно с заголовком Add New Item - Project1.

На панели Templates: выберем шаблон Code File.

Согласимся с именем CodeFile2.cs, предложенным средой по умолчанию, и нажмем кнопку Add.

В новом файле наберем код

class _2

{

static void Main(string[] args)

{

}

}

Сохраним новую редакцию файла CodeFile2.cs.

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

Чтобы уточнить какой, можно

убрать один из двух методов Main,

либо указать компилятору, какой из двух методов Main следует использовать.

Сделаем последнюю операцию. Войдем в окно со свойствами проекта командой Project.Project1 Properties…. На закладке Application найдем элемент Startup Object. Откроем выпадающий список значений этого элемента (по умолчанию значение не установлено). Выберем из двух предложенных значений класс _2. Скомпилируем проект еще раз. Компиляция должна пройти успешно.

1.12 Командная строка (Command Line)

Командной строкой (command line) является последовательность символов, которая набирается при активизации приложения командой run (Выполнить...) меню кнопки «Пуск». Командная строка включает в себя полное имя файла приложения (в нашем случае это Project1.exe с указанием маршрута из корневого каталога) и аргументы, состоящие из любых строк, разделенных пробелами. Параметр args типа string[] (массив строк) метода Main класса _2 содержит эти аргументы.

...