Глава II. Въведение в C#

Необходими знания

- Добро познаване на поне един език за програмиране от високо ниво (С, С++, Java, Pascal/Delphi, Perl, Python, PHP или друг)

- Базови познания за архитектурата на .NET Framework
Съдържание

- Принципи при дизайна на езика

- Нашата първа програма на C#

- Типове данни в C#. Примитивни типове данни. Изброен тип

- Декларации. Изрази. Оператори. Програмни конструкции

- Елементарни програмни конструкции. Съставни конструкции

- Конструкции за управление – условни конструкции, конструкции за цикъл, конструкции за преход. Специални конструкции

- Коментари в програмата

- Вход и изход от конзолата

- Дебъгерът на Visual Studio .NET

- XML документация в C# кода
В тази тема...

В настоящата тема ще разгледаме езика С#, ще се запознаем с неговите основни концепции, ще напишем и компилираме първата си C# програма. Ще се запознаем със средата за разработка Visual Studio .NET 2003 и ще демон­стрираме работата с нейния дебъгер. Ще отделим внимание на типовете данни, изразите, програм­ните конструкции и конструкциите за управ­ление в езика C#. Накрая ще демонстри­раме колко лесно и полезно е XML доку­ментирането на кода в С#.

Настоящата тема има за цел да запознае читателя с конкретните синтак­тични правила на езика C# и неговите програмни конструкции без да претендира за изчерпателност. В нея няма да обясняваме какво е промен­лива, функция, цикъл и т. н., а ще се фокусираме върху реализацията на тези езикови примитиви в C#. Очаква се читателят да владее основите на програ­мирането с поне един език от високо ниво, а тази тема ще му помогне да премине към C#.

Какво е C#

С# е съвременен, обектно-ориентиран и типово обезопасен език за прог­рамиране, който е наследник на C и С++. Той комбинира леснотата на използване на Java с мощността на С++.

Създаден от екипа на Андерс Хейлсбърг, архитектът на Delphi, С# заим­ства много от силните страни на Delphi – свойства, индексатори, компо­нентна ориентираност. С# въвежда и нови концепции – разделяне на типовете на два вида – стойностни (value types) и референтни (reference types), автоматично управление на паметта, делегати и събития, атрибути, XML документация и други. Той е стандартизиран от ECMA и ISO.

C# е специално проектиран за .NET Framework и е съобразен с неговите особености. Той е сравнително нов, съвременен език, който е заимствал силните страни на масово използваните езици за програмиране от високо ниво, като C, C++, Java, Delphi, PHP и др.
Принципи при дизайна на езика C#

Преди да се запознаем със синтаксиса и програмните конструкции в C#, нека първо разгледаме основните принципи, залегнали при проектира­нето му.
Компонентно-ориентиран

Езикът C# е насочен към компонентно-ориентираното програмиране, при което софтуерът се изгражда чрез съединяване на различни готови компо­ненти и описание на логиката на взаимодействие между тях.

При проектирането на .NET Framework и езика C# компо­нент­ният подход е залегнал на най-дълбоко архитектурно ниво. .NET Framework дефинира общ компонентен модел, който установява правилата за изграждане и използване на компоненти за всички .NET приложения. Езикът C# под­държа класове, интерфейси, свойства, събития и други средства за описа­ние на компонентите, както и средства за тяхното използване. В темата "Графичен потребителски интерфейс с Windows Forms" ще дискутираме по-задълбочено компонентния модел на .NET Framework.
Всички данни са обекти

С# е обектно-ориентиран език за програмиране. В него залягат основните принципи на обектно-ориентираното програмиране, като капсулация на данните, наследяване и полиморфизъм.

В .NET Framework всички типове данни наследяват системния тип System. Object и придобиват от него някои общи методи, свойства и други харак­теристики.

В следствие на това в C# всички данни се третират като обекти. Дори примитивните типове, чрез въвеждането на автоматичното им опако­ване (boxing) и разопако­ване (unboxing) се превръщат в обекти. Напри­мер, 5.ToString() е валид­но извикване в C#, защото 5 се опакова и се раз­глежда като обект от тип System.Object, на който се извиква метода ToString().
Сигурност и надеждност на кода

По идея .NET Framework и C# са проектирани за да осигурят висока сигурност и надеждност на изпълнявания софтуер. .NET Framework предо­ставя среда за контролирано изпълнение на управляван код, с което прави невъзможно възникването на някои от най-неприятните проблеми, свързани с управлението на паметта, неправилното преобразуване на типове и др. C# наследява всички тези характеристики от .NET Framework и добавя към тях някои допълнителни механизми за предпазване на програ­мистите от често срещани грешки.
Силна типизираност и типова безопасност

