c# सी#में कॉलबैक



.net callback (4)

मुझे एक लाइब्रेरी है, जिसमें उसमें एक फ़ंक्शन होगा जो उसके पैरामीटर के लिए ऑब्जेक्ट स्वीकार करता है।

इस ऑब्जेक्ट के साथ मैं एक विशिष्ट फ़ंक्शन कॉल करने में सक्षम होना चाहता हूँ जब एक्स समाप्त हो जाता है कॉल करने वाले फ़ंक्शन को कॉलर द्वारा निर्दिष्ट किया जाना है, और एक्स को पुस्तकालय द्वारा किया जाएगा और मॉनिटर किया जाएगा।

मैं यह कैसे कर सकता हूँ?

संदर्भ के लिए मैं सी # और .NET 3.5 का उपयोग कर रहा हूँ


Answer #1

प्रतिनिधियों के लिए एक सही नुस्खे की तरह लगता है - विशेष रूप से, प्रतिनिधियों के साथ कॉलबैक वास्तव में ठीक है कि यह किस तरह एनएकेनेट में अतुल्यकालिक पैटर्न में नियंत्रित किया जाता है।

कॉलर आमतौर पर आपको कुछ राज्य और एक प्रतिनिधि देता है, और आप दोनों को उन संदर्भों में संग्रहीत करते हैं जो आपके पास मिलते हैं, फिर प्रतिनिधि को राज्य से गुजरते हुए और जो भी परिणाम हो सकते हैं, उसे बुलाओ।

आप या तो राज्य को केवल object या संभावित रूप से एक सामान्य प्रतिनिधि का उपयोग कर सकते हैं और उपयुक्त प्रकार की स्थिति ले सकते हैं, उदाहरण के लिए

public delegate void Callback<T>(T state, OperationResult result)

फिर:

public void DoSomeOperation(int otherParameterForWhateverReason,
                            Callback<T> callback, T state)

जैसा कि आप .NET 3.5 का उपयोग कर रहे हैं, आप मौजूदा Func<...> और Action<...> प्रतिनिधि प्रकारों का उपयोग करना चाहते हैं, लेकिन आपको यह मिल सकता है कि यह आपकी खुद की घोषणा करने के लिए स्पष्ट बनाता है (नाम यह स्पष्ट कर सकता है कि आप इसके लिए क्या उपयोग कर रहे हैं।)


Answer #2

एक प्रतिनिधि प्रदान करें और एक अज्ञात प्रतिनिधि या लम्बा अभिव्यक्ति का उपयोग करें

public static void DoWork(Action processAction)
{
  // do work
  if (processAction != null)
    processAction();
}

public static void Main()
{
  // using anonymous delegate
  DoWork(delegate() { Console.WriteLine("Completed"); });

  // using Lambda
  DoWork(() => Console.WriteLine("Completed"));
}

या एक अंतरफलक का उपयोग करें

public interface IObjectWithX
{
  void X();
}

public class MyObjectWithX : IObjectWithX
{
  public void X()
  {
    // do something
  }
}

public class ActionClass
{
  public static void DoWork(IObjectWithX handlerObject)
  {
    // do work
    handlerObject.X();
  }
}

public static void Main()
{
  var obj = new MyObjectWithX()
  ActionClass.DoWork(obj);
}

Answer #3

आप का उपयोग कर सकते हैं System.Action कॉलबैक कार्यों के लिए सी # .NET में उपलब्ध है। कृपया इस नमूना उदाहरण की जांच करें:

    //Say you are calling some FUNC1 that has the tight while loop and you need to 
    //get updates on what percentage the updates have been done.
    private void ExecuteUpdates()
    {
        Func1(Info => { lblUpdInfo.Text = Info; });
    }

    //Now Func1 would keep calling back the Action specified in the argument
    //This System.Action can be returned for any type by passing the Type as the template.
    //This example is returning string.
    private void Func1(System.Action<string> UpdateInfo)
    {
        int nCount = 0;
        while (nCount < 100)
        {
            nCount++;
            if (UpdateInfo != null) UpdateInfo("Counter: " + nCount.ToString());
            //System.Threading.Thread.Sleep(1000);
        }
    }

Answer #4

क्या ऑपरेशन पूरा होने पर आपकी लाइब्रेरी को एक सार्वजनिक कार्यक्रम नहीं दिया जाना चाहिए जिससे निकाल दिया जाए? फिर कॉलर सिर्फ घटना को संभालने के लिए पंजीकरण कर सकता है और आपको ऑब्जेक्ट या प्रतिनिधि के पास जाने के बारे में चिंता करने की आवश्यकता नहीं है।

आपके द्वारा उपलब्ध कराए गए इंटरफ़ेस को कार्यान्वित करने वाला ऑब्जेक्ट काम करेगा, लेकिन ऐसा लगता है कि जावा का दृष्टिकोण .नेट दृष्टिकोण से अधिक है। घटनाएं मेरे लिए थोड़ा क्लीनर लगती हैं





callback