C# Language
फंक प्रतिनिधि

वाक्य - विन्यास

• public delegate TResult Func<in T, out TResult>(T arg)
• public delegate TResult Func<in T1, in T2, out TResult>(T1 arg1, T2 arg2)
• public delegate TResult Func<in T1, in T2, in T3, out TResult>(T1 arg1, T2 arg2, T3 arg3)
• public delegate TResult Func<in T1, in T2, in T3, in T4, out TResult>(T1 arg1, T2 arg2, T3 arg3, T4 arg4)

पैरामीटर

मापदंडों के बिना

यह उदाहरण दिखाता है कि एक प्रतिनिधि कैसे बनाया जाए जो मौजूदा समय को लौटाने वाली पद्धति को एनकैप्सुलेट करता है

static DateTime UTCNow()
{
    return DateTime.UtcNow;
}

static DateTime LocalNow()
{
    return DateTime.Now;
}

static void Main(string[] args)
{
    Func<DateTime> method = UTCNow;
    // method points to the UTCNow method
    // that retuns current UTC time  
    DateTime utcNow = method();

    method = LocalNow;
    // now method points to the LocalNow method
    // that returns local time

    DateTime localNow = method();
}

कई चर के साथ

static int Sum(int a, int b)
{
    return a + b;
}

static int Multiplication(int a, int b)
{
    return a * b;
}

static void Main(string[] args)
{
    Func<int, int, int> method = Sum;
    // method points to the Sum method
    // that retuns 1 int variable and takes 2 int variables  
    int sum = method(1, 1);

    method = Multiplication;
    // now method points to the Multiplication method

    int multiplication = method(1, 1);
}

लंबोदर और अनाम विधियाँ

एक अनाम विधि जहां एक प्रतिनिधि की उम्मीद की जाती है, उसे सौंपा जा सकता है:

Func<int, int> square = delegate (int x) { return x * x; }

लैम्ब्डा एक्सप्रेशन का उपयोग एक ही चीज़ को व्यक्त करने के लिए किया जा सकता है:

Func<int, int> square = x => x * x;

या तो मामले में, अब हम इस तरह से square अंदर संग्रहीत विधि को लागू कर सकते हैं:

var sq = square.Invoke(2);

या शॉर्टहैंड के रूप में:

var sq = square(2);

ध्यान दें कि असाइनमेंट टाइप-सुरक्षित होने के लिए, पैरामीटर प्रकार और अनाम प्रकार के रिटर्न को डेलिगेट प्रकार से मेल खाना चाहिए:

Func<int, int> sum = delegate (int x, int y) { return x + y; } // error
Func<int, int> sum = (x, y) => x + y; // error

कोवरिएंट और कॉन्ट्रावेरिएंट टाइप पैरामीटर्स

Func भी समर्थन करता है covariant और contravariant

// Simple hierarchy of classes.
public class Person { }
public class Employee : Person { }

class Program
{
    static Employee FindByTitle(String title)
    {
        // This is a stub for a method that returns
        // an employee that has the specified title.
        return new Employee();
    }

    static void Test()
    {
        // Create an instance of the delegate without using variance.
        Func<String, Employee> findEmployee = FindByTitle;

        // The delegate expects a method to return Person,
        // but you can assign it a method that returns Employee.
        Func<String, Person> findPerson = FindByTitle;

        // You can also assign a delegate 
        // that returns a more derived type 
        // to a delegate that returns a less derived type.
        findPerson = findEmployee;

    }
}