С# е силно типизиран и типово обезопасен. В него не се използват указа­тели към паметта, които създават много проблеми в по-старите езици за програмиране. Вместо тях се използват специални силно типизирани ука­затели, които се наричат референции (references). Използването на референции вместо указатели решава проблемите, които възникват от неправилната работа с указатели и директния достъп до паметта. В .NET Framework управлението на паметта се извършва почти изцяло от CLR.

Всъщност в C# може да се използват указатели (като тези в C и C++) чрез запазената дума unsafe, но това не е се препоръчва в масовия случай, защото лишава програмата от типова обезопасеност и позволява непра­вилна работа с паметта.

В С# не може да се излезе от границите на масив или символен низ. При опит да бъде направено това, се получава изключение, което може да бъде прихванато и обработено. В езици като C, C++ и Pascal излизането от границите на масив води до достъп до памет, използвана от други данни и най-често пъти предизвиква сривове или неочаквано поведение на програмата.

При създаване на клас, структура или друг тип C# компилаторът не позволява да останат неиници­ализирани член-данни. Това защитава прог­рамиста от възможността да работи с неинициализирани данни.

Макар С# да не инициализира авто­матично локалните променливи, ком­пилаторът предупреждава за непра­вилното им използване. Например следният код ще предизвика грешка при опит за компилация:



Преобразуването на типове също е безопасно. CLR не позволява да се извърши невалидно преобразуване на типове – да се преобразува про­менлива от даден тип към променлива от тип, който не е съвместим с първия. При опит да бъде направено това, възниква изключение.

Неявното преобразуване на типове е разрешено само за съвместими ти­пове, когато не е възможна загуба на информация. При явно преобразу­ване на типове, ако те не са съвместими, се хвърля InvalidCastException по време на изпълнение. Например следният код предизвиква изключение по време на изпълнение:



Безопасност на аритметичните операции

В C# чрез запазената дума checked могат да се отделят блокове код, в които аритметичните операции се проверяват за препълване на типовете и ако това се случи, се хвърля OverflowException. Това е много полезно, защото за разлика от С++, където при такива ситуации се получава грешен резултат, в С# може да се реагира адекватно на такава специфична ситуация. Ето един пример, при който CLR засича препълване на типа int:



Експлицитно задаване на виртуални методи и припокриване на метод

Една от целите на езика C# е да позволи с малко усилия да се пише надежден код. С цел да се намалят грешките от припокриване на виртуални методи са въведени запазените думи new и override, чрез които да се контролира припокриването на виртуален метод, който е в базов клас при наследяване. Каква е разликата между двете? При полиморфизъм (обект от базовия клас е създаден като обект от наследника), ако е използвана new като модификатор на метода в наследника, ще се извика функцията на базовия клас, а при използване на override – функцията на наследника.
Автоматично управление на паметта и ресурсите

В .NET Framework заделянето и използването на паметта се управлява автоматично от CLR (Common Language Runtime). Стойностните типове, които ще разгледаме по-подробно в темата "Обща система от типове", се пазят в стека, докато референтните – в т. нар. "динамична памет" (managed heap), за която се грижи системата за почистване на паметта (garbage collector).

Системата за почистване на паметта е част от CLR и нейна задача е да освобождава периодично паметта и ресурсите, заделени за обекти, които не се използват повече от приложението. Такива обекти могат да бъдат най-разнообразни: данни в динамичната памет, масиви, символни низове, а също и файлове, буфери в паметта, връзки към бази данни и др.

Грижата за паметта е трудна и сложна задача, но благодарение на CLR тя не е задължение на .NET програмистите. На нея ще обърнем специално внимание в темата "Управление на паметта и ресурсите".
Широко използване на изключения

Обработката на грешки, които могат да възникнат по време на изпъл­нение на програмата, в .NET Framework се реализира чрез използване на изключения. Механизмът на изключенията позволява да се съобщи за възникнал проблем или неочаквана ситуация и за нея да може да се реа­гира адекватно.

Изключенията представляват обекти от клас Exception или производен на него клас и съдържат информация за възникналата грешка. Напри­мер, при опит за деление на нула CLR прихваща проблема и предизвиква изключението DivideByZeroException, а при опит за излизане от грани­ците на масив възниква ArgumentOutOfRangeException. Работата с изклю­чения също ще бъде дис­кутирана в детайли в темата "Управление на изключенията в .NET".
Вградени механизми за сигурност на кода

В .NET Framework са въведени т. нар. сигурност на ниво достъп до кода (code access security) и сигурност, базирана на роли (role-based security). Чрез тях се осъществява контрол на достъпа до ресурси от програмата. Например, ако трябва да се извика системна функция или да се пише във файл, кодът трябва да има права да го направи. Сигурността на ниво достъп до кода оставя CLR да взима решения, докато при сигурност, базирана на роли, програмата може да реагира различно спрямо ролята и правата на потребителя.
Всичкият код е на едно място

