query - select entity framework 6 c#

Linq-to-Entities Clasificación dinámica

Question

Esta es mi consulta, ¿cómo puedo usar la cadena como parámetro orderby?

string sortColumn="Title";

var  items = (from ltem in ctxModel.Items
              where ltem.ItemID == vId
              orderby //something here
              select ltem).Skip(PageSize * PageIndex).Take(PageSize);

ACTUALIZAR:
No puedo simplemente ordenar por el conjunto de resultados, porque primero necesito ordenar, y solo ENTONCES a la página.

Answer 1

Al parecer, las otras alusiones a Dynamic Linq no son lo suficientemente claras. Déjame arrojar algo de luz ..

El uso de Dynamic Linq no indica necesariamente la necesidad de una dependencia de ensamblaje.

Dynamic Linq está contenido en un archivo de origen, si no me equivoco, está incluido en las muestras de C # que todos deberían haber visto al menos en algún momento en los últimos 3 años, y se pueden colocar fácilmente en un proyecto y colocar nombres para evitar colisiones. por lo tanto, proporciona servicios de creación de expresiones que pueden utilizarse donde sea que surja esta necesidad.

Considero que la capacidad para construir de forma segura una expresión a partir de una string razonablemente arbitraria, que puede construirse fácilmente sobre la marcha, es el mejor ejemplo de "dinámica".

Considerar:

    var query = northwind.Products
                         .Where("CategoryID = 3 AND UnitPrice > 3")
                         .OrderBy("SupplierID");

Answer 2

Aquí hay otra alternativa, el EntitySorter . Permite un poco lo que hace LINQ dinámico con cadenas, pero envuelve la operación en un objeto, al igual que con el patrón de Objeto de consulta . Permite tanto la clasificación por cadenas, como por tipo de construcciones seguras. Aquí hay unos ejemplos:

// Ways of defining an entity sorter
// 1. Using strings:
IEntitySorter<Person> sorter = EntitySorter<Person>
    .OrderBy("Address.City")
    .ThenByDescending("Id");

// 2. Defining a sorter with lambda''s
IEntitySorter<Person> sorter = EntitySorter<Person>
    .OrderByDescending(p => p.Name)
    .ThenBy(p => p.Id)
    .ThenByDescending(p => p.Address.City);

// 3. Using a LINQ query
IEntitySorter<Person> sorter =
    from person in EntitySorter<Person>.AsQueryable()
    orderby person.Name descending, person.Address.City
    select person;

// And you can pass a sorter from your presentation layer
// to your business layer, and you business layer may look
// like this:
static Person[] GetAllPersons(IEntitySorter<Person> sorter)
{
    using (var db = ContextFactory.CreateContext())
    {
        IOrderedQueryable<Person> sortedList =
            sorter.Sort(db.Persons);

        return sortedList.ToArray();
    }
}

Puedes encontrar el código EntitySorter .

Answer 3

Otros han sugerido el uso de enlaces dinámicos u otras bibliotecas. Personalmente , no traería una dependencia de biblioteca para una tarea tan pequeña. Pero otros dos caminos que puedes tomar son ...

• Use la sintaxis de la llamada a objetos y construya su árbol de expresiones de consulta dinámicamente Por ejemplo...

Ver http://blog.cincura.net/229310-sorting-in-iqueryable-using-string-as-column-name/

Es importante considerar la ejecución diferida en este escenario. Puede crear de forma segura su consulta que devuelva un objeto IQueryable y luego ejecutar una ordenación de consulta de objeto en ese objeto. Su consulta solo se ejecutará una vez, cuando se acceda realmente a los datos.

La publicación del blog anterior es un ejemplo de cómo puede usar la API de Expression para crear y el árbol de expresiones que puede usar para su OrderBy . Realmente suena complicado. El artículo de MSDN puede ser una mejor referencia. Vea Cómo usar los árboles de expresiones para crear consultas dinámicas en MSDN.

O

• Use la ruta simple y solo use un interruptor en el título para toda la consulta.

P.ej.

ItemType items = default(ItemType);
switch(sortColumn)
{
     case "Title":
     {
           items = ctxModel.Items
                    .Where(i => i.ItemID == vId)
                    .OrderBy( i => i.Title);
     }
     break;
 }

Answer 4

Parece que esa consulta está usando un enlace de datos personalizado y / o ObjectDataSource, sin embargo, hay una manera de hacerlo usando un método de extensión que toma una expresión de clasificación y agrega dinámicamente una llamada (expresión) OrderBy () a la consulta de linq. Documenté cómo en la publicación del blog hace un tiempo, que casualmente formaba parte de esta pregunta de SO . Si necesita más que eso, puede usar linq dinámico que está bien documentado por scottgu.

EDITAR: usar el método de extensión haría que parezca

string sortColumn="Title";

    var  items = (from ltem in ctxModel.Items
                  where ltem.ItemID == vId
                  select ltem).Skip(PageSize * PageIndex).Take(PageSize).OrderBy(sortColumn);

Answer 5

Yo uso este ayudante:

public static class OrderExt
{
    private static IOrderedQueryable<T> Order<T>(this IQueryable<T> source, string propertyName, SortDirection descending, bool anotherLevel = false)
    {
        var param = Expression.Parameter(typeof(T), string.Empty);
        var property = Expression.PropertyOrField(param, propertyName);
        var sort = Expression.Lambda(property, param);

        var call = Expression.Call(
            typeof (Queryable),
            (!anotherLevel ? "OrderBy" : "ThenBy") +
            (descending == SortDirection.Descending ? "Descending" : string.Empty),
            new[] {typeof (T), property.Type},
            source.Expression,
            Expression.Quote(sort));

        return (IOrderedQueryable<T>)source.Provider.CreateQuery<T>(call);
    }
}

para llamar al ayudante, por ejemplo, haga esto:

string sort = HttpContext.Current.Request.QueryString["sort"];
var products = _productRepository.OrderBy(sort, SortDirection.Ascending);