C Sharp
C# (C Sharp, произнася се Си Шарп) е обектно ориентиран език за програмиране, разработен от Microsoft като част от софтуерната платформа .NET. Стремежът още при създаването на C# езика е бил да се създаде прост, модерен, обектно ориентиран език с общо предназначение. Основа за C# са C++, Java и донякъде езици като Delphi, VB.NET и C. Той е проектиран да балансира мощност (C++) с възможност за бързо разработване (Visual Basic и Java). Те представляват съвкупност от дефиниции на класове, които съдържат в себе си методи, а в методите е разположена програмната логика – инструкциите, които компютърът изпълнява. Програмите на C# представляват един или няколко файла с разширение .cs, в които се съдържат дефиниции на класове и други типове. Тези файлове се компилират от компилатора на C# до изпълним код и в резултат се получават асемблита – файлове със същото име, но с различно разширение (.exe или .dll).

Ето примерна версия на програмата „Hello, world!“ (в системна конзола), написана на C#:
using System;

class Hello
{
    static void Main()
    {
        Console.WriteLine("Hello, World!");
    }
}

Езикът C# и платформата .NET 
Първата версия на C# е разработена от Microsoft в периода 1999 – 2002 г. и е пусната официално в употреба през 2002 г. като част от .NET платформата, която има за цел да улесни съществено разработката на софтуер за Windows среда чрез качествено нов подход към програмирането, базиран на концепциите за „виртуална машина“ и „управляван код“. По това време езикът и платформата Java, изградени върху същите концепции, се радват на огромен успех във всички сфери на разработката на софтуер и разработката на C# и .NET е естественият отговор на Microsoft срещу успехите на Java технологията. Едно от най-големите предимства на .NET Framework е вграденото автоматично управление на паметта. То предпазва програмистите от сложната задача сами да заделят памет за обектите и да търсят подходящия момент за нейното освобождаване. Това сериозно повишава производителността на програмистите и увеличава качеството на програмите, писани на C#.

Mono 
Тъй като оригиналната версия на езика 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.

Препратки в C# 
Езикът C# използва следните основни (има и допълнителни) ключови думи за построяване на своите програмни конструкции:

Управление на паметта 
За управлението на паметта в .NET Framework се грижи специален компонент от CLR, наречен „система за почистване на паметта“ (garbage collector). Основната задача на тази система е да следи кога заделената памет за променливи и обекти вече не се използва, да я освобождава и да я прави достъпна за последващи заделяния на нови обекти.

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

Оператори

Версии 
В своето развитие C# е преминал през следните версии:

Коментиране на кода 
В C# се използва двойна наклонена черта (//), за да се покаже, че останалата част от линията е коментар. Това е наследено от C++.
public class Foo
{
    // коментар
    public static void Bar(int firstParam) {}  // също коментар
}
По-дългите коментари могат да бъдат обозначени с „начало“ (/*) и „край“ (*/). Това е наследено от стандартните C.
public class Foo
{
    /* По-дълъг
             коментар */
    public static void Bar(int firstParam) {}
}

Условни конструкции

if-else 
Условните конструкции if и if-else предоставят условен тип контрол, чрез който програмата може да изпълнява различни функции в зависимост от някакво условие, което се проверява по време на изпълнение на конструкцията.
public static void IfElse
{
    if (булев израз)
    {
        тяло тип (1) на условната конструкция;
    }
    else if (нов булев израз)
    {
        тяло тип (2) на условната конструкция;
    }
    else
    {
        тяло тип (3) на else-конструкция;
    }
}
Форматът включва: if клауза, булев израз и тяло на условната конструкция, if-else конструкцията се състои от: запазена дума if, булев израз, тяло на условната конструкция, запазена дума else, тяло на else конструкция. Тялото на else конструкцията може да се състои от един или няколко оператора, заградени в къдрави скоби, също както тялото на условната конструкция.

