¿Cuál es el equivalente de Linq a SQL a TOP o LIMIT / OFFSET?

Cómo hago esto

Select top 10 Foo from MyTable

en Linq a SQL?

En VB:

from m in MyTable
take 10
select m.Foo

Esto supone que MyTable implementa IQueryable. Puede que tenga que acceder a través de un DataContext u otro proveedor.

También supone que Foo es una columna en MyTable que se asigna a un nombre de propiedad.

Consulte http://blogs.msdn.com/vbteam/archive/2008/01/08/converting-sql-to-linq-part-7-union-top-subqueries-bill-horst.aspx para obtener más detalles.

Utiliza el método Take :

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

En VB LINQ tiene una expresión take:

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

De la documentación:

Take<TSource>enumera sourcey produce elementos hasta que los countelementos hayan sido cedidos o sourceno contengan más elementos. Si countexcede el número de elementos source, sourcese devuelven todos los elementos de .

Usa el Take(int n)método:

var q = query.Take(10);

El OP también mencionó el desplazamiento, así que por ej. si desea obtener los artículos del 30 al 60, haría:

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

Use el método "Saltar" para el desplazamiento.
Use el método "Take" para el límite.

@Janei: mi primer comentario aquí es sobre su muestra;)

Creo que si te gusta esto, quieres tomar 4 y luego aplicar el tipo en estos 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
                };

Diferente a ordenar todo tbl_News por idNews descendiendo y luego tomando 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 ? Los resultados pueden ser diferentes.

Esto funciona bien en C #

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

Me gusta esto:

 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
                };

Usaría el método Take (N).

Si la toma ocurre en el cliente o en la base de datos depende de dónde aplique el operador de toma. Si lo aplica antes de enumerar la consulta (es decir, antes de usarla en un foreach o convertirla en una colección), la toma dará como resultado que el operador SQL "n superior" se envíe a la base de datos. Puede ver esto si ejecuta el generador de perfiles SQL. Si aplica la toma después de enumerar la consulta, sucederá en el cliente, ya que LINQ habrá tenido que recuperar los datos de la base de datos para que pueda enumerarlos.

Tomar datos de DataBase sin ordenar es lo mismo que tomar aleatoriamente

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();

Tuve que usar el método Take (n), luego transformar a la lista, funcionó como un encanto:

    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();

De esta manera funcionó para mí:

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

Para limit 1usar métodosFirstOrDefault() o First().

Ejemplo

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