ეს ორი ტიპის დელეგატი ძალიან აადვილებს დელეგატების გამოყენებას ზოგადად და ზუსტად ჯდება lambda Expression ების მოთხოვნილებაში, რომელიც წინა პოსტში მიმოვიხილე. ჩემი აზრით, ისინი ავსებენ ერთმანეთს და უფრო კომფორტულად ხდება მათი ერთობლივად გამოყენება. ასევე ყველა სხვდასხვა ტიპის მეთოდისათვის რომ არ მოგიწიოთ სხვადასხვა დელეგატის განსაზღვრა სხვადასხვა პარამეტრისა და დასაბრუნებელი ტიპით, უბრალოდ საჭიროა ამ ორი ხელსაყრელი დელეგატის ტიპის გამოყენება. იმის გასაგებად თუ რატომ შემოგვთავაზეს C# ორი სახის დელეგატი, უნდა ვნახოთ რომელიც დელეგატი რა სპეციალიზაციით გამოიყენება.
}
ზოგადი (generic) Action<T> დელეგატი, რომელშიც შეიძლება შევიდეს ის მეთოდები, რომლებიც void ტიპის მეთოდს წარმოადგენენ, არსებობს რამდენიმე სახის, რაც იმას ნიშნავს, რომ შესაძლებელია ამ ტიპის დელეგატში გაატაროთ 16 მდე სხვადასხვა პარამეტრი. Action კლასი პარამეტრების გარეშე გამოიყენება იმ void ტიპის მეთოდებისათვის, რომლებსაც არ გააჩნიათ პარამეტრი. ერთ პარამეტრიანი Action ტიპის დელეგატის განსასაზღვრად შემდეგი კოდი სრულყოფილად იმუშავებს პროგრამაში.
Action<inT>
თუ საჭიროა მეთოდის გამოძახება, რომელიც 8 პარამეტრს შეიცავს მაშინ შესაბამისი კოდს ასეთი სახე ექნება
Action<inT1, in T2, inT3, in T4, inT5, in T6, inT7, in T8>
Funk<T> დელეგატიც შესაბამისად შეიძლება გამოყენებულ იქნას. მაგრამ Action<T> სა და Func<T> ს შორის განსხვავება ის არის, რომ Func<T> ის გამოყენებით შესაძლებელია ისეთი მეთოდის გამოძახება, რომელსაც გააჩნია დასაბრუნებელი ტიპი, ანუ აბრუნებს მნიშვნელობას. ასევე არსებობს Func<T> ს სხვადასხვა ვარიაცია, რომლებშიც შესაძლებელია 16 მდე პარამეტრის გატარება და ბოლოს შედეგის დაბრუნება.
Func<inT1, in T2, inT3, in T4, outTResult>
ზემოთ მოცემული დელეგატი არის 4 პარამეტრიანი მეთოდისათვის. ჩვეულებრივი დელეგატი, რომ გამოგეყენებინათ ასეთი რამ გექნებოდათ:
delegate intmydel(int x, inty);
სტანდარტული დელეგატის განსაზღვრის მაგივრად შესაძლებელია განვსაზღვროთ Func<T> ტიპის დელეგატი, რომლის მუშაობის პრინციპსაც ახლა ვნახავთ და ვნახეთ წინა პოსტში - პოსტის სახელი.
usingSystem;
usingSystem.Collections.Generic;
usingSystem.Linq;
usingSystem.Text;
usingSystem.Threading.Tasks;
namespaceBlogSpotAppConsole
{
class Program
{
static voidMain()
{
Func<double, double>[] Del =
{
method1,
method2
};
Console.WriteLine("val = 4");
Console.WriteLine("new val = {0}", Del[0](Del[1](4)));
Console.ReadKey();
}
public static doublemethod1(double val)
{
returnval * val;
}
public static doublemethod2(double val)
{
return2 * val;
}
}
ზემოთ შეიძლება თავიდან გაუგებრობა იყოს, მაგრამ ერთი რაც რეალურად ბუნდოვანი შეიძლება იყოს, ჩემი აზრით არის ეს -> Del[0](Del[1](4)), რაც იგივეა, რომ დაგეწერათ
method1 ( method2 ( 4 ) )
ჯერ შესრულდებოდა method2(4), რომელიც დააბრუნებდა 8ს, ხოლო შემდეგ 8 იქნებოდა method1 (8) ს პარამეტრი და ის დააბრუნებდა 64, ხოლო პროგრამა მთლიანობაში დააბრუნებს 64, როგორ ნახეთ.
No comments:
Post a Comment