C Sharp

от Уикипедия, свободната енциклопедия
Направо към: навигация, търсене
Емблема за пояснителна страница Вижте пояснителната страница за други значения на C.

C#
C sharp.svg
Парадигма обектно-ориентиран, Структурно програмиране, Императивно програмиране, Функционално програмиране, Родово програмиране
Реализиране през 2001
Автор Microsoft
Типизация на данните динамична
Програмни диалекти , Spec#, Polyphonic C#
Повлиян от C++, Smalltalk, Eiffel,
Modula-3, Object Pascal, Java
Повлиява D, F#
Уебсайт C# Език (MSDN)

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

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

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

Езикът C# и платформата .NET[редактиране | edit source]

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

Mono[редактиране | edit source]

Тъй като оригиналната версия на езика C# и платформата .NET са само за Windows се появява проекта Mono. Mono е проектиран за да позволи на разработчиците да създават лесно софтуер за различни платформи. Той е имплементация със свободен код на платформата .NET. Базиран е на ECMA стандартите за C# и виртуалната машина на .NET — Common Language Runtime. Mono сваля бариерите за създаване на качествен софтуер за Linux с езика C#. Моно може да работи върху голям брой платформи като Android, Linux дистрибуциите, BSD, OS X, Windows, Solaris, и дори върху някои конзоли — Play Station 3, Wii, and X-Box 360.

Препратки[редактиране | edit source]

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

Препратки
abstract as base bool
break byte case catch
char checked class const
continue decimal default delegate
do double else enum
event explicit extern false
finally fixed float for
foreach goto if implicit
in in (generic modifier) int interface
internal is lock long
namespace new null object
operator out out (generic modifier) override
params private protected public
readonly ref return sbyte
sealed short sizeof stackalloc
static string struct switch
this throw true try
typeof uint ulong unchecked
unsafe ushort using virtual
void volatile while

Управление на паметта[редактиране | edit source]

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

За управлението на паметта в .NET Framework се грижи специален компонент от CLR, наречен "система за почистване на паметта" (garbage collector). Основната задача на системата Garbage collector-а е да следи кога заделената памет за променливи и обекти вече не се използва, да я освобождава и да я прави достъпна за последващи заделяния на нови обекти.[1]

Дизайнерски цели[редактиране | edit source]

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

Оператори[редактиране | edit source]

Категория Оператори
аритметични -, +, *, /, %, ++, --
логически &&, ||, &, |, ^, !
побитови &, |, ^, ~, <<, >>
за сравнение ==, !=, >, <, >=, <=
за присвояване =, ^=, <<=, >>=
съединяване на символни низове +
за работа с типове (type), as, is, typeof, sizeof
други ., new, (), [], {}, ?:, ??

Версии[редактиране | edit source]

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

от Microsoft
C# 1.0 Януари 2002
C# 1.2 Април 2003
C# 2.0 Септември 2005
C# 3.0 Август 2007
C# 4.0 Април 2010
C# 5.0 Август 2012

Коментиране на кода[редактиране | edit source]

В C# се използва двойна наклонена черта (/ /), за да се покаже,че останалата част от линията е коментар. Това е наследено от C++.

public class Foo
{
    // коментар
    public static void Bar(int firstParam) {}  // също коментар
}

По дългите коментарите могат да бъдат обозначени с "начало"(/ *) и завършва с "край"(*/). Това е наследено от стандартните C.

public class Foo
{
    /* По дълъг
             коментар */
    public static void Bar(int firstParam) {}
}

Условни конструкции[редактиране | edit source]

if-else[редактиране | edit source]

Условни конструкции if и 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[редактиране | edit source]

Условни конструкция 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#[редактиране | edit source]

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

while[редактиране | edit source]

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

do-while[редактиране | edit source]

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

for[редактиране | edit source]

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

foreach[редактиране | edit source]

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

Масиви[редактиране | edit source]

Масивите представляват съвкупности от променливи със дадени стойности. Тези променливи могат да бъдат примитивен или референтен тип. Елементите на масивите в 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
      };
}

Методи[редактиране | edit source]

Чрез употребата на методи в 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);
    }
}

Прихващане и обработка на изключения[редактиране | edit source]

Изключения в .NET[редактиране | edit source]

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

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

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

- Пълното име на класа на изключението;
- Съобщение – информация за естеството на грешката;
- Информация за стека на извикване на методите.

Прихващане на изключения[редактиране | edit source]

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

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

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

Хвърляне на изключения[редактиране | edit source]

Изключения в C# се хвърлят с ключовата дума throw, като първо се създава инстанция на изключението и се попълва нужната информация за него. Изключенията са класове, като единственото изискване за тях е да наследяват System.Exception.

static void ExeptionDemo()
{
    Exception e = new Exception("There is a problem");
    throw e;
}

Използване на класове и обекти в C#[редактиране | edit source]

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#[редактиране | edit source]

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

Могат ясно да се различат няколко групи структури:

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

Линейни структури[редактиране | edit source]

Статичен списък 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"
    }
}

Дървета и Графи[редактиране | edit source]

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

- Връх — всяка една точка от дървото
- Ребро — отсечка между два върха
- Корен е върхът, който няма предшественици
- Листа са всички върхове, които нямат наследници
- Вътрешни върхове са всички върхове които не са корен и листа

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

Два основни алгоритъма за обхождане на дървета са:

- Търсене в дълбочина (Depth-first search)
- Търсене в ширина (Breadth-first search)

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

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

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

- Карта на град може да се моделира с ориентиран претеглен граф
- Компютърна мрежа може да се моделира с неориентиран граф
- Речната система в даден регион може да се моделира с насочен претеглен граф

Речници и Хеш-таблици[редактиране | edit source]

Структура от данни "речник" 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);
     }
}

Множества[редактиране | edit source]

Структура от данни "множество". Класовете от библиотеката на .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));
}

Източници[редактиране | edit source]

  1. Наков, Светлин, Веселин Колев и колектив. Въведение в програмирането със C#. Велико Търново, Фабер, 2011. ISBN 978-954-400-527-6. с. 1116.

Външни препратки[редактиране | edit source]