C Sharp

**C Sharp**, **C#** (სი შარპი) — ობიექტურად ორიენტირებული, ბრძანებითი, ფუნქციური პროგრამირების ენა დამზადებული Microsoft .NET პლათფორმისთვის. პირველი ვერსია გამოშვებული იყო 2001 წელს ანდერს ჰელსბერგის ზედამხედველობით. მისი სინტაქსი ჰგავს ჯავის სინტაქს და დაფუძნებულია C++'ის სინტატიკურ კონსტრუქციაზე. ცვლადების მკაცრი ტიპიზაცია გამო ის წარმოადგენს უსაფრთხო ტიპურ ენას და შეცდომების დადგენას აწარმოებს კომპილაციის დროს. 

## ენის თვისებები 
**კლასები** - C#-ში დაწერილი პროგრამები შედგებიან კლასებისგან. კლასის გარეთ მოთავსებული კოდი არალეგიტუმურად ითვლება. ყველა კლასს შეუძლია ჰქონდეს კონსტრუკტორები და დესტრუქტორები. როგორც ჯავაში ასევე ამ ენაში ყველა კლასი Object კლასის წარმოებაა. 
ქვევით არის მოყვანილი C#-ს კლასის მაგალითი

```csharp
class Class1
    {
        public string Saxeli = "Shota";
        public string Gvari = "Rustaveli";
        public string SaxeliDaGvari()
        {
            return Saxeli + Gvari;
        }
    }
```

კლასებს გააჩნიათ დახასიათებები და სფეროები. სფეროები წარმოადგენენ კლასში გამოხატულ ცვლადებს. წინა კლასის მაგალითში სფეროებია Saxeli და Gvari. ამ სფეროების წასაკითხად საკმარისია კლასისგან შექმნილი ობიექტის სახელს დავუმატოთ წერტილი და სფეროს სახელი.
ChemiKlasi.Saxeli. ამ შემთხვევაში ChemiKlasi არის Class1-ისგან წარმოშვებული ობიექტი, ასე რომ უნდა იყოს შექმნილი Saxeli სფერის წაკითხვამდე. თვისებები ჰგვანან სფეროებს მაგრამ იმითი გამოირჩევიან რომ უბრალოდ სფეროს წაკითხვის გარდა შეიძლება მათზე რამე დავალების დაკისრება.  მაგალითად შეგვიძლია დავწეროთ პროგრამის ისეთი ინსტრუქცია რომელიც Saxeli-ს წაკითხვის დროს მონაცემთა ბაზიდან გამოყავს მისი მნიშვნელობა.
კლასისგან ახალი ობიექტის შესაქმნელად იყენება სიტყვა new. მაგის გარეშე შეუძლებელია მისი ფუნქცუების ან სფეროების გამოყენება (სტატიკური თვისებების მქონე ფუნქციების ან სფეროების გარდა).  

```csharp
Class1 ChemiKlasi = new ChemiKlasi();
     Console.WriteLine(ChemiKlasi.Saxeli);
```

კლასების დაჯგუფებისათვის გამოყენება namespace (სახელსივრცე). Namespace-ის მეშვეობის შესაძლებელია კლასების ორგანიზება ლოგიკურ ჯგუფებად.

**მონაცემთა ტიპები** - არსებობს ორი ტიპის მონაცემი, მნიშვნელობის ტიპი და მითითების ტიპი. არსებობს აგრეთვე გარდაქმნის შეუცნობელი და დაწვრილებითი სისტემა. შეუცნობელი გარდაქმნის მაგალითია როდესაც int ტიპის ცვლადი გადაგვყავს long int ტიპში. ამ შემთხვევაში არ ვკარგავთ არანაირ ინფორმაციას რადგან long int-ის რიცხვების კრებული შეიცავს int ტიპის რიცხვების კრებულს. დაწვრილებითი გარდაქმნის შემთხვევაში შეიძლება დავკარგოთ ინფორმაცია. მაგალითად long int ცვლადმა int-ად გარდაქმნის პროცესში შესაძლებელია დაკარგოს თავისი ზუსტი მნიშვნელობის ნაწილი.

არსებობენ ერთ და მრავალ სივრციანი მწკრივები. მრავალსივრციანი მწკრივი შეიძლება იყოს მართკუთხა რომელშიც თითოეულ მწკრივს ერთი და იგივე ზომა აქვს ან დაკბილული სადაც მწკრივებს სხვადასხვა ზომა გააჩნიათ.

**ფუნქციები** - C#-ში ისევე როგორც მრავალ სხვა პროგრამირების ენებში არსებობს ფუნქციების მცნება. ფუნქცია არის კოდის გარკვეული ნაწილი რომელსაც გააჩნია სახელი,
ტიპი და პარამეტრი ან პარამეტრების სია. ფუნქციის გამოძახება შეიძლება პროგრამის ნებისმიერ მონაკვეთში, რასაც შეიძლება მოყვეს ფუნქციის მიერ დაბრუნებული შედეგის
მიღება ან უბრალოდ ნებისმიერი ოპერაციის ასრულება. ფუნქციის მიერ დაბრუნებული შედეგის ტიპი ფუნქციის ტიპი უნდა იყვეს, თუ ფუნქცია არანაირ შედეგს არ აბრუნებს მაშინ მისი ტიპი ცარიელია რაც სიტყვა void-ით აღინიშნება. ზევით მოყვანილ მაგალითში გვაქვს ფუნქცია რომლის სახელია SaxeliDaGvari, ტიპია string და პარამეტრების სია ცარიელია. სიტყვით return ფუნქცია აბრუნებს string ტიპის შედეგს რაც იმას ნიშნავს რომ მის გამოძახების ადგილში ცვლადი ან გამოსახულება string-ის ტიპის უნდა იყვეს.

