लैम्ब्डा अभिव्यक्ति और सी # में संदेशबॉक्स

Question

private void SimpleLambda() 
{ 
    dynamic showMessage = x => MessageBox.Show(x); 

    showMessage("Hello World!"); 
} 

त्रुटि संदेश है: , गतिशील प्रकार के लैम्ब्डा अभिव्यक्ति कनवर्ट नहीं कर सकता क्योंकि यह एक प्रतिनिधि प्रकार

कोई मदद नहीं है,

Answer 1

private void SimpleLambda() 
{ 
    Action<string> showMessage = x => MessageBox.Show(x); 

    showMessage("Hello World!"); 
} 

Answer 2

आप घोषित करने के लिए है प्रतिनिधि प्रकार। अन्यथा यह नहीं पता होगा कि किस प्रकार का लैम्ब्डा अभिव्यक्ति — x कुछ भी हो सकता है। यह काम करना चाहिए:

Action<string> showMessage = x => MessageBox.Show(x); 

क्या इस प्रतिनिधि प्रकार है पर स्पष्टीकरण के लिए Action<T> देखें।

Answer 3

इसका MessageBox के साथ कुछ लेना देना नहीं है - क्योंकि त्रुटि संदेश कहता है, आप बस लैम्ब्डा अभिव्यक्ति को dynamic में परिवर्तित नहीं कर सकते क्योंकि संकलक को पता नहीं है कि किस प्रकार का प्रतिनिधि बनाने का उदाहरण है।

आप चाहते हैं:

Action<string> action = x => MessageBox.Show(x); 

या यहां तक ​​कि एक विधि समूह रूपांतरण का उपयोग, हालांकि तो आप वापसी प्रकार से मेल करने के लिए है:

Func<string, DialogResult> func = MessageBox.Show; 

आप तो उपयोग dynamic अगर आप चाहते हैं कर सकते हैं:

dynamic showMessage = action; // Or func 
showMessage("Hello World!"); 

वैकल्पिक रूप से, आप कर सकते हैं एक स्पष्ट प्रतिनिधि उदाहरण अभिव्यक्ति में लैम्ब्डा अभिव्यक्ति pecify:

dynamic showMessage = new Action<string>(x => MessageBox.Show(x)); 

Answer 4

मैं इस के लिए एक प्रकार निष्कर्ष सहायक बनाया। मैं वास्तव में lambdas के हस्ताक्षर को लिखकर पसंद नहीं है मैं उन्हें अस्थायी चर में संग्रहीत करने के लिए तो मैं लिखने

var fn = Func.F((string x) => MessageBox.Show(x)); 

या

var fn = Func.F((double x, double y) => x + y); 

तुम अब भी पैरामीटर signiture में डालने के लिए करना चाहते हैं लेकिन आप रिटर्न प्रकार के साथ टाइप अनुमान अनुमान दें।

कार्यान्वयन

using System; 

namespace System 
{ 
    /// <summary> 
    /// Make type inference in C# work harder for you. Normally when 
    /// you want to declare an inline function you have to type 
    /// 
    ///  Func<double, double, double> fn = (a,b)=>a+b 
    /// 
    /// which sux! With the below methods we can write 
    /// 
    ///  var fn = Func.F((double a, double b)=>a+b); 
    /// 
    /// which is a little better. Not as good as F# type 
    /// inference as you still have to declare the args 
    /// of the function but not the return value which 
    /// is sometimes not obvious straight up. Ideally 
    /// C# would provide us with a keyword fun used like 
    /// 
    ///  fun fn = (double a, double b)=>a+b; 
    /// 
    /// but till then this snippet will make it easier 
    /// 
    /// </summary> 
    public static class Func 
    { 
     public static Func<A> F<A>(Func<A> f) 
     { 
      return f; 
     } 
     public static Func<A,B> F<A, B>(Func<A, B> f) 
     { 
      return f; 
     } 
     public static Func<A,B,C> F<A, B,C>(Func<A, B,C> f) 
     { 
      return f; 
     } 
     public static Func<A,B,C,D> F<A,B,C,D>(Func<A,B,C,D> f) 
     { 
      return f; 
     } 
     public static Func<A,B,C,D,E> F<A,B,C,D,E>(Func<A,B,C,D,E> f) 
     { 
      return f; 
     } 

     public static Action A(Action f) 
     { 
      return f; 
     } 
     public static Action<_A> A<_A>(Action<_A> f) 
     { 
      return f; 
     } 
     public static Action<_A,B> A<_A, B>(Action<_A, B> f) 
     { 
      return f; 
     } 
     public static Action<_A,B,C> A<_A, B,C>(Action<_A, B,C> f) 
     { 
      return f; 
     } 
     public static Action<_A,B,C,D> A<_A,B,C,D>(Action<_A,B,C,D> f) 
     { 
      return f; 
     } 
     public static Action<_A,B,C,D,E> A<_A,B,C,D,E>(Action<_A,B,C,D,E> f) 
     { 
      return f; 
     } 
    } 

}