LINQ To Entities non riconosce il metodo Last. Veramente?

In questa query:

public static IEnumerable<IServerOnlineCharacter> GetUpdated()
{
    var context = DataContext.GetDataContext();
    return context.ServerOnlineCharacters
        .OrderBy(p => p.ServerStatus.ServerDateTime)
        .GroupBy(p => p.RawName)
        .Select(p => p.Last());
}

Ho dovuto passare a questo per farlo funzionare

public static IEnumerable<IServerOnlineCharacter> GetUpdated()
{
    var context = DataContext.GetDataContext();
    return context.ServerOnlineCharacters
        .OrderByDescending(p => p.ServerStatus.ServerDateTime)
        .GroupBy(p => p.RawName)
        .Select(p => p.FirstOrDefault());
}

Non potevo nemmeno usare p.First(), per rispecchiare la prima query.

Perché ci sono limitazioni di base in ciò che altrimenti sarebbe un sistema ORM così robusto?

Tale limitazione deriva dal fatto che alla fine deve tradurre quella query in SQL e SQL ha un SELECT TOP(in T-SQL) ma non un SELECT BOTTOM(niente del genere).

C'è un modo semplice per aggirarlo , basta solo ordinare in ordine decrescente e poi fare un First(), che è quello che hai fatto.

EDIT: Altri provider avranno probabilmente implementazioni diverse di SELECT TOP 1, su Oracle probabilmente sarebbe qualcosa di più simileWHERE ROWNUM = 1

MODIFICARE:

Un'altra alternativa meno efficiente - NON lo consiglio! - è fare appello .ToList()ai tuoi dati prima .Last(), che eseguiranno immediatamente l'espressione LINQ To Entities che è stata costruita fino a quel momento, e quindi il tuo .Last () funzionerà, perché a quel punto .Last()viene effettivamente eseguito nel contesto di un Invece LINQ to Objects Expression. (E come hai sottolineato, potrebbe riportare migliaia di record e sprecare un sacco di oggetti materializzanti CPU che non verranno mai utilizzati)

Ancora una volta, non consiglierei di fare questo secondo, ma aiuta a illustrare la differenza tra dove e quando viene eseguita l'espressione LINQ.

Invece di Last(), prova questo:

model.OrderByDescending(o => o.Id).FirstOrDefault();

Sostituire Last()con un selettore LinqOrderByDescending(x => x.ID).Take(1).Single()

Qualcosa del genere funzionerebbe se preferisci farlo in Linq:

public static IEnumerable<IServerOnlineCharacter> GetUpdated()
{
    var context = DataContext.GetDataContext();
    return context.ServerOnlineCharacters.OrderBy(p => p.ServerStatus.ServerDateTime).GroupBy(p => p.RawName).Select(p => p.OrderByDescending(x => x.Id).Take(1).Single());
}

Ancora un altro modo ottenere l'ultimo elemento senza OrderByDescending e caricare tutte le entità:

dbSet
    .Where(f => f.Id == dbSet.Max(f2 => f2.Id))
    .FirstOrDefault();

Questo perché LINQ to Entities (e database in generale) non supporta tutti i metodi LINQ (vedere qui per i dettagli: http://msdn.microsoft.com/en-us/library/bb738550.aspx )

Quello che ti serve qui è ordinare i tuoi dati in modo tale che "l'ultimo" record diventi "primo" e quindi puoi usare FirstOrDefault. Si noti che i database di solito non hanno concetti come "primo" e "ultimo", non è come se il record inserito più di recente fosse "ultimo" nella tabella.

Questo metodo può risolvere il tuo problema

db.databaseTable.OrderByDescending(obj => obj.Id).FirstOrDefault();

L'aggiunta di una singola funzione AsEnumerable()prima di selezionare la funzione ha funzionato per me.
Esempio:

return context.ServerOnlineCharacters
    .OrderByDescending(p => p.ServerStatus.ServerDateTime)
    .GroupBy(p => p.RawName).AsEnumerable()
    .Select(p => p.FirstOrDefault());

Rif: https://www.codeproject.com/Questions/1005274/LINQ-to-Entities-does-not-recognize-the-method-Sys