В С# няма разделяне на хедър файлове и файлове с имплементация, както в C и C++. Това спестява много проблеми и улеснява поддръжката на сорс кода. В C# всичкият програмен код на даден клас е в един файл.
Програмите на C#

Програмите на С# представляват съвкупност от дефиниции на класове, структури и други типове. Във всяка C# програма някой от класовете съдържа метод Main() – входна точка за програмата.

Приложенията могат да се състоят от много файлове, а в един файл може да има няколко класове, структури и други типове.

Класовете логически се разполагат в пространства от имена (namespa­ces). Те от своя страна могат да се систематизират в йерархия, т.е. едно пространство от имена може да съдържа както класове, така и други пространства от имена. Едно пространство от имена може да е разположе­но в няколко файла и дори в няколко асемблита. Например, в простран­ството от имена System се съдържа пространството от имена Xml. Прост­ранството System.Xml от своя страна е разделено в две различни асем­блита - System.Xml.dll и System.Data.dll.

Във Visual Studio .NET има инструмент, наречен "Object Browser", чрез който могат да се разгледат йерархиите на пространствата от имена в проекта, какво съдържат те и в кои файлове се намират.
Нашата първа програма на C#

Всяка книга за запознаване с даден програмен език започва обикновено с програмката "Hello, world!". Ние няма да правим изключение от този принцип и ще започнем по подобен начин – с програмката "Hello, C#". Ето как изглежда нейният сорс код:

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

Идентификаторите в С# се състоят от последователности от букви, цифри и знак за подчертаване като винаги започват с буква или знак за подчер­таване. В тях малките и главните букви се различават. Иденти­фикаторите могат да съдържат Unicode символи, например:



Microsoft препоръчва се следната конвенция за именуване:

- PascalCase – за имена на класове, пространства от имена, структури, типове, методи, свойства, константи

- camelCase – за имена на променливи и параметри

Въпреки, че е възможно, не се препоръчва да се използват идентифика­тори на кирилица или друга азбука, различна от латинската.

Декларации

Декларациите на променливи в C# могат да са няколко вида (почти като в C++, Java и Delphi) – локални променливи (за даден блок), член-промен­ливи на типа и константи. Ето пример:



Член-променливите могат да имат модификатори, например:



Константи

Константите в С# биват два вида – константи, които приемат стойността си по време на компилация (compile-time константи) и такива, които получават стойност по време на изпълнение на програмата (runtime константи).
Compile-time константи

Compile-time константите се декларират със запазената дума const. Те задължително се инициализират в момента на декларирането им и не могат да се променят след това. Те реално не съществуват като промен­ливи в програмата. По време на компилация се заместват със стойността им. Например:



Runtime константи

Runtime константите се декларират като полета с модификатора readonly. Представляват полета на типа, които са само за четене. Инициализират се по време на изпълнение (в момента на деклариране или в конструктора на типа) и не могат да се променят след като веднъж са инициализирани. Например:



Оператори

Операторите в С# са много близки до операторите в C++ и Java и имат същите действие и приоритет. Те биват:

- Аритметични: +, -, *, /, %, ++, --

- Логически: &&, ||, !, ^, true, false

- Побитови операции: &, |, ^, ~, <<, >>

- За слепване на символни низове: +

- За сравнение: ==, !=, <, >, <=, >=

- За присвояване: =, +=, -=, *=, /=, %=, &=, |=, ^=, <<=, >>=

- За работа с типове: as, is, sizeof, typeof

- Други: ., [], (), ?:, new, checked, unchecked, unsafe

В C# операторите могат да се предефинират. В темата "Обектно-ориенти­рано програмиране в .NET" ще видим как точно става това.
Изрази (expressions)

Програмен код, който се изчислява до някаква стойност, се нарича израз (expression). Изразите в C# имат синтаксиса на C++ и Java. Например:



Програмни конструкции (statements)

Програмните конструкции (statements) имат синтаксиса на C++ и Java. Те биват няколко вида:
Елементарни програмни конструкции

Елементарните програмни конструкции са най-простите елементи на прог­рамата. Например:



Съставни конструкции

Съставните програмни конструкции се състоят от няколко други конструк­ции, оградени в блок. Например:



Програмни конструкции за управление

Конструкциите за управление, както в повечето езици за програмиране, биват условни конструкции, конструкции за цикъл, за преход и т. н. В C# синтаксисът на тези конструкции е много близък до синтаксиса на C++ и Java.
Условни конструкции (conditional statements)

