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