В этом приложении будет представлено краткое введение в язык C#, специально предназначенное для тех разработчиков, опыт которых до сих пор был частично или полностью связан с Visual Basic 6.

Отметим, что в рамках этого приложения аббревиатура VB означает VB6. В тех случаях, когда говорится о VB.NET, это указывается явно.

C# и Visual Basic являются очень разными языками как в своих синтаксических стилях, так и в фундаментальных концепциях, на которых они основываются. Это означает, что разработчикам Visual Basic потребуются существенные усилия, чтобы освоиться с C# даже на базовом уровне. С помощью этого приложения мы попытаемся облегчить процесс обучения, предоставив введение в C#, которое специально предполагает знание VB, и сосредоточившись на основных концептуальных различиях между двумя языками. В ходе этого приложения будет проведено сравнение, как кодировать решения проблемы в VB и в C#, представляя вместе код C# и код VB.

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

Помимо очевидных синтаксических различий между языками, существуют две основные концепции, которые необходимо знать, чтобы можно было двигаться от VB к C#: 

1. Концепция полного потока выполнения программы от начала до конца. Visual Basic скрывает этот аспект программ, так что в модулях классов кодируется только часть программы VB, связанная с обработкой событий и всеми методами. C# делает доступной всю программу в виде исходного кода. Это объясняется тем, что C# можно философски рассматривать как последующую генерацию C++, а корни C++ уходят в 60-е годы. C++ предшествовал оконным интерфейсам пользователя и развитым операционным системам. C++ развился как низкоуровневый, близкий к машине универсальный язык программирования. Написать приложение GUI с помощью C++ означает, что необходимо явно вызвать системные вызовы для создания и взаимодействия с оконными формами. Язык C# построили на этом наследии, упростив и модернизировав C++ так, чтобы низкоуровневые преимущества C++ в производительности можно было достичь с помощью кодирования не сложнее, чем в VB. VB, с другой стороны, является молодым языком, созданным специально для быстрой разработки приложений GUI Windows. По этой причине в VB весь стандартный код GUI является скрытым, и программист VB реализует только обработчики событий. C#, со своей стороны, показывает стандартный код как часть исходного кода.

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

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

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

Приложение будет закончено кратким обзором некоторых из оставшихся различий между VB и C#, не показанных в примерах.

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

В этом приложении будут достаточно интенсивно использоваться классы C#. Они представляют собой точно определенные объекты, которые подробно рассматриваются в главах 4 и 5. Но для логичности изложения лучше представлять их как эквиваленты C# модулей классов VB, так как они являются достаточно похожими сущностями. Подобно модулю класса VB, класс C# реализует свойства и методы и содержит переменные члены. Так же как для модуля класса VB, можно создавать объекты заданного класса C# (экземпляры класса) с помощью оператора new. За этим сходством, однако, скрывается много различии. Например, модуль класса VB является на самом деле классом COM. Классы C#, напротив, обычно не являются классами COM, но они всегда интегрированы в среду .NET. Классы C# являются также более динамичными чем их аналоги VB/COM, в том смысле, что они обеспечивают более высокую производительность и дают меньшую потерю быстродействия при создании экземпляра. Но эти различия мы почти не будем учитывать при обсуждении языка C#.

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

В C# компиляция делается в два этапа, где первый этап выполняется на так называемом промежуточном языке (IL) Этот этап будем называть собственно компиляцией. Второй этап — преобразование в исполнимый код, происходящее во время выполнения, является более простым этапом, поэтому он не ведет к значительным потерям производительности. Он также не является интерпретацией. Сразу целые части кода преобразуются из IL в язык ассемблера, и полученный исполнимый код на собственном языке машины затем сохраняется, поэтому не требуется его перекомпиляции в следующий раз, когда будет выполняться эта часть кода. Компания Microsoft считает, что в комбинации с различными оптимизациями это, в конечном счете ведет к коду, который действительно выполнится быстрее, чем при использовании предыдущей системы прямой компиляции из исходного кода в собственный исполнимый код. Хотя о существовании IL необходимо помнить, он не будет влиять на обсуждение в этом приложении, так как он реально не влияет на синтаксис языка C#.

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

CInt

CStr

C# также полагается на интенсивную поддержку из областей такого вида, но в случае C# поддержка предоставляется с помощью большого множества классов, известного как базовые классы .NET. Эти классы оказывают поддержку почти всем аспектам разработок под Windows. Существуют классы, представляющие все обычные элементы управления, дату, время, доступ к файловой системе, доступ в Интернет, а также многие другие. Здесь подробно не рассматривается библиотека базовых классов .NET, но она часто используется. На самом деле C# очень хорошо интегрирован в пазовые классы .NET, и можно обнаружить, что многие ключевые понятая C# — это просто оболочки определенных базовых классов. В частности, все базовые типы данных C#, которые используются для представления целых чисел, чисел с плавающей точкой, строк и т. д. являются на самом деле базовыми классами.

Одним из важных различий между VB6 и C# в этом отношении является то, что система функций VB является специфической для VB, в то время как базовые класс .NЕТ доступны для любого поддерживающего .NET языка программирования.

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

// Код который уже был показан

// Код C#, на который необходимо обратить внимание или который

// является новым

Однако весь код VB дается в следующем формате:

' Код VB представлен на белом фоне

В этом разделе мы рассмотрим простое приложение, называемое

SquareRoot

i

Чтобы это приложение работало в Visual Basic, надо добавить обработчик событий для события нажатия кнопки. Для кнопки задается имя

cmdShowResults

txtNumber

txtSign

txtResult

Option Explicit

Private Sub cmdShowResults_Click()

 Dim NumberInput As Single

 NumberInput = CSng(Me.txtNumber.Text)

 If (NumberInput < 0) Then

  Me.txtSign.Text = "Negative"

  Me.txtResult.Text = CStr(Sqr(-NumberInput)) & " i"

 ElseIf (NumberInput = 0) Then

  txtSign.Text = "Zero"

  txtResult.Text = "0"

 Else

  Me.txtSign.Text = "Positive"

  Me.txtResult.Text = CStr(Sqr(NumberInput))

 End If

End Sub

Это единственный фрагмент кода VB, который необходимо написать.

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

// Обработчик событий нажатия пользователем кнопки Show Results.

// выводится квадратный корень и знак числа

private void OnClickShowResults(object sender, System.EventArgs e) {

 float NumberInput = float.Parse(this.txtNumber.Text);

 if (NumberInput < 0) {

this.txtSign.Text = "Negative";

  this.txtResult.Text = Math.Sqrt(-NumberInput).ToString() + " i";

 } else if (NumberInput == 0) {

  txtSign.Text = "Zero";

  txtResult.Text = "0";

 } else {

  this.txtSign.Text = "Positive";

  this.txtResult.Text = Math.Sqrt(NumberInput).ToString();

 }

}

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

Давайте рассмотрим две программы SquareRoot для ознакомления с синтаксисом C#.

Начнем с первой строки кода VB, где находится объявление