Условните конструкции в С# са if, if-else и switch. Техният синтаксис е еднакъв със синтаксиса им в C, C++ и Java.

if и if-else конструкциите за разлика от С и С++ могат да приемат единствено булево условие. Не са позволени целочислени стойности, които да играят ролята на true, ако са различни от 0 и false – иначе. Ето няколко примера за условна конструкция:



Ново в switch конструкцията за разлика от C и C++ е, че позволява изразът, по който се осъществява условието, да бъде от тип string или enum. Например:



Конструкцията switch се различава от реализацията си в С++. В С# не се раз­решава "пропадане" (fall-through). Пропадането в switch кон­струк­циите може да доведе до грешки. Независимо от удобствата, които предлага тази възможност, дизайнерите на езика С# са преценили, че рискът за грешка поради пропускане на break е по-голям, затова всеки case етикет трябва задължително да завършва с break.
Конструкции за повторение и цикъл

Конструкциите за повторение (iteration statements) са for-цикъл, while-цикъл, цикъл do-while и цикъл foreach – за обработка на колекции. Техният синтаксис е еднакъв със синтаксиса им в C, C++ и Java. Изключение прави foreach цикълът, който няма еквивалент в C и C++. Ето няколко примера:

Пример за for-цикъл:



Пример за while-цикъл:



Пример за цикъл do-while:



Операторът foreach е приложим за масиви, колекции и други типове, които поддържат интерфейса IEnumerable или имaт метод за извличане на итератор (enumerator).

Пример за цикъл foreach:



Конструкции за преход

Конструкциите за преход в C# са: break, continue – които се използват в цикли, goto – за безусловен преход и return – за връщане от метод. Те работят по същия начин, като в C, C++ и Java.

Пример за използване на конструкцията break:



Конструкции за управление на изключенията

Конструкциите за управление на изключенията в С# са: throw – за предизвикване на изключение, try-catch – за прихващане на изключе­ние, try-finally – за сигурно изпълнение на завършваща секция и try-catch-finally – за прихващане на изключение със завършваща секция.

Пример за предизвикване и прихващане на изключение:



Методът ThrowException() предизвиква изключение от тип Exception, което може да бъде прихванато, ако функцията, която го предизвиква, се намира в try-catch блок. В такъв случай може да се извършат действия в catch блока, в зависимост от информацията, която носи това изключение.

Конструкциите try-finally и try-catch-finally се използват най-вече за освобождаване на ресурси, които се използват в тялото им. Независимо дали възникне изключение при работата с даден ресурс, той трябва да бъде освободен накрая – това обикновено се прави във finally блок, който се изпълнява независимо дали се минава през catch блока. Блокът finally се изпълнява дори и да има return в catch или try блок.

В темата "Управление на изключенията в .NET" ще разгледаме подробно работата с изключения, техните особености и препоръките за правилна работа с тях.
Специални конструкции

Специалните конструкции в С# са: lock – за синхронизирано изпълнение, checked, unchecked – за контрол на аритметичните препълвания, unsafe – за директен достъп до паметта чрез указатели, fixed – за фиксиране на местоположението в паметта при работа с неуправляван код.
Коментари в програмата

Коментарите биват два вида - коментар за част от програмен ред и блоков коментар.

Ето пример за коментар на един ред:



Ето пример и за блоков коментар:



Вход и изход от конзолата

В .NET Framework за вход и изход от конзолата се използват стандартни класове от BCL (Base Class Library). Входът и изходът от конзолата се осъществяват чрез класа Console, намиращ се в пространство от имена System.

Класът System.Console предоставя основната функционалност, от която се нуждаят конзолните приложения (console applications), които четат и пишат на екрана. Ако конзолата не съществува (например в Windows Forms и уеб-базираните приложения), писането в конзолата няма никакъв ефект и не се предизвикват изключения.

Всяко конзолно приложение при стартиране получава от операционната система три стандартни потока – за вход, изход и за грешки. При изпълнение от конзолата тези три потока автоматично се асоциират със самата нея. За достъп до стандартния вход, стандартния изход и стандарт­ния изход за грешки в .NET Framework се използват свойствата In, Out и Error на класа Console.
Вход от конзолата

Входът от конзолата се осъществява чрез два метода на класа Console - Read() и ReadLine(). Методът Read() чете единичен символ от стандарт­ния вход и го връща като int стойност или връща -1, ако няма повече символи. Методът ReadLine() чете цял символен ред и връща string или стойност null ако е достигнат края на входа.

И двата метода са синхронни (блокиращи) операции т. е. при извикване блокират, докато не бъде прочетен някакъв символ (ред).

