ფუნქციის პარამეტრები

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

პირველი რაზეც ყურადღება უნდა გავამახვილოთ out და ref მოდიფიკატორებია. C#, და ასევე სხვა ენებიც, განასხვავებენ ორი ტიპის პარამეტრებს: "by value (მნიშვნელობით)" და "by reference (ბმულით)". C#-ში ნაგულისხმევია "by value (მნიშვნელობით)" პარამეტრი, რაც ნიშნავს, რომ როდესაც ფუნქციას ცვლადს ატანთ სინამდვილეში ამ ობიექტის ასლს გადასცემთ. ეს ასევე იმას ნიშნავს რომ ფუნქციის შიგნით შეგიძლიათ ეს ობიექტი შეცვალოთ და ამით გავლენა არ მოახდინოთ ობიექტის ორიგინალზე რომელიც პარამეტრად გადაეცით.

ref და out საკვანძო სიტყვების გამოყენებით შეგიძლიათ ეს ქმედება შეცვალოთ, ასე რომ ობიექტის მნიშვნელობის მაგივრად ჩვენ გადავცემთ ამ ობიექტის ბმულს (reference).

ref მოდიფიკატორი

განვიხილოთ შემდეგი მაგალითი:

static void Main(string[] args)
{
    int number = 20;
    AddFive(number);
    Console.WriteLine(number);
    Console.ReadKey();
}

static void AddFive(int number)
{
    number = number + 5;
}

ვქმნით მთელ რიცხვს, რომელსაც ვანიჭებთ 20-ს, შემდეგ ვიყენებთ AddFive() მეთოდს, რომელმაც ამ რიცხვს 5 უნდა დაუმატოს. მაგრამ აკეთებს ამას? არა. მნიშვნელობა რომელიც ფუნქციის შიგნით მივანიჭეთ, ფუნქციის გარეთ არასდროს გამოდის, რადგან ჩვენ ამ რიცხვის მნიშვნელობის ასლს გადავცემთ და არა მის ბმულს (reference). აი ასე მუშაობს C# და ეს ხშირად სასურველი ქმედებაა. თუმცა, ამ სიტუაციაში, გვინდა რომ ფუნქციის შიგნით ეს რიცხვი შეიცვალოს. შეიყვანეთ ref საკვანძო სიტყვა.

static void Main(string[] args)
{
    int number = 20;
    AddFive(ref number);
    Console.WriteLine(number);
    Console.ReadKey();
}

static void AddFive(ref int number)
{
    number = number + 5;
}

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

out მოდიფიკატორი

out მოდიფიკატორი ref მოდიფიკატორის მსგავსად მუშაობს. ორივე უზრუნველყოფს რომ პარამეტრი მნიშვნელობის მაგივრად ბმულით (by reference) გადაეცეს, მაგრამ მათ შორის ორი მნიშვნელოვანი განსხვავებაა. მეთოდისთვის ობიექტის ref მოდიფიკატორით გადაცემისას ობიექტს აუცილებლად უნდა ჰქონდეს მნიშვნელობა მინიჭებული. ეს არ არის მართალი out მოდიფიკატორისთვის, სადაც შეგიძლიათ არაინიციალიზებული ანუ მიუნიჭებელი ობიექტი გადასცეთ. მეორე მხრივ, როდესაც ფუნქცია out პარამეტრს იღებს არ შეიძლება ეს ფუნქცია ისე სრულდებოდეს რომ ამ პარამერტს მის შიგნით მნიშვნელობა არ მიენიჭოს. იქიდან გამომდინარე, რომ out პარამეტრის ადგილას მიუნიჭებელი მნიშვნელობა შეგიძლიათ გადასცეთ ფუნქციის შიგნით არ შეგიძლიათ ამ პარამეტრის გამოყენება, თქვენ მხოლოდ მასზე მნიშვნელობის მინიჭება შეგიძლიათ.

out გამოიყენოთ თუ ref სიტუაციაზეა დამოკიდებული, ამას მაშინ გაიაზრებთ როდესაც მათ გამოყენებას დაიწყებთ. ორივე მათგანი იმ საკითხთან არის კავშირში რომ C#-ში ფუნქციას მხოლოდ ერთი მნიშვნელობის დაბრუნება შეუძლია.

out მოდიფიკატორის გამოყენება ref მოდიფიკატორის ანალოგიურად ხდება. უბრალოდ ref საკვანძო სიტყვა out-ით შეცვალეთ. ასევე არ გადავიწყდეთ მეთოდის შიგნით მინიჭებული მნიშვნელობის მოშორება და მისი გამოცხადება ფუნქციის დაძახების მომენტში.

params მოდიფიკატორი

აქამდე, ჩვენი ყველა ფუნქცია ფიქსირებული რაოდენობის პარამეტრს იღებდა. თუმცა, ზოგიერთ სიტუაციაში, შესაძლოა დაგჭირდეთ ისეთი ფუნქცია რომელიც ნებისმიერი რაოდენობის პარამეტრს იღებს. რა თქმა უნდა, ეს პრობლემა შეიძლება მასივის ან სიის პარამეტრად მიღებით გადაწყდეს, აი ასე:

static void GreetPersons(string[] names) { }

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

GreetPersons(new string[] { "John", "Jane", "Tarzan" });

მისაღებია, მაგრამ უკეთესადაც შეიძლება, params საკვანძო სიტყვის გამოყენებით:

static void GreetPersons(params string[] names) { }

ამ შემთხვევაში გამოძახების მომენტი ასე გამოიყურება:

GreetPersons("John", "Jane", "Tarzan");

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

static void Main(string[] args)
{
    GreetPersons(0);
    GreetPersons(25, "John", "Jane", "Tarzan");
    Console.ReadKey();
}

static void GreetPersons(int someUnusedParameter, params string[] names)
{
    foreach(string name in names)
    Console.WriteLine("Hello, " + name);
}