LINQ সঙ্গে একটি সংগ্রহের পেজিং

LINQ- এর একটি সংগ্রহের মাধ্যমে আপনি কীভাবে পৃষ্ঠাটি পান যা আপনার startIndex এবং একটি গণনা আছে?

0
যোগ সম্পাদিত
মতামত: 5

4 উত্তর

এটি এড়িয়ে যান এবং নিয়ে যান এক্সটেনশান পদ্ধতিগুলি খুবই সহজ।

var query = from i in ideas
            select i;

var paggedCollection = query.Skip(startIndex).Take(count);
0
যোগ
এটি মূলত স্ট্যাকঅভারফ্লোের বিটা মেয়াদের প্রথম দিনে পোস্ট করা হয়েছিল, এইভাবে নিবন্ধ আইডি জন্য 66। আমি সিস্টেম পরীক্ষা ছিল, জেফ জন্য প্লাস এটা স্বাভাবিক পরীক্ষার বাজে কথা যে পরিবর্তে বিটা পরীক্ষার বাইরে আসে আউট দরকারী তথ্য বলে মনে হচ্ছে।
যোগ লেখক Nick Berardi, উৎস
আমি বিশ্বাস করি যে এটি ভালো কিছু করা ঠিক আছে। তিনি হয়তো একটি উত্তর থাকতে পারে কিন্তু হয়তো তিনি দেখতে পারেন অন্যান্য ব্যক্তিরা কীভাবে সাথে আসতে পারে।
যোগ লেখক Outlaw Programmer, উৎস

A few months back I wrote a blog post about Fluent Interfaces and LINQ which used an Extension Method on IQueryable and another class to provide the following natural way of paginating a LINQ collection.

var query = from i in ideas
            select i;
var pagedCollection = query.InPagesOf(10);
var pageOfIdeas = pagedCollection.Page(2);

আপনি এমএসডিএন কোড গ্যালারি পৃষ্ঠা থেকে কোড পেতে পারেন: পাইপলাইনস, ফিল্টার, ফ্লুইন্ট এপিআই এবং LINQ থেকে SQL

0
যোগ

এই প্রশ্নটি কিছুটা পুরানো, কিন্তু আমি আমার পেজিং অ্যালগরিদম পোস্ট করতে চেয়েছিলাম যা সমগ্র প্রক্রিয়াটি প্রদর্শন করে (ইউজার ইন্টারঅ্যাকশন সহ)।

const int pageSize = 10;
const int count = 100;
const int startIndex = 20;

int took = 0;
bool getNextPage;
var page = ideas.Skip(startIndex);

do
{
    Console.WriteLine("Page {0}:", (took / pageSize) + 1);
    foreach (var idea in page.Take(pageSize))
    {
        Console.WriteLine(idea);
    }

    took += pageSize;
    if (took < count)
    {
        Console.WriteLine("Next page (y/n)?");
        char answer = Console.ReadLine().FirstOrDefault();
        getNextPage = default(char) != answer && 'y' == char.ToLowerInvariant(answer);

        if (getNextPage)
        {
            page = page.Skip(pageSize);
        }
    }
}
while (getNextPage && took < count);

যাইহোক, যদি আপনি পারফরম্যান্সের পর, এবং উৎপাদন কোডে, আমরা কার্য সম্পাদনের পরই থাকি, তবে আপনাকে উপরে উল্লিখিত হিসাবে LINQ এর পেইজিং ব্যবহার করা উচিত নয় বরং নিজেই পেইজিং বাস্তবায়নের জন্য IEnumerator অন্তর্নিহিত। বস্তুত, এটি লিংক-আলগোরিদিম হিসাবে উল্লিখিত হিসাবে সহজ, কিন্তু আরো performant:

const int pageSize = 10;
const int count = 100;
const int startIndex = 20;

int took = 0;
bool getNextPage = true;
using (var page = ideas.Skip(startIndex).GetEnumerator())
{
    do 
    {
        Console.WriteLine("Page {0}:", (took / pageSize) + 1);

        int currentPageItemNo = 0;
        while (currentPageItemNo++ < pageSize && page.MoveNext())
        {
            var idea = page.Current;
            Console.WriteLine(idea);
        }

        took += pageSize;
        if (took < count)
        {
            Console.WriteLine("Next page (y/n)?");
            char answer = Console.ReadLine().FirstOrDefault();
            getNextPage = default(char) != answer && 'y' == char.ToLowerInvariant(answer);
        }
    }
    while (getNextPage && took < count);
}

Explanation: The downside of using Skip() for multiple times in a "cascading manner" is, that it will not really store the "pointer" of the iteration, where it was last skipped. - Instead the original sequence will be front-loaded with skip calls, which will lead to "consuming" the already "consumed" pages over and over again. - You can prove that yourself, when you create the sequence ideas so that it yields side effects. -> Even if you have skipped 10-20 and 20-30 and want to process 40+, you'll see all side effects of 10-30 being executed again, before you start iterating 40+. The variant using IEnumerable's interface directly, will instead remember the position of the end of the last logical page, so no explicit skipping is needed and side effects won't be repeated.

0
যোগ

আমি একটি ভিন্নভাবে ভিন্ন ভাবে সমাধান করেছি যেমনটি অন্যের কাছে আমার নিজের প্যাজিইনেটর তৈরি করা হয়েছে, একটি পুনরুত্পর দিয়ে। তাই আমি আমার আইটেমগুলির সংগ্রহের জন্য প্রথম পৃষ্ঠা নম্বর সংগ্রহ করেছি:

// assumes that the item collection is "myItems"

int pageCount = (myItems.Count + PageSize - 1) / PageSize;

IEnumerable pageRange = Enumerable.Range(1, pageCount);
   // pageRange contains [1, 2, ... , pageCount]

Using this I could easily partition the item collection into a collection of "pages". A page in this case is just a collection of items (IEnumerable). This is how you can do it using Skip and Take together with selecting the index from the pageRange created above:

IEnumerable> pageRange
    .Select((page, index) => 
        myItems
            .Skip(index*PageSize)
            .Take(PageSize));

অবশ্যই আপনি একটি অতিরিক্ত সংগ্রহ হিসাবে প্রতিটি পৃষ্ঠা হ্যান্ডেল আছে কিন্তু উদাহরণস্বরূপ। যদি আপনি পুনঃপৃষ্ঠা ঘুরে বেড়ান তাহলে এই আসলে হ্যান্ডেল করা সহজ।


এক-লিনিয়ার TLDR সংস্করণটি এই হবে:

var pages = Enumerable
    .Range(0, pageCount)
    .Select((index) => myItems.Skip(index*PageSize).Take(PageSize));

যা এই হিসাবে ব্যবহার করা যেতে পারে:

for (Enumerable page : pages) 
{
    // handle page

    for (Item item : page) 
    {
        // handle item in page
    }
}
0
যোগ