Методът Read() има една особеност – той не връща управлението след всеки въведен символ, а връща прочетените символи наведнъж един след друг едва след като се натисне [Enter]. По тази причина този метод не е удобен за интерактивен вход от клавиатурата при конзолни приложения.
Вход от конзолата – примери

Ето един пример за използването на метода Read():



В практиката за въвеждане на стойности от конзолата по-често се изпол­зва методът ReadLine(). Ето пример за неговата употреба:



Изход към конзолата

Изходът към конзолата се осъществява чрез два метода на класа Console - Write(…) и WriteLine(…), които печатат на конзолата подадените като параметри данни, с разликата, че WriteLine(…) преминава на нов ред след като отпечата текста. Методите приемат string, int, float, double и други типове данни.

Write(…) и WriteLine(…) приемат и параметрични форматиращи низове, които позволяват печатане на текст чрез шаблони, които се попълват от подадените параметри. На форматиращите низове ще обърнем специално внимание в темата "Символни низове".
Изход на конзолата – пример

Ето един пример за вход и изход от конзолата, който илюстрира и изпол­зването на форматиращи низове:



Дебъгерът на Visual Studio .NET

Сега ще илюстрираме как се използва дебъгерът на Visual Studio .NET. Ще покажем поставяне на точка за спиране (breakpoint), изпълнение на прог­рамата в дебъг режим, проследяване на изпълнението на програмата и следене на стойностите на променливите по време на изпълнение.

Ще си поставим за задача да напишем програма, която намира всички трицифрени числа, сумата от цифрите на които е стойността 25. Можем да решим задачата по следния начин:



За да проследим изпълнението на примерната програма, ще изпълним следните стъпки:

1. Стартираме Visual Studio .NET.

2. Създаваме ново конзолно приложение с име Digits.sln. Въвеждаме в него сорс кода от примера Digist.cs.

3. За да го компилираме натискаме [Shift]+[Ctrl]+[B].

4. Слагаме точка на прекъсване (breakpoint) с мишката върху първия ред от най-вътрешния програмен блок (щракваме малко вляво от самия ред и редът се маркира по специфичен начин):



5. Стартираме програмата от съответния бутон за стартиране от лен­тата с инструменти на Visual Studio .NET. Програмата ще започне да се изпълнява и когато се достигне реда с точката на прекъсване, Visual Studio .NET ще спре изпълнението и ще влезе в дебъг режим.

6. От менюто Debug можем да разгледаме по-интересните функции на дебъгера на Visual Studio .NET. Можем да добавим точки на прекъс­ване (breakpoints), да следим стойностите на променливите, да проследяване на изпълнението на кода по различен начин (Step Into, Step over, Step out), да добавим променливи за следене (Add Watch), да следим стека за изпълнение на програмата и т.н. Можем да разгледаме представянето на променливите в паметта – като изберем Debug | Windows | Memory. Много полезен е и прозорецът Command Window, в който не само може да се види стойност на променлива в дебъг режим, но и да се изпълни някакъв метод и да се види върнатата от него стойност. С [Shift] + [F9] при маркирана променлива може да се извика прозорец за нейното наблюдение (Quick Watch).

Точките на прекъсване могат да бъдат асоциирани с някакво условие (conditional breakpoints) и да спират изпълнението на програмата само ако това условие е истина.

Ето как изглежда работното пространство на Visual Studio .NET по време на проследяване на изпълнението на програмата след спиране в точката на прекъсване и преминаване към следващия оператор с [F10]:



Инструментът ILDASM

Всяка програма на С# се компилира до междинен език IL (Intermediate Language). Microsoft предоставя стандартен инструмент за разглеждане на този, генериран от компилаторите на С#, код. Това е инструментът Microsoft .NET Framework Disassembler (ILDASM). С тази деасембли­раща про­гра­ма можем да отворим всяко .NET асембли и да разгледаме неговите пространства от имена, класове, типове и код.

Инструментът ildasm.exe е стандартна част от Microsoft .NET Framework SDK. Обикновено .NET Framework SDK идва заедно с Visual Studio .NET и се намира в директория C:\Program Files\Microsoft Visual Studio .NET 2003\SDK\v1.1\Bin. Нека илюстрираме как се използва той. За целта трябва да изпълним следните стъпки:

1. Стартираме командния интерпретатор cmd.exe:



2. Отиваме в директорията, където се намира компилираната прог­рама, например, програмата от предходния пример Digits.exe:



Извикваме от командната линия инструмента ILDASM (ildasm.exe) и му подаваме като параметър компилираната програма Digits.exe:



4. Навигирайки по дървото, което ILDASM показва за асемблито Digits.exe, можем да видим как изглежда MSIL кодът за конструк­тора на класа Digits и за метода му Main():



XML документация в C#