Option Explicit

Option Explicit

Option Explicit

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

Option Explicit

Комментирование кода всегда важно, поэтому дальше в обоих примерах (или первое, что делается в примере на C#) добавляется комментарий:

// Обработчик событий нажатия пользователем кнопки Show Results.

// Выводится квадратный корень и знак числа

private void OnClickShowResults(object sender, System.EventArgs e) {

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

//

// Этот код определяет результаты

int Result = 10 * Input; // получение результата

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

Комментарий также может быть ограничен последовательностями символов

/

*/

/*

*/

/* этот текст действительно является длинным

длинным

длинным

длинным

комментарием * /

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

X = /* 20 */ 15;

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

/// <summary>

/// Event handler for user clicking Show Results button.

/// Displays square root and sign of number

/// </summary>

/// <param name="sender"></param>

/// <param name="e"></param>

private void OnClickShowResults(object sender, System.EventArgs e)

Если впереди используются три наклонные черты вместо двух, то комментарий по-прежнему продолжается до конца строки. Однако этот комментарий имеет теперь дополнительный результат: компилятор C# способен на самом деле использовать комментарии, которые начинаются с трех наклонных черт, чтобы автоматически создавать документацию для исходного кода как отдельный файл XML. Именно поэтому пример выше имеет достаточно формальную структуру для реального текста комментария. Эта структура готова к размещению в файле XML. Здесь не будут представлены детали этого процесса (он рассмотрен в главе 3). Необходимо только сказать, что комментируя каждый метод в коде, можно автоматически получить законченную документацию, которая обновляется при изменении кода. Компилятор будет даже проверять, что документация соответствует сигнатурам методов и т.д.

Наиболее заметным различием между приведенными выше кодами на VB и на C# будет, почти наверняка, присутствие точек с запятыми и фигурных скобок в коде C#. Хотя это делает код C# довольно устрашающим, принцип на самом деле очень простой. Visual Basic применяет возврат каретки для указания конца инструкции, в то время как в C# используется для той же цели точка с запятой. Фактически компилятор полностью игнорирует все лишние пробелы, включая возвраты каретки. Эти свойства синтаксиса C# можно комбинировать, чтобы предоставить большую свободу при размещении кода. Например, следующий код (переформатированный из части приведенного выше примера) также вполне допустим в C#:

this.txtSign.Text = "Negative";

this.txtResult.Text = Math.Sqrt(-NumberInput) + " i";

Хотя очевидно, что если потребуется, чтобы другие люди смогли прочитать код, лучше предпочесть первый стиль кодирования. Visual Studio.NET будет в любом случае автоматически размещать код в таком стиле.

Скобки используются для группирования вместе инструкций в так называемые блочные инструкции (или иногда составные инструкции). Эта концепция в действительности не существует в VB. Можно сгруппировать вместе любые инструкции, помещая вокруг них скобки. Группа теперь рассматривается как одна блочная инструкция и может использоваться в любом месте в C#, где ожидается одиночная инструкция.

Блочные инструкции часто используются в C#. Например, в приведенном выше коде C# не существует явного указания на конец метода (C# имеет методы там, где VB имеет функции и подпрограммы). VB требуется инструкция

End Sub

Следующее действие часто встречается в C#: там, где Visual Basic использует некоторое ключевое слово для пометки конца блока кода, C# просто объединяет блок в составную инструкцию. Инструкция

if

EndIf

if

else

Еще одна особенность, которую можно заметить в отношении синтаксиса, состоит в том, что все ключевые слова—

if

else

int

If

if

Name

name

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

Как правило, ключевые слова C# записываются полностью строчными буквами.

Давайте сравним синтаксис, применяющийся в VB и C# для объявления части кода, которая будет обрабатывать событие.

В VB:

Private Sub cmdShowResults_Click()

а в C#:

private void OnClickShowResults(object sender, System.EventArgs e)

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

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

void

OnClickShowResults()

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

Sub

void

Подобно Sub в VB, приведенному выше объявлению метода в C# предшествует ключевое слово

private

Необходимо отметить еще два различия в объявлении метода: версия C# получает два параметра и имеет имя, отличное от обработчика событий в VB.

Сначала рассмотрим различие в имени. Имя обработчика событий в VB задается как VB IDE. VB знает, что Sub является обработчиком событий для нажатия кнопки, потому что используется имя

cmdShowResults_Click

On

Pascal

OnClickShowResults()

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

Пример

SquareRoot

Dim NumberInput As Single

NumberInput = CSng(Me.txtNumber.Text)

Версия C# выглядит следующим образом:

float NumberInput = float.Parse(this.txtNumber.Text);

Как и можно было ожидать, типы данных в C# не совсем такие, как в VB.

float

Single

float NumberInput;

NumberInput = float.Parse(this.txtNumber.Text);

Теперь можно сравнить объявление и инициализацию переменной по отдельности.

Очевидное синтаксическое различие между C# и VB в объявлении переменных состоит в том, что в C# тип данных предшествует, а не следует за именем переменной без использования других ключевых слов. Это дает объявлениям C# более компактный формат, чем их аналогам в VB.

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

private void OnClickShowResults(object sender, System.EventArgs e);

Тип (

void

object

System.EventArgs

object

Object

object

object

object

System.EventArgs

В случае переменных синтаксис объявления, использованный в C#, позволяет комбинировать объявление с заданием начального значения переменной. В этом примере

NumberInput

int x = 10; // int аналогично Long в VB

string Message = "Hello World"; // string аналогично String в VB

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

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

$

String

%

Int

&

Long

Dim Message$ ' будет string

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

В примере кода VB переменной

NumberInput

Присваивание значений переменным в C# делается с помощью такого же синтаксиса, как и в VB. После имени переменной помещается знак

=

Let

Set

Set MyListBox = new ListBox;

C# не использует отдельный синтаксис для присваивания объектных ссылок. Эквивалент в C# для вышеприведенного будет следующим:

MyListBox = new ListBox();

Помните, что в C# значения переменным всегда присваиваются с помощью синтаксиса

<ИмяПеременной>=<Выражение>

.

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

NumberInput

SquareRoot

txtNumber

NumberInput = CSng(Me.txtNumber.Text)

и

float NumberInput = float.Parse(this.txtNumber.Text);

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

Me

this

Me

float NumberInput = float.Parse(txtNumber.Text);

Более интересной частью является то, как строка, извлеченная из текстового поля, преобразуется во

float

single

В C# все является частью класса.

В VB для преобразования используется функция

CSng

В C# преобразование из строки в число с плавающей точкой выполняется методом

Parse()

Parse()

Parse()

float

float

Single

int

float

string

int

float

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

Parse

вызван с помощью определения имени класса

float

, а не имени переменной.

Parse()

в действительности является специальным типом метода, называемого статическим (

static

) методом. Статический метод можно вызывать, не создавая экземпляр класса. Следовательно здесь определяется имя класса

float

, а не имя переменной.

static

имеет в C# значение, отличное от того, которое он имеет в VB. В C# нет эквивалента статическим переменным VB — в них нет необходимости в объектах C#, так как с этой целью будут использоваться поля C#.

Мы переходим к основной части обработчика событий — инструкции

if

If (NumberInput < 0) Then

 Me.txtSign.Texgt = "Negative"

 Me.txtResult.Text = CStr(Sqr(-NumberInput)) & " i"

ElseIf (NumberInput = 0) Then

 txtSign.Text = "Zero"

 txtResult.Text = "0"

Else

 Me.txtSign.Text = "Positive"

 Me.txtResult.Text = CStr(Sqr(NumberInput))

EndIf

в то время как версия C# записывается так:

if (NumberInput < 0) {

 this.txtSign.Text = "Negative";

 this.txtResult.Text = Math.Sqrt(-NumberInput).ToString() + " i";

} else if (NumberInput == 0) {

 txtSign.Text = "Zero";

 txtResult.Text = "0";

} else {

 this.txtSign.Text = "Positive";

 this.txtResult.Text = Math.Sqrt(NumberInput).ToString();

}

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

txtSign

if (NumberInput < 0) this.txtResult.Text = Math.Sqrt(-NumberInput) + " i";

else if (NumberInput == 0) txtSign.Text = "Zero";

else this.txtResult.Text = Math.Sqrt(NumberInput).ToString();

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

if

If NumberInput < 0 Then

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

NumberInput

else if (NumberInput == 0)

В VB символ

=

=

==

Существует еще одно важное различие, которое надо учитывать, так как оно может легко привести к ошибкам при переходе от VB к C#:

else if

состоит в C# из двух слов, а в VB используется одно слово

ElseIf

В соответствии со сделанным ранее замечанием о том, что все в C# является членом класса, будет неудивительно узнать, что эквивалент в C# функции

Sqr

Sqrt()

System.Math

Math

Можно также заметить, что в этом примере в условии с введенным числом, точно равным нулю, ключевое слово

this

txtSign.Text = "Zero";

txtResult.Text = "0";

и в соответствующем коде VB также не определяется явно

Me

this

Me

При выводе квадратного корня отрицательного числа выполняется небольшая работа со строками:

this.txtResult.Text = Math.Sqrt(-NumberInput).ToString() + " i";

Этот код покалывает, что в C# конкатенация строк делается с помощью символа

+

&

float

String

float

ToString()

ToString()

Мы завершили сравнение процедур обработки событий в C# и VB. В процессе обсуждения мы много узнали о синтаксических различиях между этими языками. Фактически была показана большая часть базового синтаксиса C#. Мы также впервые столкнулись с тем фактом, что все в C# является классом. Однако, если загрузить код нашего примера с web-сайта издательства Wrox, и просмотреть его, то почти наверняка можно будет заметить, что мы тщательно избегали какого-либо обсуждения наиболее очевидного различия между двумя примерами: в примере на C# в действительности код намного длиннее и включает не только обработчик событий. Для версии VB примера

SquareRoot

Причина, по которой код в проекте C# такой большой, связана с тем, что Visual Basic IDE большая часть того, что делается в программе, исходит от программиста. В Visual Basic требовалось написать только обработчик событий, но фактически выполняется значительно больше: запускается пример, выводится форма на экране, посылается информация Windows, зависящая от того, что желательно делать с событиями, и по окончании пример завершается. В Visual Basic программист не имеет доступа к коду, который делает все. C#, напротив, использует совершенно другую философию, и оставляет весь этот код открытым. Это может сделать внешний вид исходного кода более сложным. Но имеется одно преимущество: если код доступен, то его можно редактировать и это обеспечивает значительно большую гибкость в решении того, как должно себя вести приложение.

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

SquareRoot

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

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

Form_Load

Form_Load

В действительности приведенный выше абзац не совсем справедлив. В VB существует процедура

Sub Main()

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

Чтобы увидеть, как можно связать две идеи программирования, давайте выясним, что реально происходит, когда выполняется любое приложение Visual Basic или любое приложение GUI Windows, не важно на каком языке оно написано. Это более ограниченное рассмотрение, чем в случае приложении, которые упоминались перед этим, так как теперь мы сосредоточимся только на приложениях Windows API (другими словами, нет консолей, служб и т.д.).

Как обычно, выполнение начинается в некоторой вполне определенной точке. Команды будут вовлекать в работу некоторые окна и элементы управления, а также вывод этих элементов управления на экран. В этом месте программа делает затем что-то, что называют входом в цикл сообщений. На самом деле программа засыпает и приказывает Windows разбудить себя, когда произойдет что-то интересное, о чем ей необходимо знать. Эти "интересные" вещи являются событиями, для которых необходимо написать обработчики событий, а также существует достаточно много событий, для которых не требуется писать свои собственные обработчики событий, так как если обработчик для определенного события написан не будет, то VB IDE спокойно представляет готовый по умолчанию. Хорошим примером этого являются обработчики, которые имеют дело с изменением размера формы. Исходный код для него никогда не показывается в VB, но приложение VB может правильно отреагировать, когда пользователь попытается изменить размер, поскольку VB IDE незаметно добавляет в проект обработчики событий, которые правильно управляют этой ситуацией.

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

Поток выполнения в типичном приложении GUI Windows выглядит примерно следующим образом:

На этой диаграмме рамка с пунктирной границей указывает ту часть исполнимого кода, к которой VB IDE предоставляет программисту доступ и для которого можно писать исходный код,— это несколько обработчиков событий. Остальная часть кода недоступна для программиста, хотя его можно в некоторой степени определить, выбирая тип приложения при запросе к VB на создание проекта. Для нового проекта в VB появляется диалоговое окно, запрашивающее тип приложения, которое требуется создать,— стандартный EXE, ActiveX EXE, ActiveX DLL и т.д. После выбора VB IDE использует его для генерации всего необходимого кода в той части программы, которая находится вне пунктирной рамки на приведенной выше диаграмме. Диаграмма показывает ситуацию, когда выбрано создание проекта стандартного EXE, отличающегося от других типов проектов (например, ActiveX DLL вообще не имеет цикла сообщений, но вместо этого зависит от клиентов в отношении вызова методов), и при этом дается примерное представление о том, что происходит.

Ранее было сказано, что в C# программист получает доступ ко всему коду, теперь необходимо это уточнить: все мельчайшие подробности относительно того, что происходит в цикле сообщений, надежно скрыты внутри различных DLL, которые написала компания Microsoft, но можно видеть методы верхнего уровня, вызывающие различные элементы обработки. Допустим, имеются доступы к коду, который начинает выполнение всей программы, к вызову библиотечного метода, который заставляет программу войти в цикл сообщений и переводит ее в спящее состояние и т.д. Имеется также доступ к исходному коду, создающему экземпляры всех различных элементов управления, которые помещаются на форме, делая эти экземпляры видимыми и определяя их начальные положения, размеры и все остальное. Необходимо отметить еще и тот момент, что не требуется писать никакой подобный код самостоятельно. При использовании Visual Studio.NET для создания проекта C# по-прежнему появляется диалоговое окно, спрашивающее, какой тип проекта необходимо создать, и Visual Studio.NET будет по-прежнему готовить весь базовый код. Различие состоит в том, что Visual Studio.NET записывает этот базовый код, как исходный на C#, который затем можно непосредственно редактировать.

Все это приводит к тому, что исходный код получается более длинным и более сложным. Однако огромное его преимущество заключается в том, что он обеспечивает значительно большую гибкость в том, что делает программа и как она себя ведет. А значит, можно написать намного больше типов проектов в C#. В то время как в Visual Basic возможно написание только различных видов форм и компонентов COM, в C# вы в праве написать любую из различных типов программ, которые выполняются под Windows. Это включает, например, консольные приложения (командной строки) и страницы ASP.NET (наследник ASP), что нельзя написать в VB6 (можно использовать VBScript для страниц ASP). В этом приложении, однако, мы сосредоточимся на классических приложениях GUI для Windows.

В этом разделе будет рассмотрена оставшаяся часть кода для примера

SquareSample

Пример

SquareRoot

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

using System;

using System.Drawing;

using System.Collections;

using System.ComponentModel;

using System.Windows.Forms;

using System.Data;

namespace Wrox.ProfessionalCSharp.AppendixC.SquareRootSample {

 /// <summary>

 /// Form, которая формирует основное окно приложения:

 /// </summary>

 public class SquareRootForm : System.Windows.Forms.Form {

  private System.Windows.Forms.TextBox txtNumber;

  private System.Windows.Forms.TextBox txtSign;

  private System.Windows.Forms.TextBox txtResult;

  private System.Windows.Forms.Button cmdShowResults;

  private System.Windows.Forms.Label label1;

  private System.Windows.Forms.Label label2;

  private System.Windows Forms.Label label3;

  private System.Windows.Forms.Label label4;

  /// <summary>

  /// Необходимые для designer переменные.

  /// </summary>

  private System.ComponentModel.Container components;

  public SquareRootForm() {

   InitializeComponent();

  }

  public override void Dispose() {

   base.Dispose();

   if(components != null) components.Dispose();

  }

#region Windows Form Designer generated code

  /// <summary>

  /// Требуемый для поддержки Designer метод - не изменять

  /// содержимое этого метода с помощью редактора кода.

  /// </summary>

  private void InitializeComponent() {

   this.txtNumber = new System.Windows.Forms.TextBox();

   this.txtSign = new System.Windows.Forms.TextBox();

   this.cmdShowResults = new System.Windows.Forms.Button();

   this.label3 = new System.Windows.Forms.Label();

   this.label4 = new System.Windows.Forms.Label();

   this.label1 = new System.Windows.Forms.Label();

   this.label2 = new System.Windows.Forms.Label();

   this.txtResult = new System.Windows.Forms.TextBox();

   this.SuspendLayout();

   //

   // txtNumber

   //

   this.txtNumber.Location = new System.Drawing.Point(160, 24);

   this.txtNumber.Name = "txtNumber";

   this.txtNumber.TabIndex = 0;

   this.txtNumber.Text = "";

   //

   // txtSign

   //

   this.txtSign.Enabled = false;

   this.txtSign.Location = new System.Drawing.Point(160, 136);

   this.txtSign.Name = "txtSign";

   this.tхtSign.TabIndех = 1;

   this.txtSign.Text = "";

   //

   // cmdShowResults

   //

   this.cmdShowResults.Location = new System.Drawing.Point(24, 96);

   this.cmdShowResults.Name = "cmdShowResults";

   this.cmdShowResults.Size = new System.Drawing.Size(88, 23);

   this.cmdShowResults.TabIndex = 3;

   this.cmdShowResults.Text = "Show Results";

   this.cmdShowResults.Click +=

    new System.EventHandler(this.OnClickShowResults);

   //

   // label3

   //

   this.label3.Location = new System.Drawing.Point(72, 24);

   this.label3.Name = "label3";

   this.label3.Size = new System.Drawing.Size(80, 23);

   this.label3.TabIndex = 6;

   this.label3.Text = "Input a number";

   //

   // label4

   //

   this.label4.Location = new System.Drawing.Point(80, 184);

   this.label4.Name = "label4";

   this.label4.Size = new System.Drawing.Size(80, 16);

   this.label4.TabIndex = 7;

   this.label4.Text = "Square root is";

   //

   // label1

   //

   this.label1.Location = new System.Drawing.Point(112, 136);

   this.label1.Name = "label1";

   this.label1.Size = new System.Drawing.Size(40, 23);

   this.label1.TabIndex = 4;

   this.label1.Text = "Sign is";

   //

   // label2

   //

   this.label2.Location = new System.Drawing.Point(48, 184);

   this.label2.Name = "label2";

   this.label2.Size = new System.Drawing.Size(8, 8);

   this.label2.TabIndex = 5;

   //

   // txtResult

   //

   this.txtResult.Enabled = false;

   this.txtResult.Location = new System.Drawing.Point(160, 184);

   this.txtResult.Name = "txtResult";

   this.txtResult.TabIndex = 2;

   this.txtResult.Text = "";

   //

   // Form1

   //

   this.AutoScaleBaseSize = new System.Drawing.Size(5, 13);

   this.ClientSize = new System.Drawing.Size(292, 269);

   this.Controls.AddRange(new System.Windows.Forms.Control[] {

    this.label4, this.label3, this.label2, this.label1,

    this.cmdShowResults, this.txtResult, this.txtSign, this.txtNumber

   });

   this.Name = "Form1";

   this.Text = "Square Root C# Sample";

   this.ResumeLayout(false);

  }

#endregion

  /// <summary>

  /// Обработчик событий для нажатия пользователем кнопки Show Results

  /// Выводит квадратный корень и знак числа

  /// </summary>

  /// <param name="sender"></param>

  /// <param name="e"></param>

  private void OnClickShowResults(object sender, System.EventArgs e) {

   float NumberInput = float.Parse(this.txtNumber.Text);

   if (NumberInput < 0) {

    this.txtSign.Text = "Negative";

    this.txtResult.Text = Math.Sqrt(-NumberInput) + " i";

   } else if (NumberInput == 0) {

    txtSign.Text = "Zero";

    txtResult.Text = "0";

   } else {

    this.txtSign.Text = "Positive";

    this.txtResult.Text = Math.Sqrt(NumberInput).ToString();

   }

  }

 }

 class MainEntryClass {

  /// <summary>

  /// Основная точка входа приложения.

  /// </summary>

  [STAThread]

  static void Main() {

   SquareRootForm TheMainForm = new SquareRootForm();

   Application.Run(TheMainForm);

  }

 }

}

Основная часть исходного кода

SquareRoot

namespace Wrox.ProfessionalCSharp.AppendixC.SquareRootForm {

 public class SquareRootForm : System.Windows.Forms.Form {

Класс

SquareRootForm

MainEntryClass

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

ReadMe.txt

C:\Program Files\ReadMe.txt

G:\Program Files\HTML Help Workshop\ReadMe.txt

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

SquareRootForm

Wrox.ProfessionalCSharp.AppendixC.SquareRootForm

SquareRootForm

Исключение конфликтов такого рода важно в C#, так как рабочая среда .NET использует только эти имена для идентификации классов, в то время как элементы управления ActiveX, созданные VB, применяют для ухода от конфликтов имен сложный механизм, включающий GUID. Компания Microsoft предпочла более простую концепцию пространств имен в связи с опасениями, что некоторые сложности COM, такие как GUID, сделают неоправданно трудным для разработчиков создание хороших приложений Windows.

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

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

namespace Wrox.ProfessionalCSharp.AppendixC.SquareRootSample {

 public class SquareRootForm : System.Windows.Forms.Form {

  // и т.д.

 }

}

можно было бы записать следующим образом:

namespace Wrox {

 namespace ProfessionalCSharp {

  namespace AppendixC {

   namespace SquareRootSample {

    public class SquareRootForm : System.Windows.Forms.Form {

     // и т.д.

    }

   }

  }

 }

}

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

Конечная часть приведенного выше кода, который начинает проект

SquareRoot

using

using System;

using System.Drawing;

using System.Collections;

using System.ComponentModel;

using System.Windows.Forms;

using System.Data;

namespace Wrox.ProfessionalCSharp.AppendixC.SquareRootSample {

Эти инструкции

using

System.Windows.Forms.TextBox

Text Box

using System.Windows.Forms

TextBox

using

Теперь мы переходим к определению класса

SquareRootForm

public class SquareRootForm : System.Windows.Forms.Form {

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

Form

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

SquareRootForm

Form

Windows.Forms.Form

Form

Form

Height

Width

Desktop Location

BackColor

Если вы знакомы с интерфейсами, то наследование не должно быть для вас новым понятием, так как интерфейсы могут наследоваться друг из друга. Однако здесь имеется значительно более мощная конструкция, чем наследование интерфейсов. Когда интерфейс COM наследуется из другого интерфейса, он получает только имена и сигнатуры методов и свойства. Это, в конце концов, все, что содержит интерфейс. Однако класс содержит весь код, который реализует эти методы, и тому подобное также, как в VB делает объект класса. Это означает, что

SquareRootForm

Form

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

Основной точкой входа в программу является функция

Main()

class MainEntryClass {

 /// <summary>

 /// Основная точка входа приложения.

 /// </summary>

 [STAThread]

 static void Main() {

  SquareRootForm TheMainForm = new SquareRootForm();

  Application.Run(TheMainForm);

 }

}

Это не очевидная точка входа в программу, но это — она. Правило в C# говорит, что выполнение программы начинается с метода с именем

Main()

Main()

void

Как упоминалось раже, код VB может иметь метод

Main()

, но он редко используется и не является обязательным. В C# метод

Main()

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

Так как метод

Main()

MainEntryClass

Main()

Main()

Помимо ключевого слова

static

Main()

[STAThread]

[STAThread]

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

[STAThread]

Давайте теперь рассмотрим код внутри метода

Main()

SquareRootForm

SquareRootForm TheMainForm = new SquareRootForm();

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

Dim SomeDialog As MyDialogClass

Set SomeDialog = New MyDialogClass

В этом коде VB сначала объявляется переменная, которая является объектной ссылкой —

SomeDialog

MyDialogClass

New

Это совпадает с тем, что происходит в коде C#: объявляется переменная с именем

TheMainForm

SquareRootForm

new

SquareRootForm

NumberInput

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

Main()

Nothing

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

Nothing

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

Но если желательно задать ссылочную переменную, которая ни на что не указывает, то соответствующим ключевым словом C# является

null

Nothing

Set SomeDialog = Nothing;

в C# будет написано:

TheMainForm = null;

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

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

Application.Run(TheMainForm);

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

Run()

System.Windows.Forms.Application

Run()

Run()

Когда метод

Run()

Main()

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

Run()

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

Мы видели, как C# запускает цикл сообщений, но мы еще не изучили процесс вывода и создания самой формы. Мы также не определились с вопросом о вызове обработчиков событий. Упоминалось, что Windows вызывает такие обработчики событий, как метод

OnClickButtonResults()

SquareRootForm

Form

Отметим сначала, что класс

SquareRootForm

public class SquareRootForm : System.Windows.Forms.Form {

 private System.Windows.Forms.TextBox txtNumber;

 private System.Windows.Forms.TextBox txtSign;

 private System.Windows.Forms.TextBox txtResult;

 private System.Windows.Forms.Button cmdShowResults;

 private System.Windows.Forms.Label label1;

 private System.Windows.Forms.Label label2;

 private System.Windows.Forms.Label label3;

 private System.Windows.Forms.Label label4;

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

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

Form_Load()

Form_Initialize()

Class_Load()

Class_Initialize()

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

SquareRootForm

public SquareRootForm() {

 InitializeComponent();

}

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

new

Employee

В данном случае конструктор просто вызывает метод

InitializeComponent()

InitializeComponent()

InitializeComponent()

private void InitializeComponent() {

 this.txtNumber = new System.Windows.Forms.TextBox();

 this.txtSign = new System.Windows.Forms.TextBox();

 this.cmdShowResults = new System.Windows.Forms.Button();

 this.label3 = new System.Windows.Forms.Label();

 this.label4 = new System.Windows.Forms.Label();

 this.label1 = new System.Windows.Forms.Label();

 this.label2 = new System.Windows.Forms.Label();

 this.txtResult = new System.Windows.Forms.TextBox();

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

 //

 // txtNumber

 //

 this.txtNumber.Location = new System.Drawing.Point(160, 24);

 this.txtNumber.Name = "txtNumber";

 this.txtNumber.TabIndex = 0; this.txtNumber.Text = "";

 //

 // txtSign

 //

 this.txtSign.Enabled = false;

 this.txtSign.Location = new System.Drawing.Point(160, 136);

 this.txtSign.Name = "txtSign";

 this.txtSign.TabIndex = 1;

 this.txtSign.Text = "";

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

Point

Point

TextBox.Location

Point

Point

Point

Point

Dim Location As Point

Set Location = New Point

Location.X = 160

Location.Y = 24

SomeObject.Location = Location

Это сравнимо со следующим кодом на C#:

someObject.Location = new System.Drawing.Point(160, 24);

Относительная компактность эквивалентной инструкции C# должна быть очевидна.

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

 this.cmdShowResults.Name = "cmdShowResults";

 this.cmdShowResults.Size = new System.Drawing.Size(88, 23);

 this.cmdShowResults.TabIndex = 3;

 this.cmdShowResults.Text = "Show Results";

 this.cmdShowResults.Click +=

  new System.EventHandler(this.OnClickShowResults);

Здесь происходит следующее. Кнопка, обозначенная как объект кнопки

cmdShowResults

Click

new System.EventHandler()

+=

Символ

+=

В = В + А

В C# можно записать похожим образом:

В = В + А;

Однако в C# для этого существует альтернативная сокращенная запись:

B += А;

+=

*=

/=

-=

B /= 2;

Хотя в этом приложении не рассматриваются подробности, но C# имеет другие операторы, представляющие побитовые операции, а также дающие остаток при делении, и почти все они имеют соответствующие операторы операция-присваивание (см. главу 3).

В примере

SquareRootForm

this.cmdShowResults.Click +=

 new SyBtem.EventHandler(this.OnClickShowResults)

означает: "добавить этот обработчик к событию". Может быть немного удивительным увидеть оператор, подобный

+=

int

float

Операторы, подобные

+

,

*

и т.д. в VB действительно имеют значение, только когда применяются к числовым данным. Но в C# они могут применяться к объектам любого типа.

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

Dim V1 As Vector

Set V1 = New Vector

В математике векторы можно складывать, что будет обеспечено с помощью перезагрузки операторов. Но VB6 не поддерживает перезагрузку, поэтому вместо этого в VB6 вероятно придется определить метод Add для Vector, и, таким образом, сделать следующее:

' V1, V2 и V3 являются векторами

Set V3 = V1. Add(V2)

В VB это лучшее, что можно придумать. Однако в C#, если определить класс

Vector

+

operator+

+

Vector

// V1, V2 и V3 являются векторами

V3 = V1 + V2;

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

+

+=

-

-=

Мы получили максимум возможного из рассмотрения примеров

SquareRootForm

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

Однако мы пока еще не видели реального примера некоторого кода, который можно написать на C#, но крайне трудно создать код, делающий то же самое на VB. Мы собираемся рассмотреть такой пример в следующем разделе, где будут с помощью некоторых классов проиллюстрированы возможности наследования.

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

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

Employee

EmployeeName

Salary

GetMonthlyPayment()

' локальные переменные для хранения значений свойств

Private mStrEmployeeName As String ' локальная копия

Private mCurSalary As Currency ' локальная копия

Public Property Let Salary(ByVal curData As Currency)

 mCurSalary = curData

End Property

Public Property Get Salary() As Currency

 Salary = mCurSalary

End Property

Public Property Get EmployeeName() As String

 EmployeeName = mStrEmployeeName

End Property

Public Sub Create(sEmployeeName As String, curSalary As Currency)

 mStrEmployeeName = sEmployeeName

 mCurSalary = curSalary

End Sub

Public Function GetMonthlyPayment() As Currency

 GetMonthlyPayment = mCurSalary/12

End Function

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

EmployeeName

Create

Dim Britney As Employee

Set Britney = New Employee

Britney.Create "Britney Spears", 20000

Эта схема работает, но она не очень удобна. Проблема с инициализацией объекта

Employee

Class_Load

Class_Initialize

Class_Load

Employee

Create

Employee

Britney

Create

В C# ситуация совершенно другая. Здесь в конструкторы можно подставлять параметры (эквивалент в C# для метода

Class_Load

Employee

Name

Salary

Employee Britney = new Employee("Britney Spears", 20000.00M);

что значительно изящнее и менее подвержено ошибкам. Отметим кстати символ "

М

Currency

M

decimal

Помня о приведенных выше замечаниях можно теперь представить первое определение версии C# класса

Employee

class Employee {

 private readonly string name;

 private decimal salary;

 public Employee(string name, decimal salary) {

  this.name = name;

  this.salary = salary;

 }

 public string Name {

  get {

   return name;

  }

 }

 public virtual decimal Salary {

  get {

   return salary;

  }

  set {

   salary = value;

  }

 }

 public decimal GetMonthlyPayment() {

  return salary/12;

 }

 public override string ToString() {

  return "Name: " + name + ", Salary: $" + salary.ToString();

 }

}

Просматривая этот код, мы видим сначала пару закрытых переменных — так называемых полей-членов, соответствующих переменным-членам в модуле класса VB. Поле

name

readonly

Employee

name

salary

mStrEmployeeName

mCurSalary

mStr

mCur

В классе

Employee

Name

Salary

GetMonthlyPayment()

ToString()

Отметим кстати, что имена свойств

Name

и

Salary

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

После объявления полей в приведенном выше коде располагается "метод", имя которого —

Employee

Create

public Employee(string name, decimal salary) {

 this.name = name;

 this.salary = salary;

}

Существует потенциальная синтаксическая проблема, так как явные имена параметров совпадают с именами полей —

name

salary

this

Теперь можно объяснить точное значение квалификатора

readonly

private readonly string name;

Если поле помечено как

readonly

readonly

Между прочим этот конструктор не просто позволяет задать параметры для инициализации объекта

Employee

Employee Britney = new Employee; // неправильно

то он на самом деле не откомпилируется. Компилятор будет инициировать ошибку, так как в C# должен всегда вызываться конструктор, когда создается новый объект. Но никаких параметров задано не было, а единственный доступный конструктор требует двух параметров. Поэтому просто невозможно создать объект

Employee

Employee

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

Теперь мы переходим к свойствам

Name

Salary

public decimal Salary {

 get {

  return salary;

 }

 set {

  salary = value;

 }

}

В VB компилятор знает, что определяется свойство, так как используется ключевое слово

Property

Еще один момент, на который необходимо обратить внимание, состоит в том, что определения методов доступа

get

set

Salary

get

set

void

set

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

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

set

Name

public string Name {

 get {

  return name;

 }

}

В классе

Employee

GetMonthlySalary()

ToString()

GetMonthlySalary()

public decimal GetMonthlyPayment() {

 return salary/12;

}

Единственным новым элементом синтаксиса здесь является инструкция

return

GetMonthlyPayment = mCurSalary/12

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

return

return

return salary/12;

эквивалентна в действительности следующему коду VB:

GetMonthlyPayment = mCurSalary/12

Exit Function

Метод

ToString()

ToString()

ToString()

System.Object

System.Object

int

float

publiс override string ToString() {

 return Name: " + name + ", Salary: $" + salary.ToString();

}

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

override

Мы завершили пример класса

Employee

Employee

Мы упоминали несколько раз, что в C# классы имеют специальные методы, называемые статическими, которые можно вызвать, не создавая экземпляр объекта. Эти методы не имеют никакой аналогии в VB. Фактически, статическими могут быть не только методы, но и поля, свойства или любые другие члены класса.

Термин статический имеет совершенно другое значение в C#, чем в VB.

Чтобы проиллюстрировать, как работают статические члены и почему их необходимо использовать, давайте представим себе, что мы хотели бы, чтобы класс Employee поддерживал извлечение названия (имени) компании, в которой работает каждый сотрудник. Здесь имеется существенное различие между названием компании и именем сотрудника, так как каждый объект сотрудника представляет обособленную единицу, и поэтому необходимо хранить различные имена сотрудников. Это обычное поведение переменных модулей классов в VB и поведение по умолчанию полей в C#. Но если организация купила программное обеспечение, которое содержит класс

Employee

class Employee {

 private string name;

 private decimal salary;

 private static readonly string companyName;

В этом коде объявлено еще одно поле, но, помечая его как

static

Employee

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

Конечно, одного объявления этого поля не достаточно. Необходимо также убедиться, что оно инициализируется правильными данными. Где это нужно сделать? Ясно, что не в конструкторе — конструктор вызывается всякий раз при создании объекта

Employee

companyName

Employee

static Employee {

 companyName = "Wrox Press Pop Stars";

}

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

static

public

private

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

public static string сompanyName {

 get {

  return companyName;

 }

}

Свойство

companyName

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

string Company = Employee.CompanyName;

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

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

□ Возможная реализация свойства

MaximumLength

Employee

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

int

float

int MaxIntValue = int.MaxValue;

float MaxFloatValue = float.MaxValue;

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

GetMonthlyPayment()

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

Как можно при создании кода в VB обновить наше приложение? Существуют два возможных подхода, но оба они имеют серьезные недостатки. Можно:

□ Написать новый класс

Manager

□ Изменить класс

Employee

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

Employee

Employee

Manager

Name

CompanyName

Salary

Employee

Manager

Employee

Manager

Альтернативным способом является написание класса

Manager

Employee

objManager.objEmployее.Name

Если выбрать модификацию модуля класса сотрудника, то по-видимому надо добавить дополнительное поле типа

Boolean

Employee

Boolean

if

Employee

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

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

SquareRootForm

System.Windows.Forms.Form

SquareRootForm

Employee

Manager

Employee

GetMonthlyPayment()

ToString()

Employee

Прежде чем определить класс

Manager()

Employee

public virtual decimal GetMonthlyPayment() {

 return salary/12;

}

что сделает метод

GetMonthlyPayment()

virtual

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

virtual

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

GetMonthlyPayment()

почти наверняка объявлялся бы виртуальным, поэтому на самом деле можно добавить класс

Manager

, не делая никаких изменений в классе

Employee

.

Теперь можно определить класс

Manager()

class Manager : Employee {

 private decimal bonus;

 public Manager(string name, decimal salary, decimal bonus) : base(name, salary) {

  this.bonus = bonus;

 }

 public Manager(string name, decimal salary) : this(name, salary, 100000M) {

 }

 public decimal Bonus {

  get {

   return bonus;

  }

 }

 public override string ToString() {

  return base.ToStrint() + ", bonus: " + bonus;

 }

 public override decimal GetMonthlyPayment() {

  return base.GetMonthlyPayment() + bonus/12;

 }

}

Помимо почти завершенной реализации класса

Employee

Manager

□ Поле

bonus

□ Перезагруженный метод

GetMonthlyPayment()

ToString()

□ Два конструктора.

Поле

bonus

Bonus

Переопределенная версия метода

GetMonthlyPayment()

override

Employee.ToString()

public override decimal GetMonthlyPayment() {

 return base.GetMonthlyPayment() + bonus/12;

}

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

base

base

this

GetMonthlyPayment()

public override decimal GetMonthlyPayment() {

 return (Salary + bonus)/12;

}

но, чтобы показать использование ключевого слова

base

public override decimal GetMonthlyPayment() {

 return (salary + bonus)/12; // неправильно

}

Код выглядит почти так же, как предыдущая версия, кроме того, что поле

salary

Salary

salary

private

Employee

Если необходимо, чтобы производные, но не связанные классы могли видеть поле, C# предоставит альтернативный уровень защиты

protected

protected decimal salary; // можно сделать так

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

private

protected

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

Manager

□ Существует дополнительный элемент информации — бонус менеджера, который необходимо определить, когда создается экземпляр объекта

Manager

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

Фактически было добавлено два конструктора. Это связано с решением, что бонус менеджера обычно по умолчанию равен $100000, если он не определен явно. В VB можно определить в методах параметры по умолчанию, но C# не разрешает делать это напрямую. Вместо этого C# предлагает более мощную технику — перезагрузку методов, которая дает тот же результат. Определение в данном случае двух конструкторов позволяет проиллюстрировать эту технику.

Первый конструктор Manager имеет три параметра:

public Manager(string name, decimal salary, decimal bonus) : base(name, salary) {

 this.bonus = bonus;

}

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

base

this

Показанный выше конструктор получает три параметра. Однако два из них —

name

salary

Employee

Employee

Manager

Employee

base(name, salary)

Employee

name

salary

bonus

Manager

bonus

Manager

public Manager(string name, decimal salary) : this(name salary, 100000M) {

}

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

name

salary

public Manager(string name, decimal salary) : base(name, salary) // не очень хорошо

{

 this.bonus = 100000M;

}

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

bonus

Manager

bonus

Тот факт, что для класса Manager было предоставлено два конструктора, иллюстрирует принцип перезагрузки методов в C#, в соответствии с которым предполагается, что класс имеет более одного метода с одним именем, но эти методы имеют различное число параметров. Мы продемонстрировали перезагрузку конструкторов, но точно такие же принципы применимы ко всем методам.

Не путайте термины перезагрузка и переопределение методов. Это различные и никак не связанные концепции.

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

Manager SomeManager = new Manager("Name", 300000.00M);

компилятор будет использовать для создания экземпляра объекта  

Manager

Manager SomeManager = new Manager("Name", 300000.00М, 50000.00М);

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

Manager SomeManager = new Manager(100, 300000.00М, 50000.00М); // неправильно

то будет получена ошибка компиляции, так как оба доступных конструктора

Manager

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

Теперь, когда завершено определение классов

Employee

Manager

SampleRoot

MainForm

Employee

Manager

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

public MainForm() {

 InitializeComponent();

 Employee Britney = new Employee("Britney Spearse", 20000.00M);

 Employee Elton = new Manager("Elton John", 50000.00M);

 Manager Ginder = new Hanager("Geri Halliwell", 50000.00M, 20000.00M);

 this.listBox1.Items.Add("Elton's name is $" + Elton.Name);

 this.listBox1.Items.Add("Elton's salary is $" + Elton.Salary);

 this.listBox1.Items.Add("Elton's bonus is " + ((Manager)Elton).Bonus);

 this.listBox1.Items.Add("Elton's monthly payment is $" + Elton.GetMonthlyPayment());

 this.listBox1.Items.Add("Elton's Company is " + Employee.CompanyName);

 this.listBox1.Items.Add("Elton.ToString() : " + Elton.ToString());

 this.listBox1.Items.Add("Britney.ToString(): " + Britney.ToString());

 this.listBox1.Items.Add("Ginger.ToString(): " + Ginger.ToString());

}

Этот код должен быть вполне понятен, так как использует элементы C#, с которыми мы уже знакомы, за исключением одной небольшой странности — один из объектов

Manager

Employee

Manager

Подробнее рассмотрим класс

Manager

Employee

Employee Elton = new Manager("Elton John", 50000.00M);

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

Elton.Name

Elton.Salary

Elton.GetMonthlyPayment()

Employee

Employee

С другой стороны, отметим синтаксис, который использовался при вызове свойства

Bonus

Elton

((Manager)Elton).Bonus

Elton

Manager

Bonus

Employee

Bonus

Employee

Manager ManagerElton = (Manager)Elton;

this.listBox1.Items.Add("Elton's bonus is " + ManagerElton.Bonus);

Как и в VB, преобразование между типами данных в C# называется преобразованием типов (

casting

Manager ManagerBritney = (Manager)Britney;

то код будет компилироваться правильно, но при его работе будет получена ошибка, так как среда выполнения .NET определит, что

Britney

Employee

Manager

Manager

Employee

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

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

Employee

Manager

IEmployee

Employee

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

Мы не видели еще, как C# работает с массивами, поэтому перепишем код классов

Employee

Manager

EmployeeMaragerWithArrays

public MainForm() {

 InitializeComponent();

 Employee Britney = new Employee("Britney Spears", 20000.00M);

 Employee Elton = new Manager("Elton John", 50000.00M);

 Manager Ginger = new Manager("Geri Halliwell", 50000.00M, 20000.00M);

 Employee[] Employees = new Employee[3];

 Employees[0] = Britney;

 Employees[1] = Elton;

 Employees[2] = Ginger;

 for (int I = 0; I < 3; I++) {

  this.listBox1.Items.Add(Employees[I].Name);

  this.listBox1.Items.Add(Employees[I].ToString());

  this.listBox1.Items.Add("");

 }

}

Мы вызываем свойство

Name

ToString()

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

Employee[] Employees = new Employee[3];

Мы видим, что массив переменных некоторого тип объявляют, помещая квадратные скобки после имени типа. Массив в C# всегда считается ссылочным объектом (даже если его элементы являются простыми типами, как

int

double

Employee[] Employees;

Employees = new Employee[3];

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

double

double [,] DoubleArray = new double[3, 4];

Есть и другие несущественные различия в синтаксисе объявления массивов, но мы будем придерживаться приведенных здесь правил. Когда имеется массив, то значения его элементам присваиваются обычным образом. Отметим, однако, одно различие между C# и VB, состоящее в том, что C# всегда начинает с элемента с индексом 0. В VB имеется возможность изменить его на индекс 1, используя инструкцию

Option Base

В приведенном выше коде после инициализации элементов массива мы перебираем их в цикле. Необычный синтаксис цикла

for

Отметим, что поскольку массив был объявлен как массив объектов

Employee

Employee

Bonus

Manager

С другой стороны, хотя используются ссылки

Employee

ToString()

Manager

ToString()

ToString()

Manager

Давайте теперь рассмотрим странный синтаксис цикла

for

Integer I

For I = 1 То 3

 listBox1.Items.Add "Details of the Employee"

Next

Идея цикла

For

Step

В C# цикл

for

for

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

for

For

Foreach

Do

While

for

Надо отметить, что C# поддерживает также циклы

foreach

,

do

и

while

для соответствующих ситуаций.

Давайте вернемся к точному синтаксису. Вспомним, что версия C# для приведенного выше цикла

for

for (int I = 0; I < 3; I++) {

 this.listBox1.Items.Add(Employees[I].Name);

 this.listBox1.Items.Add(Employees[I].ToString());

 this.listBox1.Items.Add("");

}

Как можно видеть, инструкция

for

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

□ Следующим элементом является условие, определяющее завершение цикла. В данном случае условие состоит в том, что I должно быть меньше 3. Цикл продолжается, пока это условие будет

true

false

false

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

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

for

for (int I = 2; I < 4000; I *= 2)

 listBox1.Items.Add(I.ToString());

Такой результат можно получить и в VB, но немного труднее. Для этого конкретного цикла в VB лучше воспользоваться циклом

while

Мы закончили рассмотрение примеров. Оставшаяся часть приложения кратко рассматривает несколько свойств C#, о которых необходимо знать при выполнении перехода от VB к C#, и которые еще не рассматривались, в частности, некоторые из концепций C#, связанные с типами данных и операторами.

Как указывалось ранее, доступные в C# типы данных отличаются от типов данных, доступных в Visual Basic, лишь деталями. Но не только это, все типы данных в C# имеют свойства, которые обычно связываются с объектами. Например, как мы видели, каждый тип данных, даже простые типы, такие как

int

float

Хотя типы данных, доступные в C#, слегка отличаются от типов данных в VB, все же большинство типов данных, знакомые из VB, имеют непосредственные эквиваленты в C#. Например, вместо

Double

double

Date

DateTime

Одним исключением является

Variant

Variant

Variant

object

object

Object

Object

Integer

Single

object

int

float

object

Variant

В Visual Basic существует четкое различие между типами данных значений и ссылочными типами данных. Типы данных значений включают большинство предопределенных типов данных:

Integer

Single

Double

Variant

Variant

int

long

float

double

ToString()

string

Необходимо сказать несколько слов об операторах в C#, так как они действуют несколько иным образом по сравнению с операторами VB, и это может внести путаницу, если программист привык работать с VB. В VB существует на самом деле два типа операторов:

□ Оператор присваивания

=

□ Все другие операторы:

+

-

*

/

Здесь существует важное различие в том, что ни один из операторов, кроме

=

=

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

+=

int А = 5, В = 15;

А += В; // выполняет арифметическую операцию

        // и присваивает А результат (20)

Таким образом,

+=

int А = 5, B = 15;

int C = (А+=В);

Это в результате приведет в тому, что и

А

С

=

С = (А = В);

Этот код задает

А

В

С

С = А = В;

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

if

bool

Boolean

// предположим, что X и Y — переменные, которые были инициализированы.

bool В;

if (В = (X==Y)) DoSomething();

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

X == Y

X

Y

true

false

В

В = (X==Y)

true

false

if

DoSometning()

X == Y

В

В этом приложении нет места для обсуждения всех доступных в C# операторов. Они подробно рассмотрены в главах 3-6. Однако упомянем тернарный оператор (известный также как условный оператор), так как он имеет очень необычный синтаксис. Тернарный оператор формируется из двух символов —

?

:

If

// В, X и Y являются некоторыми переменными или выражениями.

// В является Boolean.

B ? X : Y

и работает так: оценивается первое выражение, которое расположено перед символом

?

true

false

int Z = (Х==Y) ? 5 : 8;

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

int Z;

if (X==Y) Z = 5;

else Z = 8;

В этом приложении было представлено краткое введение в C# с точки зрения сравнения его с Visual Basic. Мы обнаружили довольно мало различий в синтаксисе. В целом синтаксис C# позволяет выразить большинство инструкций более компактным образом. Также можно заметить большое сходство между языками, например в их использовании классов (или модулей классов в VB), типов данных значений, ссылочных типов данных и многих синтаксических структур. Однако C# поддерживает также многие мощные свойства, в частности связанные с наследованием и классическим объектно-ориентированным программированием, которые недоступны в VB.

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