Expresión dinámica utilizando LINQ. ¿Cómo encontrar las cocinas?

Question

Intento implementar un filtro dinámico de usuario, donde se usan algunas propiedades, selecciona algunos operadores y también selecciona los valores.

Como no he encontrado todavía una respuesta a this question, traté de usar expresiones LINQ.
Principalmente necesito identificar todas las casas cuyas habitaciones principales son cocinas (cualquier sentido, lo sé).

using System; 
using System.Collections.Generic; 
using System.Linq; 
using System.Linq.Expressions; 
//using System.Linq.Dynamic; 

namespace ConsoleApplication2 
{ 
    class Program 
    { 
     static void Main(string[] args) 
     { 
      Room aRoom = new Room() { Name = "a Room" }; 
      Room bRoom = new Room() { Name = "b Room" }; 
      Room cRoom = new Room() { Name = "c Room" }; 

      House myHouse = new House 
      { 
       Rooms = new List<Room>(new Room[] { aRoom }), 
       MainRoom = aRoom 
      }; 
      House yourHouse = new House() 
      { 
       Rooms = new List<Room>(new Room[] { bRoom, cRoom }), 
       MainRoom = bRoom 
      }; 
      House donaldsHouse = new House() 
      { 
       Rooms = new List<Room>(new Room[] { aRoom, bRoom, cRoom }), 
       MainRoom = aRoom 
      }; 

      var houses = new List<House>(new House[] { myHouse, yourHouse, donaldsHouse }); 

      //var kitchens = houses.AsQueryable<House>().Where("MainRoom.Type = RoomType.Kitchen"); 
      //Console.WriteLine("kitchens count = {0}", kitchens.Count()); 

      var houseParam = Expression.Parameter(typeof(House), "house"); 
      var houseMainRoomParam = Expression.Property(houseParam, "MainRoom"); 
      var houseMainRoomTypeParam = Expression.Property(houseMainRoomParam, "Type"); 

      var roomTypeParam = Expression.Parameter(typeof(RoomType), "roomType"); 

      var comparison = Expression.Lambda(
       Expression.Equal(houseMainRoomTypeParam, 
       Expression.Constant("Kitchen", typeof(RoomType))) 
       ); 

      // ???????????????????????? DOES NOT WORK 
      var kitchens = houses.AsQueryable().Where(comparison); 

      Console.WriteLine("kitchens count = {0}", kitchens.Count()); 
      Console.ReadKey(); 

     } 
    } 

    public class House 
    { 
     public string Address { get; set; } 
     public double Area { get; set; } 
     public Room MainRoom { get; set; } 
     public List<Room> Rooms { get; set; } 
    } 

    public class Room 
    { 
     public double Area { get; set; } 
     public string Name { get; set; } 
     public RoomType Type { get; set; } 
    } 

    public enum RoomType 
    { 
     Kitchen, 
     Bedroom, 
     Library, 
     Office 
    } 
} 

Answer 1

var kitchens = from h in houses 
       where h.MainRoom.Type == RoomType.Kitchen 
       select h; 

Pero debe establecer la propiedad RoomType en las habitaciones antes.

Ok, editar:

por lo que debe volver a definir:

var comparison = Expression.Lambda<Func<House, bool>>(... 

Entonces, cuando lo utiliza:

var kitchens = houses.AsQueryable().Where(comparison.Compile()); 

Edición # 2:

Ok, aquí ir:

var roomTypeParam = Expression.Parameter(typeof(RoomType), "roomType"); 



// ???????????????????????? DOES NOT WORK 
var comparison = Expression.Lambda<Func<House, bool>>(
    Expression.Equal(houseMainRoomTypeParam, 
    Expression.Constant(Enum.Parse(typeof(RoomType), "Kitchen"), typeof(RoomType))), houseParam); 



// ???????????????????????? DOES NOT WORK 
var kitchens = houses.AsQueryable().Where(comparison); 

Edición # 3: de, para sus necesidades, estoy fuera de ideas por ahora. Te doy una última:

Declarar un método de extensión sobre el tipo String:

internal static object Prepare(this string value, Type type) 
{ 
    if (type.IsEnum) 
     return Enum.Parse(type, value); 

    return value; 
} 

luego usarlo en esa expresión como:

Expression.Constant("Kitchen".Prepare(typeof(RoomType)), typeof(RoomType)) 

Eso es porque al parecer las enumeraciones son tratados de manera diferente. Esa extensión dejará la cadena inalterada para otros tipos. Drawback: tiene que agregar otro typeof() allí.

Answer 2

qué pasa con esto

var kitchens = houses 
       .SelectMany(h => h.Rooms, (h, r) => new {House = h, Room = r}) 
       .Where(hr => hr.Room.Type == RoomType.Kitchen) 
       .Select(hr => hr.House); 

Answer 3

// ???????????????????????? DOES NOT WORK 
var kitchens = houses.AsQueryable().Where(comparison); 

El método Where toma un Func<House, bool> o una Expression<Func<House, bool>> como el parámetro, pero la variable comparison es de tipo LambdaExpression, que no coincide. Es necesario utilizar otra sobrecarga del método:

var comparison = Expression.Lambda<Func<House, bool>>(
       Expression.Equal(houseMainRoomTypeParam, 
       Expression.Constant("Kitchen", typeof(RoomType)))); 
//now the type of comparison is Expression<Func<House, bool>> 

//the overload in Expression.cs 
public static Expression<TDelegate> Lambda<TDelegate>(Expression body, params ParameterExpression[] parameters); 

Answer 4

no edificar la cláusula where de esa manera - Creo que es más complejo de lo que debe ser para sus necesidades. En su lugar, se pueden combinar en cláusulas como esta:

var houses = new List<House>(new House[] { myHouse, yourHouse, donaldsHouse }); 

// A basic predicate which always returns true: 
Func<House, bool> housePredicate = h => 1 == 1; 

// A room name which you got from user input: 
string userEnteredName = "a Room"; 

// Add the room name predicate if appropriate: 
if (!string.IsNullOrWhiteSpace(userEnteredName)) 
{ 
    housePredicate += h => h.MainRoom.Name == userEnteredName; 
} 

// A room type which you got from user input: 
RoomType? userSelectedRoomType = RoomType.Kitchen; 

// Add the room type predicate if appropriate: 
if (userSelectedRoomType.HasValue) 
{ 
    housePredicate += h => h.MainRoom.Type == userSelectedRoomType.Value; 
} 

// MainRoom.Name = \"a Room\" and Rooms.Count = 3 or 
// ????????????????????????? 
var aRoomsHouses = houses.AsQueryable<House>().Where(housePredicate); 

me probaron éste, honesto :)

Answer 5

Para añadir un nuevo tipo de Enum dinámica LINQ, debe agregar el siguiente código:

typeof(Enum), 
typeof(T) 

T : Enum type 

en tipos predefinidos de dinámica. Funciona para mi.