XML документацията в C# програмите представлява съвкупност от комен­тари, започващи с "/ / /". Тя може да съдържа различни XML тагове – напри­мер, таг описващ връщана стойност на метод, таг за препратки към други методи и др. Като идея XML документацията прилича на JavaDoc в Java.

XML документацията значително улеснява поддръжката – документацията е част от кода, а не стои във външен файл. Поддържа се лесно и ползата от нея е видима още при разработката на приложението – Visual Studio .NET показва краткото описание на даден метод, ако той е документиран чрез вградената XML документация, при задействане на IntelliSense. C# компилаторът може да извлича XML документацията като XML файл за по-нататъшна обработка.

Ето пример за използване на XML документация:



Тагове в XML документацията

Ето по-важните тагове, използвани в XML документацията в C#:

- <summary>…</summary> – кратко описание за какво се отнася даден тип, метод, свойство и т.н. Visual Studio .NET показва това описание при задействане на IntelliSense.

- <remarks>…</remarks> – подробно описание на даден тип, метод, свойство и т.н. Visual Studio .NET показва това описание в областта Object Browser.

- <param>…</param> – описание на един от параметрите на даден метод.

- <returns>…</returns> – описание на връщаната от даден метод стойност.

- <exception>…</exception> – описание на изключение, което може да възникне в даден метод.

- <seealso> – препратка към информация, свързана с текущото описание.

- <value>…</value> – описание на свойство (property).
Извличане на XML документация от C# сорс код

Сега ще покажем как чрез C# компилатора може да се извлече докумен­тацията от C# файл в отделен XML файл. Нека имаме следната програма на C#, която използва XML документация:



За да извлечем документацията от тази програма, трябва да изпълним следните стъпки:

1. Стартираме командния интерпретатор cmd.exe:



2. Отиваме в директорията, където се намира сорс кода на програмата. Нека тя е Demo-6-XML-Comments:



3. Извикваме компилатора на C#, за да компилира файла MainClass.cs, като му задаваме опцията за извличане на XML доку­ментацията в отделен файл:



4. Отваряме получения .xml файл с Internet Explorer, за да разгледаме съдържанието му.

Ето как полученият XML файл:



Генериране на HTML документация от VS.NET

Сега ще покажем как чрез Visual Studio .NET може да се генерира HTML документация за даден проект на C# по XML коментарите в неговия сорс код. Във вид на HTML документацията е много по-удобна за четене и разглеждане.

За целта трябва да изпълним следните стъпки:

1. Отваряме с Visual Studio .NET проект, в който сме използвали XML документиране, например проекта Demo-6-XML-Comments.sln, който съдържа кода от предходния пример.

2. От меню Tools избираме Build Comment Web Pages…. Указваме директория, където да се генерира HTML документацията, и натискаме бутона [OK]. Visual Studio .NET ще генерира в посочената директория съвкупност от HTML файлове, които доку­ментират нашия проект и съдържат XML коментарите от сорс кода му, подре­дени в подходящ за разглеждане вид.

3. Разглеждаме HTML документацията, която Visual Studio .NET е гене­ри­рал. Можем да навигираме по пространствата от имена, типовете от проекта и отделните му методи:



Директиви на предпроцесора

Нека сега разгледаме някои по-важни директиви на т. нар. предпроцесор. Преди компилация C# програмите преминават през процес на обработка, който идентифицира кода, който трябва да бъде компилиран при условна ком­пилация. Този процес се изпълнява от предпроцесора. Програмно върху предпроцесора можем да указваме влияние чрез т.нар. директиви – запазени думи, започващи със символа #.
Директиви за форматиране на сорс кода

В С# са въведени директиви за форматиране на сорс кода - #region и #endregion, които ограждат блок от кода, който се "свива" от редактора на Visual Studio .NET:

[img]http://i.data.bg/07/07/21/471102_orig.jpg[img]

Visual Studio .NET редакторът много често слага региони, за да отдели автоматично-генерирания код от сорс кода, писан от програмиста. Дирек­тивите #region и #endregion се игнорират от C# компилатора и се използват единствено от средите за разработка.
Директиви за условна компилация

Директивите #define и #ifdef служат за условна компилация. Чрез тях може да се укаже на компилатора да компилира кода по различен начин според процесора, платформата и въобще средата, в която се извършва компилацията. Чрез #if, #else, #elif, #endif се задават границите на блоковете за условна компилация и съответните условия (знаци) за ком­пилиране. Директивите #define и #undef дефинират знаци за услов­на компилация, според които се определя кой от блоковете за условна компилация да се разглежда.
Условна компилация – пример

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



Ето и резултата от изпълнението на примера:



Директиви за контрол над компилатора

Директивите #warning и #error предизвикват предупреждения и грешки по време на компилация. Например следната програма на C# се компи­лира успешно, но с предупреждение:



