Սովորում ենք C# | Առաջին քայլեր

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

Microsoft ընկերությունը տրամադրում է Visual Studio միջավայրը, որը մատուցվում է մի քանի տարբերակով՝

• Visual Studio - հասանելի է Windows և macOS ՕՀ-ների համար։ Անվճար տարբերակը կոչվում է Community Edition։
• Visual Studio Code - Հասանելի է Windows, macOS և Linux ՕՀ-ների համար։ Անվճար է։

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

Visual Studio Code-ում աշխտանքը սկսելու համար բավարար է ստեղծել նոր C# ֆայլ (C# կոդ պարունակող ֆայլերն ունեն .cs ընդլայնումը)։
Visual Studio-ով աշխատելու համար պետք է նախ ստեղծել պռոյեկտ, ինչից հետո ավտոմատ կերպով կստեղծվեն անհրաժեշտ ֆայլերն ու կկարգավորվեն գործիքները։ Ծրագիրը գործարկելուց, սկզբնական մենյուում առաջարկվում է մի քանի տարբերակ, որոնոց միջոցով կարելի է ծավալել աշխատանք նախագծերի (projects) հետ։

Վերջին տարբերակը ("Create a new project") նոր նախագծի ստեղծումն է, որն ընտրելուց առաջարկվում է նախագծերի բոլոր նմուշների (template) տեսականին։ Պարզագույն ծրագրերի համար (որոնք չունեն գրաֆիկական ինտերֆեյս, չեն հանդիսանում web-հավելված, խաղ և այլն), խորհուրդ է տրվում օգտագործել Console App կոչվող նմուշը։

Ինչպես տեսնում ենք, Console App նմուշի համար ևնշված է երկու տարբերակ՝ .NET Core և .NET Framework: Այս նմուշներն օգտագործում են .NET-ի համապատասխան տարբերակը, որոնց տարբերության մասին պատմել եմ նախորդ գրառման մեջ։

Նախագծի նմուշն ընտրելուց և Next սեղմելուց հետո, լրացնում ենք նախագծի անունն ու պահպանման վայրը և օգտագործում ենք Create կոճակը նախագծի ստեղծումն ավարտելու համար։

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

Մինչ ծրագրավորման հնարքներ և 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) թվերի՝ համակարգչային հիշողության մեջ ներկայացման մեթոդների հետ կարող եք ծանոթանալ հետևյալ հղումներով՝
• Прямой, обратный и дополнительный коды
• Прямой, обратный и дополнительный коды двоичного числа
• Signed Binary Numbers
• 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 բառից, քանի որ մաթեմատիկայի՝ պնդումների ճշմարտացիությանը վերաբերվող ճյուղը կոչվում է Բուլյան հանրահաշիվ՝ Boolean algebra)։

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

`

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

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

`

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

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

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

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

`

// Հայտարարում ենք ամբողջ թիվ պահող 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

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

`

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;։ Հասանելի են նաև +=, -=, %=, *= օպերատորները։

`

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)	|	a | b
Պայմանական ԵՎ (AND)	&&	a && b
Պայմանական ԿԱՄ (OR)	||	a || b
Հակառակ ԿԱՄ (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

`

// Ժխտման օպերատորը պարզապես փոխում է տվյալ Բուլյան փոփոխականի արժեքը...
// ...ճշմարիտը (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-ի համար՝ |, և ||։ Կրկնվող նշանով տարբերակների առանձնահատկությունը կայանում է նրանում, որ բավարար պայմանի գործելու դեպքում, նրանք չեն ստուգում երկրորդ օպերանդ։ Օրինակ, որպեսզի a && b արտահայտությունը վերադարձնի ճշմարիտ (true) արժեք, անհրաժեշտ է, որ երկու օպերանդներն էլ կրեն ճշմարիտ արժեք։ Եթե առաջին օպերանդը (a) չի կրում այն, պարզ է որ ամբողջ արտահայտությունն այլևս չի կարող լինել ճշմարիտ, հետևաբար երկրորդ օպերանդի՝ b-ի արժեքը նույնիսկ հաշվի չի առնվում։

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

Հաջորդիվ, ծանոթանանք հավասարության և համեմատության օպերատորներին։
Հավասարության օպերատորը (==) թույլ է տալիս ստուգել արդյոք իրեն տրված երկու օպերանդները հավասար են (կրում են նույն արժեքը)։ Արդյունքը վերադարձվում է բուլյան փոփոխականի տեսքով, այսինքն կամ true կամ false արժեքով։
`

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, եթե երկու օպերանդները տարբերվում են իրարից։
`

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#-ում տվյալների հետ աշխատելու օպերատորների մի քանի տեսակների, մասնավորապես՝ թվաբանական, տրամաբանական, հավասարության և համեմատության օպերատորներին։