დელეგატები (4/5) - Func და Action

 

ეს ორი ტიპის დელეგატი ძალიან აადვილებს დელეგატების გამოყენებას ზოგადად და ზუსტად ჯდება lambda Expression ების მოთხოვნილებაში, რომელიც წინა პოსტში მიმოვიხილე. ჩემი აზრით, ისინი ავსებენ ერთმანეთს და უფრო კომფორტულად ხდება მათი ერთობლივად გამოყენება. ასევე ყველა სხვდასხვა ტიპის მეთოდისათვის რომ არ მოგიწიოთ სხვადასხვა დელეგატის განსაზღვრა სხვადასხვა პარამეტრისა და დასაბრუნებელი ტიპით, უბრალოდ საჭიროა ამ ორი ხელსაყრელი დელეგატის ტიპის გამოყენება. იმის გასაგებად თუ რატომ შემოგვთავაზეს C# ორი სახის დელეგატი, უნდა ვნახოთ რომელიც დელეგატი რა სპეციალიზაციით გამოიყენება.

ზოგადი (generic) Action<T> დელეგატი, რომელშიც შეიძლება შევიდეს ის მეთოდები, რომლებიც void ტიპის მეთოდს წარმოადგენენ, არსებობს რამდენიმე სახის, რაც იმას ნიშნავს, რომ შესაძლებელია ამ ტიპის დელეგატში გაატაროთ 16 მდე სხვადასხვა პარამეტრი. Action კლასი პარამეტრების გარეშე გამოიყენება იმ void ტიპის მეთოდებისათვის, რომლებსაც არ გააჩნიათ პარამეტრი. ერთ პარამეტრიანი Action ტიპის დელეგატის განსასაზღვრად შემდეგი კოდი სრულყოფილად იმუშავებს პროგრამაში.

Action<in T>

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

Action<in T1, in T2, in T3, in T4, in T5, in T6, in T7, in T8>

Funk<T> დელეგატიც შესაბამისად შეიძლება გამოყენებულ იქნას. მაგრამ Action<T> სა და Func<T> ს შორის განსხვავება ის არის, რომ Func<T> ის გამოყენებით შესაძლებელია ისეთი მეთოდის გამოძახება, რომელსაც გააჩნია დასაბრუნებელი ტიპი, ანუ აბრუნებს მნიშვნელობას. ასევე არსებობს Func<T> ს სხვადასხვა ვარიაცია, რომლებშიც შესაძლებელია 16 მდე პარამეტრის გატარება და ბოლოს შედეგის დაბრუნება. 

Func<in T1, in T2, in T3, in T4, out TResult>

ზემოთ მოცემული დელეგატი არის 4 პარამეტრიანი მეთოდისათვის. ჩვეულებრივი დელეგატი, რომ გამოგეყენებინათ ასეთი რამ გექნებოდათ:

delegate int mydel(int x, int y);

სტანდარტული დელეგატის განსაზღვრის მაგივრად შესაძლებელია განვსაზღვროთ Func<T> ტიპის დელეგატი, რომლის მუშაობის პრინციპსაც ახლა ვნახავთ და ვნახეთ წინა პოსტში - პოსტის სახელი.

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

namespace BlogSpotAppConsole

{

    class Program

    {

        static void Main()

        {

            Func<double, double>[] Del =

            {

                method1,

                method2

            };

 

            Console.WriteLine("val = 4");

            Console.WriteLine("new val = {0}", Del[0](Del[1](4)));

 Console.ReadKey();

        }

        public static double method1(double val)

        {

            return val * val;

        }

        public static double method2(double val)

        {

            return 2 * val;

        }

    }

}

ზემოთ შეიძლება თავიდან გაუგებრობა იყოს, მაგრამ ერთი რაც რეალურად ბუნდოვანი შეიძლება იყოს, ჩემი აზრით არის ეს ->  Del[0](Del[1](4)), რაც იგივეა, რომ დაგეწერათ

method1 ( method2 ( 4 ) )

ჯერ შესრულდებოდა method2(4), რომელიც დააბრუნებდა 8ს, ხოლო შემდეგ 8 იქნებოდა method1 (8) ს პარამეტრი და ის დააბრუნებდა 64, ხოლო პროგრამა მთლიანობაში დააბრუნებს 64, როგორ ნახეთ.