Qual è il Linq a SQL equivalente a TOP o LIMIT / OFFSET?

Come faccio a fare questo

Select top 10 Foo from MyTable

in Linq a SQL?

In VB:

from m in MyTable
take 10
select m.Foo

Ciò presuppone che MyTable implementa IQueryable. Potrebbe essere necessario accedervi tramite un DataContext o un altro provider.

Presuppone inoltre che Foo sia una colonna in MyTable che viene associata a un nome di proprietà.

Vedi http://blogs.msdn.com/vbteam/archive/2008/01/08/converting-sql-to-linq-part-7-union-top-subqueries-bill-horst.aspx per maggiori dettagli.

Usa il metodo Take :

var foo = (from t in MyTable
           select t.Foo).Take(10);

In VB LINQ ha un'espressione take:

Dim foo = From t in MyTable _
          Take 10 _
          Select t.Foo

Dalla documentazione:

Take<TSource>enumera sourcee restituisce elementi fino a quando gli countelementi non sono stati resi o sourcenon contiene più elementi. Se countsupera il numero di elementi in source, sourcevengono restituiti tutti gli elementi di .

Usa il Take(int n)metodo:

var q = query.Take(10);

Anche l'OP ha menzionato l'offset, quindi per es. se desideri ottenere gli articoli da 30 a 60, dovresti:

var foo = (From t In MyTable
       Select t.Foo).Skip(30).Take(30);

Utilizzare il metodo "Skip" per l'offset.
Utilizzare il metodo "Take" per il limite.

@Janei: il mio primo commento qui riguarda il tuo campione;)

Penso che se ti piace in questo modo, vuoi prendere 4, quindi applicare l'ordinamento su questi 4.

var dados =  from d in dc.tbl_News.Take(4) 
                orderby d.idNews descending
                select new 
                {
                    d.idNews,
                    d.titleNews,
                    d.textNews,
                    d.dateNews,
                    d.imgNewsThumb
                };

Diverso dall'ordinare l'intero tbl_News per idNews in ordine decrescente e quindi prendendo 4

var dados =  (from d in dc.tbl_News
                orderby d.idNews descending
                select new 
                {
                    d.idNews,
                    d.titleNews,
                    d.textNews,
                    d.dateNews,
                    d.imgNewsThumb
                }).Take(4);

no ? i risultati possono essere diversi.

Funziona bene in C #

var q = from m in MyTable.Take(10)
        select m.Foo

Mi piace così:

 var dados =  from d in dc.tbl_News.Take(4) 
                orderby d.idNews descending

                select new 
                {
                    d.idNews,
                    d.titleNews,
                    d.textNews,
                    d.dateNews,
                    d.imgNewsThumb
                };

Utilizzeresti il ​​metodo Take (N).

Se il take avviene sul client o nel db dipende da dove si applica l'operatore take. Se lo si applica prima di enumerare la query (ovvero prima di utilizzarla in un foreach o convertirla in una raccolta), il take comporterà l'operatore SQL "n" in alto che verrà inviato al db. Puoi vederlo se esegui il profiler SQL. Se si applica il Take dopo aver enumerato la query, ciò accadrà sul client, poiché LINQ avrà dovuto recuperare i dati dal database per poterlo enumerare attraverso di esso

Il rilevamento dei dati di DataBase senza ordinamento è uguale al take casuale

Array oList = ((from m in dc.Reviews
                           join n in dc.Users on m.authorID equals n.userID
                           orderby m.createdDate descending
                           where m.foodID == _id                      
                           select new
                           {
                               authorID = m.authorID,
                               createdDate = m.createdDate,
                               review = m.review1,
                               author = n.username,
                               profileImgUrl = n.profileImgUrl
                           }).Take(2)).ToArray();

Ho dovuto usare il metodo Take (n), quindi trasformarmi in elenco, ha funzionato come un incantesimo:

    var listTest = (from x in table1
                     join y in table2
                     on x.field1 equals y.field1
                     orderby x.id descending
                     select new tempList()
                     {
                         field1 = y.field1,
                         active = x.active
                     }).Take(10).ToList();

In questo modo ha funzionato per me:

var noticias = from n in db.Noticias.Take(6)
                       where n.Atv == 1
                       orderby n.DatHorLan descending
                       select n;

Per i limit 1metodi di utilizzo FirstOrDefault()o First().

Esempio

var y = (from x in q select x).FirstOrDefault();