C# (C Sharp, произнася сеСи Шарп) еобектно ориентиранезик за програмиране, разработен отMicrosoft като част от софтуерната платформа.NET. Стремежът още при създаването на C# езика е бил да се създаде прост, модерен, обектно ориентиран език с общо предназначение. Основа за C# саC++, Java и донякъде езици катоDelphi,VB.NET иC. Той е проектиран да балансира мощност (C++) с възможност за бързо разработване (Visual Basic и Java). Те представляват съвкупност от дефиниции на класове, които съдържат в себе си методи, а в методите е разположена програмната логика – инструкциите, които компютърът изпълнява. Програмите на C# представляват един или няколко файла с разширение.cs, в които се съдържат дефиниции на класове и други типове. Тези файлове се компилират от компилатора на C# до изпълним код и в резултат се получават асемблита – файлове със същото име, но с различно разширение (.exe или.dll).
Първата версия на C# е разработена отMicrosoft в периода 1999 – 2002 г. и е пусната официално в употреба през 2002 г. като част от.NET платформата, която има за цел да улесни съществено разработката на софтуер заWindows среда чрез качествено нов подход към програмирането, базиран на концепциите за „виртуална машина“ и „управляван код“. По това време езикът и платформатаJava, изградени върху същите концепции, се радват на огромен успех във всички сфери на разработката на софтуер и разработката на C# и .NET е естественият отговор на Microsoft срещу успехите на Java технологията. Едно от най-големите предимства на .NET Framework е вграденото автоматично управление на паметта. То предпазва програмистите от сложната задача сами да заделят памет за обектите и да търсят подходящия момент за нейното освобождаване. Това сериозно повишава производителността на програмистите и увеличава качеството на програмите, писани на C#.
Тъй като оригиналната версия на езика C# и платформата .NET са само за Windows, се появява проектът Mono. Mono е проектиран, за да позволи на разработчиците да създават лесно софтуер за различни платформи. Той е имплементация със свободен код на платформата .NET. Базиран е на ECMA стандартите за C# и виртуалната машина на .NET – Common Language Runtime. Mono сваля бариерите за създаване на качествен софтуер заGNU/Linux с езика C#. Mono може да работи върху голям брой платформи катоAndroid, GNU/Linux дистрибуциите,BSD,OS X, Windows,Solaris и дори върху някои конзоли –PlayStation 3, Wii, иXbox 360.
За управлението на паметта в .NET Framework се грижи специален компонент от CLR, наречен „система за почистване на паметта“ (garbage collector). Основната задача на тази система е да следи кога заделената памет за променливи и обекти вече не се използва, да я освобождава и да я прави достъпна за последващи заделяния на нови обекти.[1]
C# е създаден като прост, модерен, с общо предназначение и обектно ориентиран език за програмиране.
Езикът е предназначен за използване в развиващите се софтуерни компоненти, той е подходящ и за разполагане в разпределена среда.
На езика C# и върху .NET платформата може да бъде разработван разнообразен софтуер като офис приложения, уеб приложения, уеб сайтове, настолни приложения, мултимедийни интернет приложения, приложения за мобилни телефони, различни видове игри и много други.
Условните конструкции if и if-else предоставят условен тип контрол, чрез който програмата може да изпълнява различни функции в зависимост от някакво условие, което се проверява по време на изпълнение на конструкцията.
Форматът включва: if клауза, булев израз и тяло на условната конструкция, if-else конструкцията се състои от: запазена дума if, булев израз, тяло на условната конструкция, запазена дума else, тяло на else конструкция. Тялото на else конструкцията може да се състои от един или няколко оператора, заградени в къдрави скоби, също както тялото на условната конструкция.
Конструкцията switch-case избира измежду части от програмен код на базата на стойност на зададения селектор, който представлява променлива или израз (най-често целочислен). Форматът на конструкцията за избор на вариант е следният:
Операторът switch сравнява резултата от селектора с всяка една стойност от изброените в тялото на switch конструкцията в case етикетите. Ако се открие съвпадение с някой case етикет, се изпълнява съответната конструкция. Ако не се открие съвпадение, се изпълнява default конструкцията.
Циклите в C# саwhile, do-while, for иforeach.C# предоставя нов вид цикъл, нареченforeach, който е близък доfor each наVisual Basic.Foreach позволява да се преминава през всеки елемент и поддържа IEnumerable интерфейс.
publicstaticvoiddo-while{// Разликата на do-while с while е, че do-while ще се изпълни задължително поне един път и след това ще проверява условието.do{}while(условие)}
Масивите представляват съвкупности от променливи с дадени стойности. Тези променливи могат да бъдат примитивен или референтен тип. Елементите на масивите в C# са номерирани с числата 0, 1, 2, ... N-1. Тези номера на елементи се наричат индекси, а броят елементи в даден масив N се нарича дължина на масива. Масивите също така могат да бъдат от различни размерности едномерни, двумерни .. n-мерни.
Деклариране и инициализиране на масиви:
publicstaticvoidArray{//Деклариране на масив с променливи от тип int и размер 6 елементаint[]oneDimArray=newint[6];myArray[0]=301;// задаване на елемента под индекс 0, стойност равна на 301//Деклариране на масив, размер 6 елемента, заедна със стойности на съответните индекси: 0, 1, 2, 3, 4, 5int[]oneDimArrayNew={301,302,303,299,310,323};//Деклариране на двумерен масив, размер 3 х 4 елемента.//вариант 1 чрез задаване на размеритеint[,]intMatrix=newint[3,4];//вариант 2 чрез директно задаване на стойноститеint[,]intMatrixNew={{1,2,3,4},// стойности на ред 0{5,6,7,8},// стойности на ред 1{5,3,4,8},// стойности на ред 2};}
Чрез употребата на методи в C# при реализирането на даден код се постига разделяне на множество подпрограми (subroutines), сглобени в една обща програма. Целта на това разделяне на методи е програмният код да бъде по-ясно четим, което от своя страна води до по-лесно писане на програмата, намиране на неточности и преправяне на вече написания код.
Най-общо принципът за дефиниране на методи в C# e: всеки метод да върши конкретна задача, името му да бъде показателно за работата, която върши, като, ако поради някаква причина методът не успее да изпълни работата, за която е предназначен, трябва да хвърли грешка (exception). Обикновено размерът на кода на един метод не трябва да е повече от един екран.
Друга много важна причина, заради която е добре да се използват методи, е, че по този начин се избягва повторението на код. Това е пряко свързано с концепцията за преизползване на кода.
Правила за именуване на метод:
Името на методите трябва да започва с главна буква
Трябва да се прилага правилото „PascalCase“: (всяка нова дума, която се долепя като част от името на метода, трябва да започва с главна буква)
Имената на методите е препоръчително да бъдат съставени от глагол или от глагол и съществително име
Пример за извикване на метод:
classExampleProgram{staticvoidMain(){// ...string[]names={"Ivan","Petar","Hristo"};for(inti=0;i<names.Length;i++){PrintName(names[i]);// метод, който принтира съответния зададен string, без да връща стойност}// ...intresult=SolveEquation(2,4);// метод, който връща стойност от тип intConsole.WriteLine(result);// ...}privatestaticintSolveEquation(intnum1,intnum2){try{intresult=num1*num2–(num1+num2);returnresult;}catch(ArgumentOutOfRangeException){thrownewArgumentOutOfRangeException();}catch(OverflowException){thrownewOverflowException();}}privatestaticvoidPrintName(stringcurrentName){Console.WriteLine(currentName);}}
Варианти на методи (method overloading)
Когато в даден клас има деклариран метод, чието име съвпада с името на друг метод, но сигнатурите на двата метода се различават по списъка от параметри (броят на елементите в него или подредбата им), имаме различни варианти на този метод (method overloading).
Изключение (exception) в общия случай представлява уведомление за дадено събитие, нарушаващо нормалната работа на една програма. Exception handling (инфраструктура за обработка на изключенията) е механизъм, който позволява хвърлянето и прихващането на изключения. Този механизъм се предоставя от средата за контролирано изпълнение на .NET код, наречена CLR. Част от тази инфраструктура са дефинираните езикови конструкции в C# за хвърляне и прихващане на изключения. CLR се грижи и след като веднъж е възникнало всяко изключение, да стигне до кода, който може да го обработи.
Изключение в .NET представлява събитие, което уведомява програмиста, че е възникнало обстоятелство (грешка), непредвидено в нормалния ход на програмата. Това става, като методът, в който е възникнала грешката, изхвърля специален обект, съдържащ информация за вида на грешката, мястото в програмата, където е възникнала, и състоянието на програмата при възникване на грешката.
Всяко изключение в .NET носи т.нар. stack trace, който информира за това къде точно в кода е възникнала грешката. Stack trace се използва от програмистите, за да се намерят причините за възникването на изключението и съдържа следната информация в себе си:
Процесът на търсене и прихващане на изключение е обратният на този за извикване на методи. Започва се от метода, в който е възникнало изключението, и се върви към метода, който го е извикал, където изключението може да е прихванато. Ако не бъде намерен такъв метод, който да прихване изключението, то се прихваща от CLR, който показва съобщение за грешка (изписва я в конзолата или я показва в специален прозорец).
За да прихванем изключение, обгръщаме парчето код, където може да възникне изключение, с програмната конструкция try-catch: Конструкцията се състои от един try блок, обгръщащ валидни изрази на C#, които могат да хвърлят изключения, следван от един или няколко catch блока, които обработват съответно различни по тип изключения.
try{// Код, от който искаме да прихванем евентуална грешка}catch(ExceptionTypeobjectName){// Код, който обработва грешката}catch(ExceptionTypeobjectName){// Код, който обработва грешката}finally{// Код, който обработва грешката}
Изключения в C# се хвърлят с ключовата дума throw, като първо се създава инстанция на изключението и се попълва нужната информация за него. Изключенията са класове, като единственото изискване за тях е да наследяват System.Exception.
staticvoidExeptionDemo(){Exceptione=newException("There is a problem");throwe;}
C# е измислен да бъде лесен за работа, универсален, съвременен обектно ориентиран език за програмиране от високо ниво.
Обектно ориентираното програмиране е модел на програмиране, който използва обекти и техните характеристики и взаимодействия за изграждането на компютърни програми. Софтуерните обекти моделират обекти от реалния свят или абстрактни концепции, които също се разглеждат като обекти.
Класът дефинира абстрактните характеристики на даден обект. Той е план или шаблон, чрез който се описва даден обект. Класовете са градивните елементи на ООП и са неразделно свързани с обектите. Всеки обект е представител на точно един клас.
Примерен клас за обекта кола:
classExampleProgram{staticvoidMain(){// използваме дадената кола по подразбиранеCardefaultCar=newCar();defaultCar.PrintMaxSpeed();// задаваме нова колаCarnewInitializedCar=newCar("Traby-new","black","Trabant Corp.",230);newInitializedCar.PrintMaxSpeed();}}publicclassCar{// дефиниране на основните свойства на обектаpublicstringname;publicstringcolor;publicstringproducer;publicintmaxSpeed;// присвояване на стойностите на свойствата на обектаpublicstringName{get{returnthis.name;}set{this.name=value;}}publicstringColor{get{returnthis.color;}set{this.color=value;}}publicstringProducer{get{returnthis.producer;}set{this.producer=value;}}publicintMaxSpeed{get{returnthis.maxSpeed;}set{this.maxSpeed=value;}}// конструктор без параметриpublicCar(){this.Name="super-tunning Traby";this.Color="pink";this.Producer="Trabant Corp.";this.MaxSpeed=178;}// конструктор със задаване на параметриpublicCar(stringname,stringcolor,stringproducer,intmaxSpeed){this.Name=name;this.Color=color;this.Producer=producer;this.MaxSpeed=maxSpeed;}publicvoidPrintMaxSpeed(){Console.WriteLine("The max speed of the {0} is {1}km/h ",name,maxSpeed);}}
Структурите от данни са множество от данни, организирани на основата на логически и математически закони. Много често изборът на правилната структура прави програмата много по-ефективна – можем да спестим памет и време за изпълнение. Ще бъдат разгледани някои от основните структури, които се използват в C#, от библиотеката на .NET, както и от външната библиотека на PowerCollections.
Могат ясно да се различат няколко групи структури:
Линейни структури
Дървовидни структури – различни типове дървета и графи
Статичен списък List<T>: List<T> се използва най-удачно, когато не се очаква често вмъкване и премахване на елементи, новите елементи се добавят в края и елементите се ползват по индекс.
publicstaticvoidListT{// създава се списък с добавени два елемента тип string "C#" и "Java"List<string>list=newList<string>(){"C#","Java"};//list.Add("SQL");list.Add("Python");// добавят се нови елементи "SQL" и "Python"foreach(stringiteminlist){Console.WriteLine(item);}}
Свързан списък LinkedList<T>: С оглед на структурата на свързания списък трябва да имаме предвид следното: Можем да добавяме бързо на произволно място в списъка (за разлика от List<T>). Търсенето на елемент по индекс или по съдържание в LinkedList е бавна операция, тъй като се налага да обхождаме всички елементи последователно, като започнем от началото на списъка. Изтриването на елемент е бавна операция, защото включва търсене.
publicstaticvoidLinkedListT{// създаване на свърза списъкLinkedList<string>list=newLinkedList<string>();list.AddFirst("First");// добавяне на елемент на позиция 0 (първа)list.AddLast("Last");// добавяне на елемент на позледната позицияlist.AddAfter(list.First,"After First");list.AddBefore(list.Last,"Before Last");Console.WriteLine(String.Join(", ",list));// Result: First, After First, Before Last, Last}
Опашка Queue<T>: Структурата опашка изпълнява условието „първият влязъл излиза първи“. Добавените елементи се нареждат в края на опашката, а при извличане поредният елемент се взима от началото (главата) ѝ.
publicstaticvoidQueueT{// деклариране на опашкаQueue<string>queue=newQueue<string>();queue.Enqueue("Message One");// добавяне на елементиqueue.Enqueue("Message Two");queue.Enqueue("Message Three");queue.Enqueue("Message Four");while(queue.Count>0){stringmessage=queue.Dequeue();// взимаме и изваждаме първия добавен елемент в опашкатаConsole.WriteLine(message);// "Message One", "Message Two", "Message Three", "Message Four"}}
Стек Stack<T>: Стекът представлява структура от данни с поведение „последният влязъл първи излиза“. Последния добавен елемент винаги е на първа позиция в стека.
publicstaticvoidStackT{// деклариране на стекStack<string>stack=newStack<string>();stack.Push("1. One");// добавяме елементи в стекаstack.Push("2. Two");stack.Push("3. Three");stack.Push("4. Four");while(stack.Count>0){stringpersonName=stack.Pop();// взимаме последния добавен елемент (на първа позиция) в стека:Console.WriteLine(personName);// "4. Four", "3. Three", "2. Two", "1. One"}}
В програмиранетодърветата са изключително често използванаструктура от данни, защото те моделират по естествен начин всякакви йерархии отобекти, които постоянно ни заобикалят в реалния свят. Свойствата на тези структури са от съществено значение за съвременното програмиране. Всяка от тях се използва за моделирането на проблеми от реалността, които се решават ефективно чрез имплементзция на дърво или граф.
Общата терминология, свързана с дърветата, включва:
Връх – всяка една точка от дървото
Ребро – отсечка между два върха
Корен е върхът, който няма предшественици
Листа са всички върхове, които нямат наследници
Вътрешни върхове са всички върхове, които не са корен и листа
Двоично дърво (binary tree) е дърво, в което преките наследници на всеки връх са не повече от два. Прието е единият наследник да се нарича ляв наследник, а другият – десен наследник. Те, от своя страна, са корени съответно на лявото поддърво и на дясното поддърво на техния родител.
Два основни алгоритъма за обхождане на дървета са:
Балансирано двоично дърво – двоично дърво, в което никое листо не е на много голяма дълбочина от всяко друго листо.
Идеалното балансирано двоично дърво е дърво, в което разликата в броя на върховете на лявото и дясното поддърво на всеки от върховете е най-много единица.
Дървовидните структури, имплементиращи обекти от реалния свят, могат да се реализират по много различни начини. Поради тази причина в .NET съществува само една вътрешна имплементация на дърво: В библиотеката System.Collections.Generic се поддържа класът TreeSet<T>, който вътрешно представлява червено-черно дърво. Този клас е вътрешен и е видим само в дадената библиотека.
Графите са една много полезна и разпространена структура от данни. Използват се за описването на най-разнообразни взаимовръзки между обекти от практиката. Както при дърветата, така и при графите съществуват много различни начини за представяне в програмирането.
Графите могат да се използват за моделиране на много ситуации от реалността, а задачите върху графи представляват множество реални проблеми, които често се налага да бъдат решавани. Ето няколко примера:
Карта на град може да се моделира с ориентиран претеглен граф
Компютърна мрежа може да се моделира с неориентиран граф
Речната система в даден регион може да се моделира с насочен претеглен граф
Речниците са известни още като асоциативни масиви (associative arrays) или карти (maps). При речниците заедно с данните, които държим, пазим и ключ, по който ги намираме. Елементите на речниците са двойки (ключ, стойност), като ключът се използва при търсене.
В .NET има две основни имплементации на интерфейса IDictionary<K, V>: Dictionary<K, V> и SortedDictionary<K, V>. SortedDictionary представлява имплементация с балансирано (червено-черно) дърво, а Dictionary – имплементация с хештаблица. Речниците Dictionary<K, V> и SortedDictionary<K, V> не позволяват добавяне на ключове с еднаква стойност, затова в някои случаи е по-удобно използването на аналогичните структури от библиотеката на Wintellect Power Collections for .NET.
MultiDictionary<TKey, TValue> е речник, аналогичен на класа Dictionary<TKey, TValue>, който позволява повторение по ключ.
OrderedMultiDictionary<TKey, TValue> е речник, подобен на SortedDictionary<TKey, TValue>, който отново позволява запазване на елементи с един и същи ключ.
publicstaticvoidDictionaryKV{// деклариране на речник от библиотеката на .NETDictionary<string,DateTime>finishList=newDictionary<string,DateTime>();finishList.Add("Иван Петров",newDateTime(2013,9,1,01,10,23));finishList.Add("Петър Христов",newDateTime(2013,9,1,01,11,42));finishList.Add("Иван Иванов",newDateTime(2013,9,1,01,13,25));finishList.Add("Георги Стойков",newDateTime(2013,9,1,01,14,59));foreach(KeyValuePair<string,DateTime>pairinfinishList){Console.WriteLine("Name: {0} – time: {1:HH:mm:ss}",pair.Key,pair.Value);}// деклариране на речник от библиотеката на Wintellect.PowerCollectionsMultiDictionary<string,decimal>priceList=newMultiDictionary<string,decimal>(true);priceList.Add("fish",4.50m);priceList.Add("fish",3.30m);priceList.Add("fish",8.70m);priceList.Add("pork",3.70m);priceList.Add("pork",4.20m);foreach(varpairinpriceList){Console.WriteLine("Product {0} – price: {1}",pair.Key,pair.Value);}}
Класовете от библиотеката на .NET, които имплементират множество, са HashSet<Т> и SortedSet<T>.
В библиотеката на Wintellect.PowerCollections аналогични класове са Set<T> и OrderedSet<T>, както и Bag<T> и OrderedBag<T>, които за разлика от HashSet<Т> и Set<T> позволяват запазване и на еднакви стойности на елементите.
Тези класове имплементират множество чрез хештаблица. Единственият начин да се намери обект от множество е, като зададем търсене със самия обект или евентуално с обект, който е еквивалентен на него.
publicstaticvoidSetT{// деклариране на сортирано множество от .NETSortedSet<float>valuesSet=newSortedSet<float>();valuesSet.Add(2.14f);valuesSet.Add(2.34f);valuesSet.Add(2.55f);valuesSet.Add(2.66f);if(valuesSet.Contains(2.55f)==true){Console.WriteLine("The set contains 2.55");}// деклариране на сортирано множество от Wintellect.PowerCollectionsOrderedSet<int>orderedSetOfInts=newOrderedSet<int>();orderedSetOfInts.Add(3);orderedSetOfInts.Add(20);orderedSetOfInts.Add(20);orderedSetOfInts.Add(200);orderedSetOfInts.Add(20);orderedSetOfInts.Remove(20);orderedSetOfInts.UnionWith(newOrderedSet<int>(){3,4,5});Console.WriteLine("All elements in the set: "+orderedSetOfInts);Console.WriteLine("Sub-range [5...20): "+orderedSetOfInts.Range(5,true,20,false));}