Документацията на .NET Framework

Програмирането с .NET Framework е немислимо без неговата документа­ция. Затова нека сега разгледаме какво представлява тя и как можем да я използваме при търсене на помощна информация по време на разработ­ката на .NET приложения.
MSDN Library

Документацията на .NET Framework се съдържа в "Microsoft MSDN Library".

MSDN Library е система, която предоставя пълен набор от технически до­кументи, описващи продуктите, инструментите и технологиите за разра­ботка на Microsoft (в частност .NET Framework и C#), както и средства за навигация и търсене в тях. MSDN Library съдържа технически ръковод­ства, справочна информация, статии, при­мери и други ресурси за софту­ерни разработчици.

MSDN Library е достъпен безплатно в on-line вариант от Интернет сайта за разработчици на Microsoft – http://msdn.microsoft.com/library/. Продуктът се разпростра­нява и за локална инсталация заедно с партньорските прог­рами на Microsoft.
MSDN Library – пример

За пример ще покажем как можем да намерим подробна информация за форматиращите низове в .NET Framework и тяхното използване. За целта стартираме MSDN Library и търсим "composite formatting":



.NET Framework и MSDN Library

Документацията на .NET Framework е част от MSDN Library и се разпро­странява заедно с VS.NET и .NET Framework SDK.

Когато бъде инсталирана, документацията за .NET Framework, тя се инте­грира във VS.NET и може да се използва директно от него. Напри­мер, ако се нуждаем от помощна информация за метода WriteLine(…) на класа Console, натискаме [F1] във Visual Studio .NET докато курсорът е върху този метод. Отваря се нов прозорец, в който са описани параметрите, типа на връщаната стойност, типовете изключения, които може да предиз­вика описвания метод, в кое пространство от имена се намира и др.

Ето как изглежда описанието на метода WriteLine(…) на класа Console:



Източник:

Светлин Наков и колектив

Глава III

Как работи програмата?

На първия ред директивата using System указва, че се използва прост­ранството от имена System (т.е. всички класове, структури и други типове, декларирани в него). Тя е като #include в C++, като import в Java и като uses в Delphi.

Следва декларацията на клас с ключова дума class. Този клас се състои от един единствен метод – методът static void Main(), който е входна точка на програмата. Когато този метод завърши, завършва и програмата.

В метода Main() се извиква метода WriteLine(…) на класа Console, нами­ращ се в пространството от имена System. Класът Console осигурява сред­ства за вход и изход от конзолата. Чрез него отпечатваме на конзолата текста "Hello, C#".
Компилиране от командния ред

Програми на C# могат да се компилират от командния ред чрез компи­латора csc.exe, който е стандартна част от .NET Framework и е достъпен от директорията, в която е инсталиран той. При стандартна инсталация тя е C:\Windows\Microsoft.NET\Framework\v1.1.4322.

Можем да компилираме сорс кода на примерната програма по след­ния начин: Използвайки командния интерпретатор (cmd.exe) се придвиж­ваме до директорията, където се намира файлът HelloCSharp.cs. След това можем да го компилираме със следната команда:



За да бъде намерен компилаторът csc.exe, е необхо­димо в текущия път (в променливата PATH от средата) да е включена дирек­торията на .NET Framework.

Ако компилацията премине успешно, в резултат се получава файлът HelloCSharp.exe, който представлява .NET асембли, записано като изпъл­ним файл.
Стартиране от командния ред

Стартирането на получения изпълним (.exe) файл става както всички останали изпълними файлове, например чрез следната команда:



Резултатът

Резултатът от изпълнението на нашата първа C# програмка представлява един текстов ред:



Резултатът от компилирането и изпълнението на примерната програма е показан на следващата картинка:



Създаване на проект, компилиране и стартиране от Visual Studio.NET

Ще покажем как може да се използва интегрираната среда за разработка на приложения Microsoft Visual Studio .NET за изпълнение на предходната примерна програмка. Ще създадем нов проект (конзолно приложение), ще го компилираме и изпълним. Трябва да преминем през следните стъпки:

1. Стартираме Visual Studio .NET.

2. От меню File избираме New Project. Избираме Visual C# Projects | Console Application. Избираме име и местоположение за проекта:



Visual Studio .NET създава за нас един Solution и един проект в него, съдържащ няколко файла. Файлът, в който можем да пишем нашия код, се отваря автоматично.

3. Въвеждаме примерната програмка. Можем да сменим името на файла Class1.cs с HelloCSharp.cs чрез клавиша [F2], натиснат в момент, в който е активен файлът Class1.cs от Solution Explorer:



4. За да компилираме, натискаме [Shift+Ctrl+B] или избираме менюто Build | Build Solution. Ето как изглежда VS.NET в този момент:



5. За да стартираме приложението, натискаме [Ctrl+F5] или избираме от менюто Debug | Start Without Debugging. В резултат прило­жението се изпълнява в нов конзолен прозорец и след приключване на работата му VS.NET ни приканва да натиснем някакъв клавиш, за да затвори прозореца:



Можем да стартираме приложението и само с [F5], но тогава то ще се изпълни в режим на дебъгване и след приключване на работата му прозорецът, в който е изведен резултата, веднага ще се затвори и няма да го видим.

Запазени думи в C#

Езикът C# дефинира следните запазени думи, които се използват в кон­струкциите и синтаксиса на езика:



Ще видим за какво служат повечето от тях постепенно, в процеса на запознаване с езика C#, с обектно-ориентираното програмиране в .NET Framework, с общата система от типове и в някои други теми.
Типове данни в C#

Типовете данни в C# биват два вида – типове по стойност (value types) и типове по референция (reference types). Типовете по стойност (стойностни типове) директно съдържат своята стойност и се съхраняват в стека. Те се предават по стойност. Типовете по референция (референтни типове) пред­ставляват силно типизирани указатели към стойност в динамичната памет. Те се предават по референция (адрес) и се унищожават от garbage collector, когато не се използват повече от програмата.

Типовете биват още примитивни (вградени, built-in) типове и типове, дефинирани от потребителя.
Стойностни типове (value types)

Типовете по стойност (стойностни типове) са примитивните типове, избро­е­ните типове и структурите. Например:



Референтни типове (reference types)

Типовете по референция (референтни типове) са класовете, интерфей­сите, масивите и делегатите. Например:



На всички типове в C# съответстват типове от общата система от типове (Common Type System – CTS) на .NET Framework. Например, на прими­тивния C# тип int съответства типа System.Int32 от CTS.

Примитивни типове


Примитивните типове данни в C# (built-in data types) биват:
Примитивни типове по стойност

- byte, sbyte, int, uint, long, ulong – цели числа

- float, double, decimal – реални числа

- char – Unicode символи

- bool – булев тип (true или false)
Примитивни типове по референция

- string – символен низ (неизменима последователност от Unicode символи)

- object – обект (специален тип, който се наследява от всички типове)
Типове дефинирани от потребителя

Типовете дефинирани от потребителя биват класове, структури, изброени типове, интерфейси и делегати:



Вече се сблъскахме с класовете в C# в примерната програма "Hello, C#". Повече за тях, както и за структурите и интерфейсите ще научим в темата "Обектно-ориентирано програмиране в .NET".

Преобразуване на типовете

Има два типа преобразувания на примитивните типове – преобразуване по подразбиране (implicit conversion) и изрично преобразуване (explicit conversion).

В C# преобразуването по подразбиране е позволено, когато е безопасно. Например, от int към long, от float към double, от byte към short:



Изричното преобразуване се използва, когато преобразуваме към по-малък тип или типовете не са директно съвместими. Например, от long към int, от double към float, от char към short, от int към char, от sbyte към uint:



В С# има специална ключова дума checked, която указва при препълване да се получава System.OverflowException вместо грешен резултат. Клю­човата дума unchecked действа противоположна на checked. Ето пример за преобразуване на типове с използване на тези ключови думи:



Изброени типове (enumerations)

Изброените типове в C# се състоят от множество именувани константи. Дефинират се със запазената дума enum и наследяват типа System.Enum. Ето пример за изброен тип, който съответства на дните от седмицата:



Изброените типове се използват за задаване на една измежду няколко възможности. Вътрешно се представят с int, но може да се зададе и друг числов тип.

Изброените типове са силно типизирани – те не се превръщат в int, освен експлицитно.

Ето пример как може да бъде използван даден изброен тип:



Както се вижда, инстанциите на изброените типове могат да приемат една от дефинираните в тях стойности.

Изброените типове могат да се използват и като съвкупност от битови флагове чрез атрибута [Flags]. Ето пример за изброен тип, който може да приема за стойност комбинация от дефинираните в него константи:



Какво представляват атрибутите и как се използват ще разгледаме по-детайлно в темата "Атрибути". Засега трябва да знаем, че чрез тях може да се асоциира допълнителна информация към типовете.

Използването на изброени типове осигурява по-високо ниво на абстрак­ция и по този начин сорс кодът става по-разбираем и по-лесен за под­дръжка.

В .NET Framework широко се използват изброени типове. Например, из­броения тип ConnectionState, намиращ се в пространство от имена System.Data, характеризира състоянието на връзка към база от данни, създадена чрез ADO.NET (зададено е и числовото съответствие на всяко едно от състоянията):