switch-case 
Конструкцията switch-case избира измежду части от програмен код на базата на стойност на зададения селектор, който представлява променлива или израз (най-често целочислен). Форматът на конструкцията за избор на вариант е следният:
public static void SwitchCase
{
    switch (селектор)
    {
    case стойност на селектора (1): конструкция; break;
    case стойност на селектора (2): конструкция; break;
    case стойност на селектора (3): конструкция; break;
    case стойност на селектора (4): конструкция; break;
    // ...
    default: конструкция; break;
    }
}
Операторът switch сравнява резултата от селектора с всяка една стойност от изброените в тялото на switch конструкцията в case етикетите. Ако се открие съвпадение с някой case етикет, се изпълнява съответната конструкция. Ако не се открие съвпадение, се изпълнява default конструкцията.

Цикли в C# 
Циклите в C# са while, do-while, for и foreach. C# предоставя нов вид цикъл, наречен foreach, който е близък до for each на Visual Basic. Foreach позволява да се преминава през всеки елемент и поддържа IEnumerable интерфейс.

while 
public static void while
{
    // Докато условието е вярно цикъла ще се изпълнява.
    while (условие)
    {

    }
}

do-while 
public static void do-while
{
    // Разликата на do-while с while е, че do-while ще се изпълни задължително поне един път и след това ще проверява условието.
    do
    {

    }
    while (условие)
}

for 
public static void for
{
    //Инициализация, следвана от проверка на условието, изпълнение на цикъла.
    for (i=0; i<10; i++)
    {

    }
}

foreach 
public static void foreach
{
    //Изпълнение на цикъла за всеки елемент от масив или списък.
    foreach (елемент in колекция)
    {

    }
}

Масиви 
Масивите представляват съвкупности от променливи с дадени стойности. Тези променливи могат да бъдат примитивен или референтен тип. Елементите на масивите в C# са номерирани с числата 0, 1, 2, ... N-1. Тези номера на елементи се наричат индекси, а броят елементи в даден масив N се нарича дължина на масива. Масивите също така могат да бъдат от различни размерности едномерни, двумерни .. n-мерни.

