सी # लैम्ब्डा अभिव्यक्ति में स्विच

Question

क्या लैम्ब्डा अभिव्यक्ति में स्विच करना संभव है? अगर नहीं, क्यों? Resharper इसे एक त्रुटि के रूप में प्रदर्शित करते हैं।

Answer 1

आप एक बयान ब्लॉक लैम्ब्डा में कर सकते हैं:

Action<int> action = x => 
{ 
    switch(x) 
    { 
    case 0: Console.WriteLine("0"); break; 
    default: Console.WriteLine("Not 0"); break; 
    } 
}; 

लेकिन अगर आप एक "एकल अभिव्यक्ति लैम्ब्डा" में यह नहीं कर सकते, तो यह अमान्य है:

// This won't work 
Expression<Func<int, int>> action = x => 
    switch(x) 
    { 
    case 0: return 0; 
    default: return x + 1; 
    }; 

यह आपको इसका मतलब कर सकते हैं अभिव्यक्ति वृक्ष में स्विच का उपयोग न करें (कम से कम सी # कंपाइलर द्वारा उत्पन्न किया गया; मेरा मानना ​​है कि कम से कम .NET 4.0 पुस्तकालयों में इसके लिए समर्थन करता है)।

Answer 2

हम्म, मुझे कोई कारण नहीं दिखता कि यह क्यों काम नहीं करना चाहिए। बस

param => { 
    // Nearly any code! 
} 

delegate (param) { 
    // Nearly any code! 
} 

param => JustASingleExpression (No switches) 

Answer 3

हाँ, यह काम करता है, लेकिन आपको अपना कोड ब्लॉक में रखना होगा। उदाहरण:

private bool DoSomething(Func<string, bool> callback) 
{ 
    return callback("FOO"); 
} 

फिर, इसे कहते हैं:

DoSomething(val => 
       { 
        switch (val) 
        { 
         case "Foo": 
          return true; 

         default: 
          return false; 
        } 
       }); 

Answer 4

मैं भी :-)

[Test] 
public void SwitchInLambda() 
{ 
    TakeALambda(i => { 
     switch (i) 
     { 
      case 2: 
       return "Smurf"; 
      default: 
       return "Gnurf"; 
     } 
    }); 
} 

public void TakeALambda(Func<int, string> func) 
{ 
    System.Diagnostics.Debug.WriteLine(func(2)); 
} 

वर्क्स जाँच ठीक (आउटपुट "Smurf")!

Answer 5

में एक शुद्ध Expression (.NET 3.5 में), निकटतम आप प्राप्त कर सकते हैं सशर्त एक यौगिक है:

Expression<Func<int, string>> func = x => 
     x == 1 ? "abc" : (
     x == 2 ? "def" : (
     x == 3 ? "ghi" : 
       "jkl")); /// yes, this is ugly as sin... 

मज़ा नहीं है, खासकर जब यह जटिल हो जाता है। आप एक बयान शरीर (केवल LINQ करने वाली वस्तुओं के साथ उपयोग के लिए) के साथ एक lamda अभिव्यक्ति मतलब है, तो कुछ भी ब्रेसिज़ के अंदर कानूनी है:

Func<int, string> func = x => { 
     switch (x){ 
      case 1: return "abc"; 
      case 2: return "def"; 
      case 3: return "ghi"; 
      default: return "jkl"; 
     } 
    }; 

बेशक

, आप काम आउटसोर्स करने के लिए सक्षम हो सकता है;

var qry = from cust in ctx.Customers 
      select new {cust.Name, CustomerType = ctx.MapType(cust.TypeFlag) }; 

जहां MapType है: उदाहरण के लिए - उदाहरण के लिए, LINQ करने वाली एसक्यूएल आप डेटा-प्रसंग पर एक पद्धति के लिए (डेटाबेस में) एक अदिश यूडीएफ (जो वास्तव में नहीं किया जाता है) को मैप करने के लिए अनुमति देता है एक यूडीएफ जो डीबी सर्वर पर काम करता है।