Entity Framework linq orderby Funktion

Question

Ich bin neu in Entity Framework und linq. Ich arbeite mit asp.net mvc 5 und C#. ich eine Abfrage mit dynamischer Sortierung wie folgt schreiben:

public static IEnumerable<T> OrderByDynamic<T>(this IEnumerable<T> source, string propertyName, bool Ascending) 
{ 
    if (Ascending) 
     return source.OrderBy(x => x.GetType().GetProperty(propertyName).GetValue(x, null)); 
    else 
     return source.OrderByDescending(x => x.GetType().GetProperty(propertyName).GetValue(x, null)); 
    } 

und in meinem Repository kann ich schreiben:

string sortExpr = "name"; 
_objDB.hotels.Where(s => (s.city_id = 1)) 
      .OrderByDynamic(sortExpr, Ascending).ToList(); 

Dieser Code funktioniert gut, wenn sie auf einer Spalte einer Tabelle ist das Sortieren, aber ich brauche nach einer SQL-Funktion sortieren. Ich trat in die Funktion in das .edmx Modell mit dem folgenden Code

[EdmFunction("hotelReservation.Core.Data", "getHotelMinPrice_cap")] 
public static int getHotelMinPrice_cap(int Hotel_id, int capacity, DateTime enter_date, DateTime exit_date) 
{ 
    throw new NotSupportedException("Direct calls are not supported."); 
} 

und meiner SQL-Auswahl ist so etwas wie:

select * 
from hotel 
where city_id = 1 
order by dbo.getHotelMinPrice_cap(hotel.id,1,'2001-01-01', '2021-01-01') 

Wie kann ich die letzte SQL-Abfrage mit dynamischer Sortierung in Linq schreiben?

Answer 1

Dank Harald Coppoolse für die Antwort ich es endlich wie dies tat:

_objDB.hotels .Select(h=> new { id= h.id, name=h.name, star=h.star, 
        minPrice1 = hotel.getHotelMinPrice_cap(h.id, 1, model.date_check_in, model.date_check_out)}) 
.Where(s => (s.city_id = 1)) 
.OrderByDynamic(sortExpr, Ascending).ToList(); 

In diesem Fall kann ich sortExpr = minPrice1; wählen und es wird durch die SQL-Funktion Art sein.

auch änderte ich die OrderByDynamic Funktion als Gebrüll:

public static IQueryable<T> OrderByDynamic<T>(this IQueryable<T> q, string SortField, bool Ascending) 
     { 
      var param = Expression.Parameter(typeof(T), "p"); 
      var prop = Expression.Property(param, SortField); 
      var exp = Expression.Lambda(prop, param); 
      string method = Ascending ? "OrderBy" : "OrderByDescending"; 
      Type[] types = new Type[] { q.ElementType, exp.Body.Type }; 
      var mce = Expression.Call(typeof(Queryable), method, types, q.Expression, exp); 
      return q.Provider.CreateQuery<T>(mce); 
     } 

, die ich auf Seite gefunden: https://stackoverflow.com/a/7265354/8509940

Answer 2

Ihre Lösung stellt mehrere Probleme:

• Sie OrderBy eine Eigenschaft mit Namen der Hoffnung, dass die Objekte, die Sie haben diese Eigenschaft bestellen. Was ist, wenn Ihre Objekte diese Eigenschaft nicht haben?
• SQL versteht nicht funktioniert wie GetProperty(), so dass diese Anordnung in einem lokalen Speicher (AsEnumerable) anstelle des viel schneller SQL Server (AsQueryable) durchgeführt werden muss.
• Sie verwenden eine gespeicherte Prozedur, um zu bestellen.

  public static IEnumerable<T, TKey> OrderByDynamic<T>(this IEnumerable<T> source, 
      Func<T, TKey> keySelector, System.ComponentModel.ListSortDirection sortDirection) 
  { 
      if (sortDirection == ListSortDirection.Ascending) 
       return source.OrderBy(keySelector); 
      else 
       return source.OrderByDescending(keySelector); 
  } 
  

  Verbrauch wäre wie:

Die ersten beiden Probleme können durch Änderung der Parameter propertyName durch eine Func<TSource, TKey> keySelector leicht lösende

var result = Students.OrderByDynamis(student => student.Name, ListSortDirection.Ascending); 

Der Vorteil dieser Methode, dass Ihr Compiler wird sich beschweren, wenn Sie versuchen, durch eine nicht vorhandene Eigenschaft zu bestellen. Außerdem kann OrderByAsQueryable durchgeführt werden; Es kann von Ihrer Datenbank statt im lokalen Speicher ausgeführt werden.

Es ist wirklich eine schlechte Idee, eine Zeichenfolge zu verwenden, um die gewünschte Eigenschaft auszuwählen.

Wenn Sie einen Tippfehler machen, werden Sie dies nur zur Laufzeit feststellen. Außerdem: Wenn Sie wissen, was Sie während der Entwicklung Ihres Codes als Zeichenkette für Ihre propertyName eingeben müssen, wissen Sie auch, welche Art von Objekten Sie sortieren werden. Sie könnten also stattdessen eine keySelector schreiben.

Ihr zweites Problem ruft die gespeicherte Prozedur als Sortierreihenfolge auf. Dies ist relativ einfach zu lösen, wenn Sie zuerst die gespeicherte Prozedur aufrufen und dann Bestellung durch den Rückgabewert:

var result = Hotels.Where(hotel => hotel...) 
    .Select(hotel => new 
    { 
     StoredProcedureValue = CallStoredprocedure(hotel,...), 
     Hotel = hotel, 
    }) 
    .AsEnumerable() // bring the result to local memory 
    .Orderby(item => item.StoredProcedureValue) 
    .Select(item => item.Hotel); 

nur die Hotels, die in den lokalen Speicher übertragen in Ihrem End-Ergebnis sein wird, zusammen mit dem Ergebnis der die StoredProcedures. Sie wurden nur für die Hotels aufgerufen, die Sie in Ihrem Endergebnis verwenden werden.

Die Sortierung erfolgt jedoch im lokalen Speicher.Wenn Sie auch möchten, dass diese Sortierung auf Datenbankseite erfolgt, müssen Sie eine neue gespeicherte Prozedur erstellen, die die andere gespeicherte Prozedur aufruft, bevor die Sortierung durchgeführt wird.