Syntax to execute code block inside Linq query?

Question

Here's some code that (obviously) doesn't compile:

var q = from x in myAnonymousTypeCollection
        select new {
          x.ID,
          CalcField = { 
                        switch(x.SomeField) {
                          case 1:
                            return Math.Sqrt(x.Field1);
                          case 2:
                            return Math.Pow(x.Field2, 2);
                          default:
                            return x.Field3;
                        }
                      }
        };

You get the picture; I'm trying to calculate CalcField in a completely different way, depending on what the value of SomeField is. I can't use a Func<> (or can I?), because the input type is anonymous. So what's the right syntax to get this to work?

Answer 1

First off, I usually prefer the method chain syntax over the query syntax for Linq. With that you can do this easily.

var q = myAnonymousTypeCollection
    .Select(x => 
            {
                object calcField; 

                 switch(x.SomeField) 
                 {
                      case 1:
                        calcField = Math.Sqrt(x.Field1);
                      case 2:
                        calcField =  Math.Pow(x.Field2, 2);
                      default:
                        calcField = x.Field3;

                 return new 
                        {
                            x.ID,
                            CalcField = calcField
                        };
            });

Without using method chains, you need either a method or an Func. Let's assume a Func

//replace these with actual types if you can.
Func<dynamic, dynamic> calculateField = 
    x => 
    {
        switch(x.SomeField) {
            case 1:
                return Math.Sqrt(x.Field1);
            case 2:
                return Math.Pow(x.Field2, 2);
            default:
                return x.Field3;
    }

var q = from x in myAnonymousTypeCollection
        select new { x.Id, CalcField = calculateField(x) };

Note: I didn't write this in an IDE, so please excuse any simple errors.

Here is the MSDN for dynamic. However, I have found that once you need to start passing anonymous types around, it is best to make an actual class.

Answer 2

You could wrap your anonymous function as a (self-executing) Func<> delegate. This assumes you know the return type.

var q = from x in myAnonymousTypeCollection
    select new {
      ID = x.ID,
      CalcField = new Func<double>( () => { 
                    switch(x.SomeField) {
                      case 1:
                        return Math.Sqrt(x.Field1);
                      case 2:
                        return Math.Pow(x.Field2, 2);
                      default:
                        return x.Field3;
                    }
                  } )()
    };