C# interruptor en la expresión lambda

Question

¿Es posible tener un interruptor en una expresión lambda? Si no, ¿por qué? Resharper lo muestra como un error.

Answer 1

Puede lambda en un bloque de instrucciones:

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

Pero no se puede hacer en una "expresión lambda única", por lo que este no es válida:

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

Esto significa que puede No uso el modificador en un árbol de expresiones (al menos como lo genera el compilador de C#; creo que .NET 4.0 al menos tiene soporte para él en las bibliotecas).

Answer 2

Hmm, no veo ninguna razón por la que esto no debería funcionar. Solo tenga cuidado con la sintaxis que usa

param => { 
    // Nearly any code! 
} 

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

param => JustASingleExpression (No switches) 

Answer 3

Sí, funciona, pero debe poner su código en un bloque. Ejemplo:

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

Luego, para lo llaman:

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

         default: 
          return false; 
        } 
       }); 

Answer 4

he comprobado también :-)

[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)); 
} 

funciona bien (salidas "Pitufo")!

Answer 5

En una pura Expression (en .NET 3.5), el más cercano que puedes conseguir es un compuesto condicional:

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

No es divertido, especialmente cuando se pone compleja. Si se refiere a una expresión lambda con un cuerpo de la declaración (sólo para uso con LINQ a Objetos), entonces cualquier cosa es legal dentro de las llaves:

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

Por supuesto, es posible que pueda subcontratar el trabajo; por ejemplo, LINQ a SQL permite asignar una UDF escalar (en la base de datos) a un método en el contexto de datos (que no se utiliza en realidad) - por ejemplo:

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

donde es MapType un UDF que hace el trabajo en el servidor de db.