Dela via

Returnera eller hoppa över element i en sekvens

Använd operatorn Take för att returnera ett visst antal element i en sekvens och hoppa sedan över resten.

Använd operatorn Skip för att hoppa över ett visst antal element i en sekvens och sedan returnera resten.

Anmärkning

Take och Skip har vissa begränsningar när de används i frågor mot SQL Server 2000. Mer information finns i posten Hoppa över och ta undantag i SQL Server 2000 i Felsökning.

LINQ till SQL översätts Skip med hjälp av en underfråga med SQL-satsen NOT EXISTS . Den här översättningen har följande begränsningar:

  • Argumentet måste vara en uppsättning. Fleruppsättningar stöds inte, även om de är ordnade.

  • Den genererade frågan kan vara mycket mer komplex än den fråga som genereras för den basfråga som Skip tillämpas. Den här komplexiteten kan orsaka sämre prestanda eller till och med en timeout.

Exempel 1

I följande exempel används Take för att välja de första fem Employees anställda. Observera att samlingen först sorteras efter HireDate.

IQueryable<Employee> firstHiredQuery =
    (from emp in db.Employees
    orderby emp.HireDate
    select emp)
    .Take(5);

foreach (Employee empObj in firstHiredQuery)
{
    Console.WriteLine("{0}, {1}", empObj.EmployeeID,
        empObj.HireDate);
}

Dim firstHiredQuery = _
    From emp In db.Employees _
    Select emp _
    Order By emp.HireDate _
    Take 5

For Each empObj As Employee In firstHiredQuery
    Console.WriteLine("{0}, {1}", empObj.EmployeeID, _
        empObj.HireDate)
Next

Exempel 2

I följande exempel används Skip för att välja alla utom de 10 dyraste Products.

IQueryable<Product> lessExpensiveQuery =
    (from prod in db.Products
    orderby prod.UnitPrice descending
    select prod)
    .Skip(10);

foreach (Product prodObj in lessExpensiveQuery)
{
    Console.WriteLine(prodObj.ProductName);
}

Dim lessExpensiveQuery = _
    From prod In db.Products _
    Select prod _
    Order By prod.UnitPrice Descending _
    Skip 10

For Each prodObj As Product In lessExpensiveQuery
    Console.WriteLine(prodObj.ProductName)
Next

Exempel 3

I följande exempel kombineras metoderna Skip och Take för att hoppa över de första 50 posterna och sedan returnera de 10 nästkommande.

var custQuery2 =
    (from cust in db.Customers
    orderby cust.ContactName
    select cust)
    .Skip(50).Take(10);

foreach (var custRecord in custQuery2)
{
    Console.WriteLine(custRecord.ContactName);
}

Dim custQuery2 = _
    From cust In db.Customers _
    Order By (cust.ContactName) _
    Select cust _
    Skip 50 _
    Take 10

For Each custRecord As Customer In custQuery2
    Console.WriteLine(custRecord.ContactName)
Next

Take och Skip operationer är väldefinierade bara för ordnade uppsättningar. Semantiken för osorterade uppsättningar eller flera uppsättningar är odefinierad.

På grund av begränsningarna i ordningen i SQL försöker LINQ till SQL flytta ordningen på argumentet Take för operatorn eller Skip till resultatet av operatorn.

Anmärkning

Översättningen skiljer sig åt för SQL Server 2000 och SQL Server 2005. Om du planerar att använda Skip med en fråga av någon komplexitet använder du SQL Server 2005.

Överväg följande LINQ till SQL-fråga för SQL Server 2000:

IQueryable<Customer> custQuery3 =
    (from custs in db.Customers
     where custs.City == "London"
     orderby custs.CustomerID
     select custs)
    .Skip(1).Take(1);

foreach (var custObj in custQuery3)
{
    Console.WriteLine(custObj.CustomerID);
}

Dim custQuery3 = _
    From custs In db.Customers _
    Where custs.City = "London" _
    Select custs _
    Order By custs.CustomerID _
    Skip 1 _
    Take 1

For Each custObj In custQuery3
    Console.WriteLine(custObj.CustomerID)
Next

LINQ till SQL flyttar beställningen till slutet i SQL-koden enligt följande:

SELECT TOP 1 [t0].[CustomerID], [t0].[CompanyName],
FROM [Customers] AS [t0]
WHERE (NOT (EXISTS(
    SELECT NULL AS [EMPTY]
    FROM (
        SELECT TOP 1 [t1].[CustomerID]
        FROM [Customers] AS [t1]
        WHERE [t1].[City] = @p0
        ORDER BY [t1].[CustomerID]
        ) AS [t2]
    WHERE [t0].[CustomerID] = [t2].[CustomerID]
    ))) AND ([t0].[City] = @p1)
ORDER BY [t0].[CustomerID]

När Take och Skip är sammanlänkade måste all angiven ordning vara konsekvent. Annars är resultatet odefinierat.

För icke-negativa, konstanta integralargument baserat på SQL-specifikationen är båda Take och Skip väldefinierade.

Se även