Սովորում ենք C# | Առաջին քայլեր
Tags: csharp, dotnet, beginners, armenian
Published: 2020-03-13 21:16:17

### Միջավայրի կարգավորում

Microsoft ընկերությունը տրամադրում է Visual Studio միջավայրը, որը մատուցվում է մի քանի տարբերակով՝
* Visual Studio - հասանելի է [Windows](https://visualstudio.microsoft.com/vs/) և [macOS](https://visualstudio.microsoft.com/vs/mac) ՕՀ-ների համար։ Անվճար տարբերակը կոչվում է Community Edition։
* [Visual Studio Code](https://code.visualstudio.com/) - Հասանելի է Windows, macOS և Linux ՕՀ-ների համար։ Անվճար է։

Visual Studio Code-ն իրենից ներկայացնում է պարզ միջավայր, որը կարելի է օգտագործել փոքր ծրագրեր գրելու համար, սակայն առավել մեծ նախագծերի վրա աշխատելիս (օրինակ վեբ կամ բջջային հավելվածներ) հարմար է օգտագործել առավել բազմաֆունկցիոնալ Visual Studio-ն։

Visual Studio Code-ում աշխտանքը սկսելու համար բավարար է ստեղծել նոր C# ֆայլ (C# կոդ պարունակող ֆայլերն ունեն .cs ընդլայնումը)։ 
Visual Studio-ով աշխատելու համար պետք է նախ ստեղծել պռոյեկտ, ինչից հետո ավտոմատ կերպով կստեղծվեն անհրաժեշտ ֆայլերն ու կկարգավորվեն գործիքները։ Ծրագիրը գործարկելուց, սկզբնական մենյուում առաջարկվում է մի քանի տարբերակ, որոնոց միջոցով կարելի է ծավալել աշխատանք նախագծերի (*projects*) հետ։ 
![Visual Studio սկզբնական մենյուն](https://dev-to-uploads.s3.amazonaws.com/i/463ek75ps8z5tg8s6ej5.PNG)
Վերջին տարբերակը ("Create a new project") նոր նախագծի ստեղծումն է, որն ընտրելուց առաջարկվում է նախագծերի բոլոր նմուշների (template) տեսականին։ Պարզագույն ծրագրերի համար (որոնք չունեն գրաֆիկական ինտերֆեյս, չեն հանդիսանում web-հավելված, խաղ և այլն), խորհուրդ է տրվում օգտագործել **Console App** կոչվող նմուշը։
![Նոր նախագծի ստեղծում](https://dev-to-uploads.s3.amazonaws.com/i/ld76txkp2g66frajq3ex.PNG)
> Ինչպես տեսնում ենք, Console App նմուշի համար ևնշված է երկու տարբերակ՝ .NET Core և .NET Framework: Այս նմուշներն օգտագործում են .NET-ի համապատասխան տարբերակը, որոնց տարբերության մասին պատմել եմ [նախորդ գրառման](https://dev.to/n_babajanyan/c-net-3ddi) մեջ։

Նախագծի նմուշն ընտրելուց և Next սեղմելուց հետո, լրացնում ենք նախագծի անունն ու պահպանման վայրը և օգտագործում ենք Create կոճակը նախագծի ստեղծումն ավարտելու համար։ 
![Նոր նախագծի վերջնական կարգավորումներ](https://dev-to-uploads.s3.amazonaws.com/i/2kzlgyj43cgby9sazlt9.PNG)


### Առաջին քայլեր՝ տվյալների պահպանում

Մինչ ծրագրավորման հնարքներ և C#-ի առանձնահատկություններ ուսումնասիրելը, հիշենք ինչ է իրենից ներկայացնում ծրագրավորումը և ընդհանրապես ինֆորմատիկա գիտությունը։ 
Ինֆորմատիկան ուսումնասիրում է տվյալների հետ աշխատող (ընթերցող, փոփոխող, պահպանող, արտածող) գործընթացները։ Ըստ այդմ, ինֆորմատիկայի հիմնական գործիքների՝ համակարգիչների գործառույթներն անխուսափելիորեն ներառում են տվյալների վրա իրականացվող գործողություններ։ Բայց տարբեր դեպքերում անհրաժեշտ է լինում աշխատել տվյալների տարբեր տիպերի հետ՝ թվեր, տառեր, տեքստ, նկարներ․․․

Հենց այս նպատակով էլ բարձր մակարդակի յուրաքանչյուր լեզու պարունակում է գործիքներ տիպերի հետ աշխատելու համար։ .NET-համատեղելի լեզուների դեպքում այս գործիքակազմը ներառում է հիմնական բազային տիպեր, ինչպես նաև մեր սեփական տիպերը սահմանելու հնարավորություն։

C#-ի միջոցով հիշողության մեջ **ամբողջ թվեր** պահելու համար գործում են հետևյալ տիպերը՝


| C# տիպի անվանում |    Զբաղեցրած հիշողություն     | Արժեքների տիրույթ |
|:-----------------|:------------------------------|:-----------------:|
| `sbyte`            | Դրական/բացասական թվեր, 8 բիթ  | -128ից 127                                             |
| `byte`             | Դրական թվեր, 8 բիթ            | 0ից 255                                                |
| `short`            | Դրական/բացասական թվեր, 16 բիթ | -32,768ից 32,767                                       |
| `ushort`           | Դրական թվեր, 16 բիթ           | 0ից 65,535                                             |
| `int`              | Դրական/բացասական թվեր, 32 բիթ | -2,147,483,648ից 2,147,483,647                         |
| `uint`             | Դրական թվեր, 32 բիթ           |  0ից 4,294,967,295                                     |
| `long`             | Դրական/բացասական թվեր, 64 բիթ | -9,223,372,036,854,775,808ից 9,223,372,036,854,775,807 |
| `ulong`            | Դրական թվեր, 64 բիթ           | 0ից 18,446,744,073,709,551,615                         |

> Ինչպես տեսաք, ամբողջ թվերի պահպանման համար նախատեսված տիպերը բաժանվում են, երկու տեսակի՝ միայն դրական թվեր պարունակող տիպեր և ցանկացած նշանով թվեր պարունակող տիպեր։ Ընդ որում, միայն դրական թիվ պարունակող տիպերը նույն զբաղեցրած հիշողության պայմաններում ունակ են պահպանել երկու անգամ մեծ մաքսիմալ արժեքներ, քան դրական և բացասական թվերի համար նախատեսվածները։ Օրինակ՝ ``sbyte`` (signed byte) և ``byte`` տիպերը զբաղեցնում են 8 բիթ հիշողություն, սակայն ``byte``-ի մաքսիմալ արժեքը 255 է, մինչդեռ ``sbyte``-ինը՝ 127։
Այս տարբերակումը բխում է համակարգիչներում ամբողջ թվերի երկուական ներկայացման տեսակներից՝
* Signed integer` նշանով թվեր
* Unsigned integer՝ առանց նշանի թվեր
Բացասական և դրական (signed) թվերի՝ համակարգչային հիշողության մեջ ներկայացման մեթոդների հետ կարող եք ծանոթանալ հետևյալ հղումներով՝ 
* [Прямой, обратный и дополнительный коды](https://prog-cpp.ru/direct-return-additional-code/)
* [Прямой, обратный и дополнительный коды двоичного числа](https://microkontroller.ru/programmirovanie-mikrokontrollerov-avr/pryamoy-obratnyiy-dopolnitelnyiy-kod-dvoichnogo-chisla/)
* [Signed Binary Numbers](https://www.electronics-tutorials.ws/binary/signed-binary-numbers.html)
* [Signed number representations](https://en.wikipedia.org/wiki/Signed_number_representations)

**Կոտորակային թվերի** ներկայացման համար C#-ում ներառված են հետևյալ տիպերը՝

| C# տիպի անվանում | Զբաղեցրած հիշողություն | Ճշգրտություն |
|------------------|------------------------|--------------|
| `float`        | 4 բայթ (32 բիթ)        | 6-9 նիշ      |
| `double`       | 8 բայթ (64 բիթ)        | 15-17 նիշ    |
| `decimal`     | 16 բայթ (128 բիթ)      | 28-29 նիշ    |

Նշված երեք տիպերն ունեն տարբեր կիրառություններ։ Քանի որ `float`-ը զբաղեցնում է նշվածներից ամենափոքր ծավալը, այն կարելի է օգտագործել, երբ արագագործությունն ավելի կարևոր է քան ճշգրտությունը, իսկ օրինակ `decimal`-ը հիմնականում օգտագործվում է ֆինանսական հաշվարկներ կատարող ծրագրերում, քանի որ առաջարկում է մաքսիմալ ճշգրտություն։

**Տեքստային տվյալների** հետ աշխատանքի համար C#-ը ներառում է `string` և `char` տիպերը։ `char`-ը (character բառի կրճատված տարբերակը) նախատեսված մեկ նշան (տառ, թվանշան և այլն) պահպանելու համար, իսկ `string`-ը՝ ցանկացած երկարությամբ տեքստ։

> Իրականում, `string` տիպն ունի սահմանափակում՝ .NET միջավայրում տեքստային փոփոխականը կարող է զբաղեցնել մինչև 2GB հիշողություն, այսինքն պարունակել մինչև մոտավորապես 1 միլիարդ նիշ։

Ծրագրավորման հիմնական բոլոր լեզուներում օգտագործվում է ևս մեկ հատուկ տիպ, նախատեսված **տրամաբանական արժեքների** պահպանման համար, որն օգտագործվում է ծրագրի մեջ պնդումների ճշմարտության ստուգման համար։ Հետևաբար, այս տիպը կարող է ընդունել ընդամենը երկու արժեք՝ `true` (ճշմարիտ) և `false` (սխալ)։ C#-ում այս տիպը կոչվում է `bool` (կրճատ Boolean բառից, քանի որ մաթեմատիկայի՝ պնդումների ճշմարտացիությանը վերաբերվող ճյուղը կոչվում է [Բուլյան հանրահաշիվ](https://hy.wikipedia.org/wiki/%D4%B2%D5%B8%D6%82%D5%AC%D5%B5%D5%A1%D5%B6_%D5%B0%D5%A1%D5%B6%D6%80%D5%A1%D5%B0%D5%A1%D5%B7%D5%AB%D5%BE)՝ Boolean algebra)։

Դիտարկենք այսպիսի փոփոխականի հետ աշխատանքի պարզ օրինակ։

````c#
// Կարելի է պնդման արժեքը պահել bool տիպի փոփոխականում, այն հետագայում օգտագործելու համար
bool lightsOn = true;      // Լույսերը միացված են
lightsOn = false;          // Լույսերն անջատված են

// Կարելի է նաև ստուգել նախապես պահպանված արժեքների ճշմարտացիությունը
if(lightsOn) {
   // Եթե լույսերը միացված են, ձեռնարկել որոշ գործողություններ
}
````

### Գործողություններ տվյալների հետ՝ օպերատորներ

Վերոհիշյալ բոլոր տիպերը հնարավորություն են տալիս հիշողության մեջ պահպանել համապատասխան արժեքներ, բայց ինչպե՞ս կարող ենք փոփոխել դրանք և մեր ունեցած տեղեկատվությունից ստանալ նոր արժեքներ։ Այս հարցում մեզ կօգնեն **օպերատորները** (operator): 

Ծրագրավորման մեջ օպերատորները սահմանում են տվյալ տիպի արժեքների հետ կատարվող գործողությունները։ C#-ը ներառում է թվաբանական (arithmetic), տրամաբանական (logical), համեմատման (comparison), հավասարության (equality) և այլ տեսակների օպերատորներ։ 

Առաջին հերթին անհրաժեշտ է ծանոթանալ **նշանակման օպերատորին**։ Այն ներկայացված է `=` նշանով և թույլ է տալիս փոփոխականին վերագրել արժեք։ Նշանի աջ կողմում գտնվող արժեքը վերագրվում է ձախ կողմում գտնվող փոփոխականին։

````c#
// Հայտարարում ենք ամբողջ թիվ պահող int տիպի փոփոխական՝ number անվամբ և վերագրում դրան 13 արժեքը
int number = 13;

// Հայտարարում ենք մեկ նիշ պահող char տիպի փոփոխական` letter անվամբ և վերագրում դրան N արժեքը։
// Ուշադրություն դարձրեք՝ տեքստային արժեքները կոդում շրջապատվում են չակերտներով
char letter = "N";

// Կարելի է նաև նախապես հայտարարել փոփոխականը․․․
string country;

// ․․․և հետո միայն արժեք վերագրել դրան
country = "Armenia"

// Հնարավոր է նաև փոփոխականին վերագրել մեկ այլ փոփոխականի մեջ պահված արժեք
int firstNumber = 15;
int secondNumber = firstNumber; // Այժմ երկու փոփոխականներն էլ կրում են 15 արժեքը
````
> Օպերատորներն իրենց գործողությունները կատարում են **օպերանդների** վրա։ Օրինակ, նշանակման օպերատորն ունի երկու օպերանդ՝ ձախ կողմում գտնվող փոփոխականն ու աջ կողմում գտնվող արժեքը (կամ այլ փոփոխական)։
> Ըստ օպերանդների քանակի լինում են՝
> * **Բինար (binary) օպերատորներ**, որոնց անհրաժեշտ է երկու օպերանդ
> * **Ունար (unary) օպերատորներ**, որոնց անհրաժեշտ է միայն մեկը

C#-ում հասանելի թվաբանական օպերատորները հետևյալն են՝


|            Անվանում            | Նշան | Տեսակ |   Գրելաձև    |
|--------------------------------|------|-------|--------------|
| Մեծացում 1-ով (increment)      | `++` | Ունար | `a++`, `++a` |
| Փոքրացում 1-ով (decrement)     | `--` | Ունար | `a--`, `--a` |
| Նշանի փոխում (negation)        | `-`  | Ունար | `-a`         |
| Բազմապատկում                   | `*`  | Բինար | `a * b`      |
| Բաժանում                       | `/`  | Բինար | `a / b`      |
| Բաժանման մնացորդ (remainder)   | `%`  | Բինար | `a % b`      |
| Գումարում                      | `+`  | Բինար | `a + b`      |
| Հանում                         | `-`  | Բինար | `a - b`      |

Դիտարկենք օպերատորների օգտագործման որոշ օրինակներ՝

````c#
int number = 3;
number++; // Այժմ number փոփոխականը կկրի 4 արժեքը

int secondNumber = 5;
int result = number * secondNumber; // result փոփոխականը կկրի 20 արժեքը

result = result / 2; // 10

int remainder = 7 % 5; 
// remainder փոփոխականը կկրի 2 արժեքը, 
// քանի որ 7-ը 5 բաժանելիս ստանում ենք 1 քանորդ և 2 մնացորդ։
// % օպերատորը վերադարձնում է միայն մնացորդը։
````

> Ուշադրություն դարձրե՛ք `result = result / 2;` տողին։ Այն դեպքերի համար, երբ փոփոխականի վրա կատարվում է գործողություն, իսկ արդյունքը պահվում հենց նույն փոփոխականի մեջ, տվյալ օպերատորը կարելի է համատեղել նշանակման օպերատորի հետ (`=`)։ Օրինակ՝ `result /= 2;`։ Հասանելի են նաև `+=`, `-=`, `%=`, `*=` օպերատորները։

````c#
int num = 2;
num *= 2; // նույնն է ինչ num = num * 2;
num %= 3; // նույնն է ինչ num = num % 3;
num -= 1; // նույնն է ինչ num = num - 1;
````

Այժմ ծանոթանանք Բուլյան արժեքների հետ աշխատող *տրամաբանական օպերատորներին* (logical operators)։


|       Անվանում        | Նշան | Գրելաձև |
|-----------------------|------|---------|
| Ժխտում                | `!`    | `!a`      |
| Տրամաբանական ԵՎ (AND) | `&`    | `a & b `  |
| Տրամաբանական ԿԱՄ (OR) |<code>&#124;</code>| <code>a &#124; b</code>|
| Պայմանական ԵՎ (AND)   | `&&`   | `a && b`  |
| Պայմանական ԿԱՄ (OR)   |<code>&#124;&#124;</code>|<code>a &#124;&#124; b</code>|
| Հակառակ ԿԱՄ (XOR)     | `^`    | `a ^ b`   |

ԵՎ (AND) օպերատորը վերադարձնում է ճշմարիտ արժեք, եթե իր երկու օպերանդներն էլ կրում են `true` արժեք, մնացած բոլոր դեպքերում վերադարձվում է `false`։

|       a | b| a AND b|
|:----:|:----:|:-------:|
| `true` | `true`    | `true`      |
| `true` | `false`    | `false`      |
| `false` | `true`    | `false`      |
| `false` | `false`    | `false`      |

ԿԱՄ (OR) օպերատորը վերադարձնում է ճշմարիտ արժեք, եթե գոնե մեկ օպերանդ ունի ճշմարիտ արժեք։

|       a | b| a OR b|
|:-------:|:-------:|:----------:|
| `true` | `true`    | `true`      |
| `true` | `false`    | `true`      |
| `false` | `true`    | `true`      |
| `false` | `false`    | `false`      |

````c#
// Ժխտման օպերատորը պարզապես փոխում է տվյալ Բուլյան փոփոխականի արժեքը...
// ...ճշմարիտը (true) վերածելով սխալի (false) և հակառակը։
bool someVariable = true;
bool anotherVariable = !someVariable; // anotherVariable = false

anotherVariable = !anotherVariable; // anotherVariable = true

bool firstVar = true;
bool secondVar = false;

// (firstVar && secondVar) արտահայտությունը կընդունի false արժեքը
// հետևաբար, դրա չժտումը՝ ! օպերատորի միջոցով, կընդունի true արժեքը
bool result = !(firstVar && secondVar); 
````

Ուշադրություն դարձրեք, որ AND և OR գործողությունների համար կա երկուական օպերատոր՝ AND—ի համար `&` և `&&`, OR-ի համար՝ <code>&#124;</code>, և <code>&#124;&#124;</code>։ Կրկնվող նշանով տարբերակների առանձնահատկությունը կայանում է նրանում, որ բավարար պայմանի գործելու դեպքում, նրանք չեն ստուգում երկրորդ օպերանդ։ Օրինակ, որպեսզի `a && b` արտահայտությունը վերադարձնի ճշմարիտ (`true`) արժեք, անհրաժեշտ է, որ երկու օպերանդներն էլ կրեն ճշմարիտ արժեք։ Եթե առաջին օպերանդը (`a`) չի կրում այն, պարզ է որ ամբողջ արտահայտությունն այլևս չի կարող լինել ճշմարիտ, հետևաբար երկրորդ օպերանդի՝ `b`-ի արժեքը նույնիսկ հաշվի չի առնվում։ 

Նույն կերպ, որպեսզի <code>a &#124;&#124; b</code> արտահայտությունը վերդարձնի ճշմարիտ արժեք, անհրաժեշտ է, որ գոնե մեկ օպերանդ լինի ճշմարիտ։ Այսինքն, եթե առաջին օպերանդը (`a`) կրի ճշմարիտ արժեք, ամբողջ արտահայտությունը կվերադարձնի ճշմարիտ արժեք, առանց `b`-ի արժեքը հաշվի առնելու։

Հաջորդիվ, ծանոթանանք **հավասարության** և **համեմատության** օպերատորներին։
Հավասարության օպերատորը (`==`) թույլ է տալիս ստուգել արդյոք իրեն տրված երկու օպերանդները հավասար են (կրում են նույն արժեքը)։ Արդյունքը վերադարձվում է բուլյան փոփոխականի տեսքով, այսինքն կամ `true` կամ `false` արժեքով։
````c#
int number = 3;
int secondNumber = 3;
bool result = (number == secondNumber); // result = true

// Կարելի է ստուգել նաև տեքստային փոփոխականներ
string firstString = "String 1";
string secondString = "String 2";
bool result2 = (firstString == secondString); // result2 = false;
````

Գոյություն ունի նաև անհավասարության օպերատոր (`!=`), որի նպատակը երևի արդեն պարզ է։ Վերոհիշյալ բոլոր տիպերի համար, `a != b` արտահայտությունը համարժեք է `!(a == b)` արտահայտությանը։ Այսինքն, այն վերադարձնում է `true`, եթե երկու օպերանդները տարբերվում են իրարից։
````c#
bool firstBoolean = true;
bool secondBoolean = true;

bool result = (firstBoolean != secondBoolean) // result = false

float var1 = 7.35f;
float var2 = 7.36f;
bool result2 = (var1 != var2); // result2 = true
````

Նման կերպ կարելի է օգտագործել նաև համեմատության օպերատորները՝
* `<` - փոքր (օրինակ՝ `a < b`)
* `>` - մեծ (օրինակ՝ `a > b`)
* `<=` - փոքր կամ հավասար (օրինակ՝ `a <= b`)
* `>=` - մեծ կամ հավասար (օրինակ՝ `a >= b`)

### Ամփոփում
 
Այս անգամ անդրադարձանք Visual Studio միջավայրի կարգավորմանը և որոշ այլընտրանքների։ Այնուհետև, ծանոթացանք C# լեզվում հասանելի տիպերից մի քանիսին՝ մանրամասնելով, թե որ դեպքերում կարող է օգտագործեվել դրանցից յուրաքանչյուրը։ Այս տիպերի փոփոխականներում պահվող տեղեկատվությունը կարող է լինել ամբողջ թիվ, կոտորակային թիվ, տեքստ կամ բուլյան արժեք (որոնց նշանակությանն ու օգտագործմանը նույնպես ծանոթացանք)։ 
Վերջ ի վերջո, ծանոթացանք C#-ում տվյալների հետ աշխատելու օպերատորների մի քանի տեսակների, մասնավորապես՝ թվաբանական, տրամաբանական, հավասարության և համեմատության օպերատորներին։