Деклариране и инициализиране на масиви:
public static void Array
{
    //Деклариране на масив с променливи от тип int и размер 6 елемента
    int[] oneDimArray = new int[6];
    myArray[0] = 301;  // задаване на елемента под индекс 0, стойност равна на 301

    //Деклариране на масив, размер 6 елемента, заедна със стойности на съответните индекси: 0, 1, 2, 3, 4, 5
    int[] oneDimArrayNew = { 301, 302, 303, 299, 310, 323 };

    //Деклариране на двумерен масив, размер 3 х 4 елемента.
      //вариант 1 чрез задаване на размерите
      int[,] intMatrix = new int[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“: (всяка нова дума, която се долепя като част от името на метода, трябва да започва с главна буква)
 Имената на методите е препоръчително да бъдат съставени от глагол или от глагол и съществително име

Пример за извикване на метод:
class ExampleProgram
{
    static void Main()
    {
        // ...
        string[] names = { "Ivan", "Petar", "Hristo" };
        for (int i = 0; i < names.Length; i++)
        {
            PrintName(names[i]); // метод, който принтира съответния зададен string, без да връща стойност
        }
        // ...
        int result = SolveEquation(2, 4); // метод, който връща стойност от тип int
        Console.WriteLine(result);
        // ...

    }

    private static int SolveEquation(int num1, int num2)
    {
        try
        {
            int result = num1 * num2 – (num1 + num2);
            return result;
        }
        catch (ArgumentOutOfRangeException)
        {
            throw new ArgumentOutOfRangeException();
        }
        catch (OverflowException)
        {
            throw new OverflowException();
        }
    }

    private static void PrintName(string currentName)
    {
        Console.WriteLine(currentName);
    }
}

Варианти на методи (method overloading)

Когато в даден клас има деклариран метод, чието име съвпада с името на друг метод, но сигнатурите на двата метода се различават по списъка от параметри (броят на елементите в него или подредбата им), имаме различни варианти на този метод (method overloading).

class ExampleMethodOverload
{
    static void Main()
    {
        string stringToPrint = "hello";
        int intToPrint = 5;
        float floatToPrint = 2.33f;

        Print(stringToPrint);
        Print(intToPrint);
        Print(floatToPrint);
    }

    static void Print(string str)
    {
        Console.WriteLine(str);
    }

    static void Print(int number)
    {
        Console.WriteLine(number);
    }

    static void Print(float number)
    {
        Console.WriteLine(number);
    }
}

Прихващане и обработка на изключения

Изключения в .NET 
Изключение (exception) в общия случай представлява уведомление за дадено събитие, нарушаващо нормалната работа на една програма. Exception handling (инфраструктура за обработка на изключенията) е механизъм, който позволява хвърлянето и прихващането на изключения. Този механизъм се предоставя от средата за контролирано изпълнение на .NET код, наречена CLR. Част от тази инфраструктура са дефинираните езикови конструкции в C# за хвърляне и прихващане на изключения. CLR се грижи и след като веднъж е възникнало всяко изключение, да стигне до кода, който може да го обработи.

Изключение в .NET представлява събитие, което уведомява програмиста, че е възникнало обстоятелство (грешка), непредвидено в нормалния ход на програмата. Това става, като методът, в който е възникнала грешката, изхвърля специален обект, съдържащ информация за вида на грешката, мястото в програмата, където е възникнала, и състоянието на програмата при възникване на грешката.

Всяко изключение в .NET носи т.нар. stack trace, който информира за това къде точно в кода е възникнала грешката. Stack trace се използва от програмистите, за да се намерят причините за възникването на изключението и съдържа следната информация в себе си:
 Пълното име на класа на изключението;
 Съобщение – информация за естеството на грешката;
 Информация за стека на извикване на методите.

Прихващане на изключения 
Процесът на търсене и прихващане на изключение е обратният на този за извикване на методи. Започва се от метода, в който е възникнало изключението, и се върви към метода, който го е извикал, където изключението може да е прихванато. Ако не бъде намерен такъв метод, който да прихване изключението, то се прихваща от CLR, който показва съобщение за грешка (изписва я в конзолата или я показва в специален прозорец).

За да прихванем изключение, обгръщаме парчето код, където може да възникне изключение, с програмната конструкция try-catch: Конструкцията се състои от един try блок, обгръщащ валидни изрази на C#, които могат да хвърлят изключения, следван от един или няколко catch блока, които обработват съответно различни по тип изключения.

try
{
    // Код, от който искаме да прихванем евентуална грешка
}
catch (ExceptionType objectName)
{
    // Код, който обработва грешката
}
catch (ExceptionType objectName)
{
    // Код, който обработва грешката
}
finally
{
    // Код, който обработва грешката
}

Хвърляне на изключения 
Изключения в C# се хвърлят с ключовата дума throw, като първо се създава инстанция на изключението и се попълва нужната информация за него. Изключенията са класове, като единственото изискване за тях е да наследяват System.Exception.
static void ExeptionDemo()
{
    Exception e = new Exception("There is a problem");
    throw e;
}

Използване на класове и обекти в C# 
C# е измислен да бъде лесен за работа, универсален, съвременен обектно ориентиран език за програмиране от високо ниво.

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

Класът дефинира абстрактните характеристики на даден обект. Той е план или шаблон, чрез който се описва даден обект. Класовете са градивните елементи на ООП и са неразделно свързани с обектите. Всеки обект е представител на точно един клас.

Примерен клас за обекта кола:
class ExampleProgram
{
    static void Main()
    {
        // използваме дадената кола по подразбиране
        Car defaultCar = new Car();
        defaultCar.PrintMaxSpeed();

        // задаваме нова кола
        Car newInitializedCar = new Car("Traby-new", "black", "Trabant Corp.", 230);
        newInitializedCar.PrintMaxSpeed();
    }
}

public class Car
{
    // дефиниране на основните свойства на обекта
    public string name;
    public string color;
    public string producer;
    public int maxSpeed;

    // присвояване на стойностите на свойствата на обекта
    public string Name
    {
        get { return this.name; }
        set { this.name = value; }
    }
    public string Color
    {
        get { return this.color; }
        set { this.color = value; }
    }
    public string Producer
    {
        get { return this.producer; }
        set { this.producer = value; }
    }
    public int MaxSpeed
    {
        get { return this.maxSpeed; }
        set { this.maxSpeed = value; }
    }

    // конструктор без параметри
    public Car()
    {
        this.Name = "super-tunning Traby";
        this.Color = "pink";
        this.Producer = "Trabant Corp.";
        this.MaxSpeed = 178;
    }

    // конструктор със задаване на параметри
    public Car(string name, string color, string producer, int maxSpeed)
    {
        this.Name = name;
        this.Color = color;
        this.Producer = producer;
        this.MaxSpeed = maxSpeed;
    }

    public void PrintMaxSpeed()
    {
        Console.WriteLine("The max speed of the {0} is {1}km/h ", name, maxSpeed);
    }
}

Структури от данни в C# 
Структурите от данни са множество от данни, организирани на основата на логически и математически закони. Много често изборът на правилната структура прави програмата много по-ефективна – можем да спестим памет и време за изпълнение. Ще бъдат разгледани някои от основните структури, които се използват в C#, от библиотеката на .NET, както и от външната библиотека на PowerCollections.

Могат ясно да се различат няколко групи структури:
 Линейни структури
 Дървовидни структури – различни типове дървета и графи
 Речници – хештаблици
 Множества

Линейни структури 
Статичен списък List<T>: List<T> се използва най-удачно, когато не се очаква често вмъкване и премахване на елементи, новите елементи се добавят в края и елементите се ползват по индекс.
public static void ListT
{
    // създава се списък с добавени два елемента тип string "C#" и "Java"
    List<string> list = new List<string>() { "C#", "Java" }; //
    list.Add("SQL");
    list.Add("Python");    // добавят се нови елементи "SQL" и "Python"
    foreach (string item in list)
    {
       Console.WriteLine(item);
    }
}

Свързан списък LinkedList<T>: С оглед на структурата на свързания списък трябва да имаме предвид следното: Можем да добавяме бързо на произволно място в списъка (за разлика от List<T>). Търсенето на елемент по индекс или по съдържание в LinkedList е бавна операция, тъй като се налага да обхождаме всички елементи последователно, като започнем от началото на списъка. Изтриването на елемент е бавна операция, защото включва търсене.
public static void LinkedListT
{
    // създаване на свърза списък
    LinkedList<string> list = new LinkedList<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>: Структурата опашка изпълнява условието „първият влязъл излиза първи“. Добавените елементи се нареждат в края на опашката, а при извличане поредният елемент се взима от началото (главата) ѝ.
public static void QueueT
{
    // деклариране на опашка
    Queue<string> queue = new Queue<string>();
    queue.Enqueue("Message One"); // добавяне на елементи
    queue.Enqueue("Message Two");
    queue.Enqueue("Message Three");
    queue.Enqueue("Message Four");
    while (queue.Count > 0)
    {
        string message = queue.Dequeue(); // взимаме и изваждаме първия добавен елемент в опашката
        Console.WriteLine(message); // "Message One", "Message Two", "Message Three", "Message Four"
    }
}

Стек Stack<T>: Стекът представлява структура от данни с поведение „последният влязъл първи излиза“. Последния добавен елемент винаги е на първа позиция в стека.
public static void StackT
{
    // деклариране на стек
    Stack<string> stack = new Stack<string>();
    stack.Push("1. One"); // добавяме елементи в стека
    stack.Push("2. Two");
    stack.Push("3. Three");
    stack.Push("4. Four");
    while (stack.Count > 0)
    {
        string personName = stack.Pop(); // взимаме последния добавен елемент (на първа позиция) в стека:
        Console.WriteLine(personName);   // "4. Four", "3. Three", "2. Two", "1. One"
    }
}

Дървета и графи 

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

Общата терминология, свързана с дърветата, включва:
 Връх – всяка една точка от дървото
 Ребро – отсечка между два върха
 Корен е върхът, който няма предшественици
 Листа са всички върхове, които нямат наследници
 Вътрешни върхове са всички върхове, които не са корен и листа

Двоично дърво (binary tree) е дърво, в което преките наследници на всеки връх са не повече от два. Прието е единият наследник да се нарича ляв наследник, а другият – десен наследник. Те, от своя страна, са корени съответно на лявото поддърво и на дясното поддърво на техния родител.

Два основни алгоритъма за обхождане на дървета са:
 Търсене в дълбочина (Depth-first search)
 Търсене в ширина (Breadth-first search)

Балансирано двоично дърво – двоично дърво, в което никое листо не е на много голяма дълбочина от всяко друго листо.

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

Дървовидните структури, имплементиращи обекти от реалния свят, могат да се реализират по много различни начини. Поради тази причина в .NET съществува само една вътрешна имплементация на дърво: В библиотеката System.Collections.Generic се поддържа класът TreeSet<T>, който вътрешно представлява червено-черно дърво. Този клас е вътрешен и е видим само в дадената библиотека.

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

Графите могат да се използват за моделиране на много ситуации от реалността, а задачите върху графи представляват множество реални проблеми, които често се налага да бъдат решавани. Ето няколко примера:
 Карта на град може да се моделира с ориентиран претеглен граф
 Компютърна мрежа може да се моделира с неориентиран граф
 Речната система в даден регион може да се моделира с насочен претеглен граф

Речници и хештаблици 
Структура от данни „речник“ IDictionary<K, V>

Речниците са известни още като асоциативни масиви (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>, който отново позволява запазване на елементи с един и същи ключ.
public static void DictionaryKV
{
     // деклариране на речник от библиотеката на .NET
     Dictionary<string, DateTime> finishList = new Dictionary<string, DateTime>();
     finishList.Add("Иван Петров", new DateTime(2013, 9, 1, 01, 10, 23));
     finishList.Add("Петър Христов", new DateTime(2013, 9, 1, 01, 11, 42));
     finishList.Add("Иван Иванов", new DateTime(2013, 9, 1, 01, 13, 25));
     finishList.Add("Георги Стойков", new DateTime(2013, 9, 1, 01, 14, 59));

     foreach (KeyValuePair<string, DateTime> pair in finishList)
     {
         Console.WriteLine("Name: {0} – time: {1:HH:mm:ss}", pair.Key, pair.Value);
     }

     // деклариране на речник от библиотеката на Wintellect.PowerCollections
     MultiDictionary<string, decimal> priceList = new MultiDictionary<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 (var pair in priceList)
     {
         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> позволяват запазване и на еднакви стойности на елементите.

Тези класове имплементират множество чрез хештаблица. Единственият начин да се намери обект от множество е, като зададем търсене със самия обект или евентуално с обект, който е еквивалентен на него.

public static void SetT
{
      // деклариране на сортирано множество от .NET
      SortedSet<float> valuesSet = new SortedSet<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.PowerCollections
      OrderedSet<int> orderedSetOfInts = new OrderedSet<int>();
      orderedSetOfInts.Add(3);
      orderedSetOfInts.Add(20);
      orderedSetOfInts.Add(20);
      orderedSetOfInts.Add(200);
      orderedSetOfInts.Add(20);
      orderedSetOfInts.Remove(20);
      orderedSetOfInts.UnionWith(new OrderedSet<int>() { 3, 4, 5 });
      Console.WriteLine("All elements in the set: " + orderedSetOfInts);
      Console.WriteLine("Sub-range [5...20): " + orderedSetOfInts.Range(5, true, 20, false));
}

Източници

Външни препратки 
 Visual C# Developer Center – Общност на C# разработчиците
 C# Help – Помощ в изучаването на езика
 C# Free source codes and tutorials  – Безплатни сорсове и самоучители
 Mono Project – Проектът Mono
 MS Visual Studio – Официална среда за програмиране на C#
 Курс „C# програмиране – част I“  – Онлайн архив на курс за C#-1 Телерик Академия
 Курс „C# програмиране – част II“  – Онлайн архив на курс за C#-2 Телерик Академия
 Безплатно видео обучение по въведение в C# от SoftwareAcademy.bg