პროგრამის გაშვების პირველი ანუ მთავარი ფუნქცია არის Main. მისი ტიპი ცარიელია და აქვს სტატიკური თვისება. 

```csharp
static void Main(string[] args)
     {
          ...................
     }
```

სტატიკური თვისება შეიძლება ჰქონდეს როგორც ფუნქციებს ასევე სფეროებს და იყენება ობიექტად არაწარმოებული კლასების ფუნქციების ან ცვლადების გამოყენებისას. მაგალითად Class1-ში რომ გვქონოდა სტატიკური სფერო Misamarti

```csharp
static string Misamarti = "Tbilisi, Georgia XXXXX";
```

მის წასაკითხად არ დაგვჭირდებოდა ამ კლასის ობიექტის შექმნა. უბრალოდ საკმარისია კლასის სახელს ანუ Class1-ს დავუმატოთ წერტილი და სფეროს სახელი Class1.Misamarti.

## თვისებები 
თვისებები C#-ში წარმოადგენენ visual basic-ისგან გადმოღებულ იდეას. ეს იდეა Java-სა და C++-ში არ არის გამოყენებული. თვისება არის ფუნცია ან ფუნქციების წყვილი რომელიც კოდის თვალსაზრისით წააგავს კლასის წევრს (სფერო, field). მაგალითად კლას მართკუთხედს შეიძლება ჰქონდეს თვისება სიგრძე და სიგანე.

```csharp
Martkutxedi chemiMartkutxedi = new Martkutxedi();
    chemiMartkutxedi.sigrdze = 20;
```

პირველი დანახვისას შეიძლება მოგვეჩვენოს რომ მართკუთხედის sigrdze არის ამ კლასის ობიექტის სფერო, მაგრამ სინამდვილეში ამ გამოსახულებით სრულდება
გარკვეული ბრძანება. 
იმისათვის რომ გამოვხატოთ თვისება უნდა გამოვიყენოთ ქვემოთ მოყვანილი მაგალითის სინტაქსი:

```csharp
public int Sigrdze
       {
         get
         {
          return sigrdze;
         }
         set 
         {
           // ნებისმიერი კოდი სიგრძე თვისების დასაყენებლად
         }
       }
```

get თანამონაწილეს არ გააჩნია არანაირი პარამეტრი და აბრუნებს იგივე ტიპს როგორიც არის თვითონ თვისება. set თანამონაწილეში ის ერთი პარამეტრი რომელსაც კომპილატორი მოელოდება არის ამ თვისების მნიშვნელობა.

## ანონიმური ტიპები 
C# 2008 მოყოლებული შესაძლებელია ცვლადის გამოხატვა და კომპილატორისათვის მისი ტიპის დადგენის დავალება. ამ ახალი თვისების გამოსაყენებლად იყენება var სიტყვა.
მაგალითად 

```csharp
var x = 10;
```

ამ გამოსახულების გაანალიზებისას კომპილატორი თავისით დაადგენს x ცვლადის ტიპს. ცვლადის ტიპი დგინდება მისსადმი მინიჭებული მნიშვნელობის ტიპისაგან. ჩვენს შემთხვევაში ზემოთ მოყვანილი გამოსახულება 

```csharp
int x = 10;
```

ის ტოლფასია.
var სიტყვის new სიტყვასთან გამოყენებისას შეგვიძლია შევქმნათ ანონიმური ტიპები. ეს ტიპები წარმოადგენენ უსახელო object კლასიდან წარმოებულ კლასებს.
მაგალითად

```csharp
var adamiani = new { Saxeli = "Shota", Gvari = "Rustaveli"};
```

გამოსახულება ქმნის ობიექტს Saxeli-ს და Gvari-ს თვისებებით.
თუ ჩვენ შევქმნით სხვა ობიექტს როგორიცაა

```csharp
var pexburteli = new { Saxeli = "Shota" Gvari = "Arveladze"};
```

adamiani-ს და pexburteli-ს ტიპი ერთი და იგივე ტიპს გამოხატავს. ამ შემთხვევაში ლეგიტიმურია შემდეგი გამოსახულება:

```csharp
adamiani = pexburteli;
```

ამ ობიექტების ტიპის სახელი არ არის ცნობილი. კომპილატორი თავისით იგონებს ტიპის სახელს და მხოლოდ მას შეუძლია მისი გამოყენება.

## მითითებები 
* 
* 
* 

## რესურსები ინტერნეტში 
* C# Language (MSDN)
* C# Programming Guide (MSDN)
* C# Specification (MSDN)
* [ISO C# Language Specification](http://standards.iso.org/ittf/PubliclyAvailableStandards/c042926_ISO_IEC_23270_2006(E).zip).
* Microsoft Visual C# .NET

კატეგორია:პროგრამირების ენები
კატეგორია:კლასზე დაფუძნებული დაპროგრამების ენები