অবজেক্টের জন্য লিনকিউ সহ পেজিং

Question 1

আপনি কীভাবে একটি লিনকিউ কোয়েরিতে পেজিং বাস্তবায়ন করবেন? আসলে আপাতত, স্কেল টপ ফাংশনটি অনুকরণ করতে পারলে আমি সন্তুষ্ট হব। যাইহোক, আমি নিশ্চিত যে পূর্ণ পেজিং সমর্থনটির প্রয়োজন যেভাবেই পরে যাই হোক না কেন।

var queryResult = from o in objects
                  where ...
                  select new
                      {
                         A = o.a,
                         B = o.b
                      }
                   ????????? TOP 10????????

Question 2

আপনি Skipএবং Takeএক্সটেনশন পদ্ধতিগুলি সন্ধান করছেন। Skipফলাফলটি প্রথম এন উপাদানগুলির পরে চলে যায়, বাকীটি ফিরিয়ে দেয়; Takeফলাফলগুলিতে প্রথম এন উপাদানগুলি প্রদান করে, বাকি কোনও উপাদান ফেলে দেয়।

এই পদ্ধতিগুলি কীভাবে ব্যবহার করতে হয় সে সম্পর্কে আরও তথ্যের জন্য এমএসডিএন দেখুন: http://msdn.microsoft.com/en-us/library/bb386988.aspx

ধরে নিই যে আপনি ইতিমধ্যে অ্যাকাউন্টটি নিচ্ছেন যে পৃষ্ঠা নম্বরটি 0 থেকে শুরু হওয়া উচিত (মন্তব্যগুলিতে প্রস্তাবিত প্রতি 1 টি হ্রাস) আপনি এটি এটি করতে পারেন:

int numberOfObjectsPerPage = 10;
var queryResultPage = queryResult
  .Skip(numberOfObjectsPerPage * pageNumber)
  .Take(numberOfObjectsPerPage);

অন্যথায় @ অ্যালভিনের পরামর্শ অনুসারে

int numberOfObjectsPerPage = 10;
var queryResultPage = queryResult
  .Skip(numberOfObjectsPerPage * (pageNumber - 1))
  .Take(numberOfObjectsPerPage);

Question 3

ব্যবহার করা Skipএবং Takeঅবশ্যই যাওয়ার উপায়। যদি আমি এটি বাস্তবায়ন করতাম, তবে সম্ভবত প্যাগিং হ্যান্ডেল করার জন্য আমি কোডটি নিজের সম্প্রসারণ পদ্ধতিটি লিখতাম (কোডটি আরও পাঠযোগ্য। বাস্তবায়ন অবশ্যই ব্যবহার করতে পারে Skipএবং Take:

static class PagingUtils {
  public static IEnumerable<T> Page<T>(this IEnumerable<T> en, int pageSize, int page) {
    return en.Skip(page * pageSize).Take(pageSize);
  }
  public static IQueryable<T> Page<T>(this IQueryable<T> en, int pageSize, int page) {
    return en.Skip(page * pageSize).Take(pageSize);
  }
}

ক্লাসটি দুটি এক্সটেনশন পদ্ধতি সংজ্ঞায়িত করে - একটির জন্য IEnumerableএবং একটি এর জন্য IQueryable, যার অর্থ আপনি এটি ব্যবহার করতে পারেন LINQ থেকে অবজেক্ট এবং লিনকিউ থেকে এসকিউএল উভয় (ডাটাবেস ক্যোয়ারী লেখার সময়, সংকলকটি IQueryableসংস্করণটি বেছে নেবে )।

আপনার পেজিং প্রয়োজনীয়তার উপর নির্ভর করে আপনি কিছু অতিরিক্ত আচরণও যুক্ত করতে পারেন (উদাহরণস্বরূপ নেতিবাচক pageSizeবা pageমান হ্যান্ডেল করার জন্য )। আপনার ক্যোয়ারিতে আপনি কীভাবে এই এক্সটেনশন পদ্ধতিটি ব্যবহার করবেন তা এখানে একটি উদাহরণ রয়েছে:

var q = (from p in products
         where p.Show == true
         select new { p.Name }).Page(10, pageIndex);

Question 4

অবজেক্টগুলিতে লিনকিউ ব্যবহার করার সময় আমার পেজিংয়ের পারফরম্যান্ট অ্যাপ্রোচটি এখানে রয়েছে:

public static IEnumerable<IEnumerable<T>> Page<T>(this IEnumerable<T> source, int pageSize)
{
    Contract.Requires(source != null);
    Contract.Requires(pageSize > 0);
    Contract.Ensures(Contract.Result<IEnumerable<IEnumerable<T>>>() != null);

    using (var enumerator = source.GetEnumerator())
    {
        while (enumerator.MoveNext())
        {
            var currentPage = new List<T>(pageSize)
            {
                enumerator.Current
            };

            while (currentPage.Count < pageSize && enumerator.MoveNext())
            {
                currentPage.Add(enumerator.Current);
            }
            yield return new ReadOnlyCollection<T>(currentPage);
        }
    }
}

এটি তখন এর মতো ব্যবহার করা যেতে পারে:

var items = Enumerable.Range(0, 12);

foreach(var page in items.Page(3))
{
    // Do something with each page
    foreach(var item in page)
    {
        // Do something with the item in the current page       
    }
}

এই আবর্জনার কোনওটিই নয় Skipএবং Takeযদি আপনি একাধিক পৃষ্ঠায় আগ্রহী হন তবে এটি অত্যন্ত অদক্ষ।

Question 5

   ( for o in objects
    where ...
    select new
   {
     A=o.a,
     B=o.b
   })
.Skip((page-1)*pageSize)
.Take(pageSize)

Question 6

এটি কারও সাহায্য করবে কিনা জানি না, তবে আমি এটি আমার উদ্দেশ্যে দরকারী বলে মনে করেছি:

private static IEnumerable<T> PagedIterator<T>(IEnumerable<T> objectList, int PageSize)
{
    var page = 0;
    var recordCount = objectList.Count();
    var pageCount = (int)((recordCount + PageSize)/PageSize);

    if (recordCount < 1)
    {
        yield break;
    }

    while (page < pageCount)
    {
        var pageData = objectList.Skip(PageSize*page).Take(PageSize).ToList();

        foreach (var rd in pageData)
        {
            yield return rd;
        }
        page++;
    }
}

এটি ব্যবহার করতে আপনার কিছু লিনক ক্যোয়ারী থাকবে এবং পৃষ্ঠার আকারের সাথে ফলকটি একটি ফোরচ লুপে পাস করুন:

var results = from a in dbContext.Authors
              where a.PublishDate > someDate
              orderby a.Publisher
              select a;

foreach(var author in PagedIterator(results, 100))
{
    // Do Stuff
}

সুতরাং এটি প্রতিটি লেখককে একবারে 100 জন লেখক আনতে পুনরাবৃত্তি করবে।

Question 7

সম্পাদনা - অপরিহার্য স্কিপ (0) অপরিহার্য হিসাবে এটি প্রয়োজনীয় নয়

var queryResult = (from o in objects where ...
                      select new
                      {
                          A = o.a,
                          B = o.b
                      }
                  ).Take(10);

Question 8

var pages = items.Select((item, index) => new { item, Page = index / batchSize }).GroupBy(g => g.Page);

ব্যাচসাইজ স্পষ্টতই একটি পূর্ণসংখ্যা হবে। এটি পূর্ণসংখ্যার সাথে দশমিক স্থানগুলি সহজেই ফেলে দেয় এই সুবিধাটি গ্রহণ করে।

আমি এই প্রতিক্রিয়াটির সাথে অর্ধেক রসিকতা করছি, তবে এটি আপনি যা করতে চান তা করবে এবং এটি পিছিয়ে গেছে, আপনি যদি এটি করেন তবে আপনাকে একটি বড় পারফরম্যান্স জরিমানা দিতে হবে না

pages.First(p => p.Key == thePage)

এই সমাধানটি লিনকটোএন্টিটিগুলির জন্য নয়, এমনকি এটিকে একটি ভাল ক্যোয়ারিতে রূপান্তর করতে পারে কিনা তা আমি জানি না।

Question 9

লুকাজয়েডের উত্তরের অনুরূপ আমি আইকিউয়েরেবলের জন্য একটি এক্সটেনশন তৈরি করেছি।

   public static IEnumerable<IEnumerable<T>> PageIterator<T>(this IQueryable<T> source, int pageSize)
            {
                Contract.Requires(source != null);
                Contract.Requires(pageSize > 0);
                Contract.Ensures(Contract.Result<IEnumerable<IQueryable<T>>>() != null);

                using (var enumerator = source.GetEnumerator())
                {
                    while (enumerator.MoveNext())
                    {
                        var currentPage = new List<T>(pageSize)
                        {
                            enumerator.Current
                        };

                        while (currentPage.Count < pageSize && enumerator.MoveNext())
                        {
                            currentPage.Add(enumerator.Current);
                        }
                        yield return new ReadOnlyCollection<T>(currentPage);
                    }
                }
            }

স্কিপ বা টেক সমর্থিত না হলে এটি কার্যকর।

Question 10

আমি এই এক্সটেনশন পদ্ধতিটি ব্যবহার করি:

public static IQueryable<T> Page<T, TResult>(this IQueryable<T> obj, int page, int pageSize, System.Linq.Expressions.Expression<Func<T, TResult>> keySelector, bool asc, out int rowsCount)
{
    rowsCount = obj.Count();
    int innerRows = rowsCount - (page * pageSize);
    if (innerRows < 0)
    {
        innerRows = 0;
    }
    if (asc)
        return obj.OrderByDescending(keySelector).Take(innerRows).OrderBy(keySelector).Take(pageSize).AsQueryable();
    else
        return obj.OrderBy(keySelector).Take(innerRows).OrderByDescending(keySelector).Take(pageSize).AsQueryable();
}

public IEnumerable<Data> GetAll(int RowIndex, int PageSize, string SortExpression)
{
    int totalRows;
    int pageIndex = RowIndex / PageSize;

    List<Data> data= new List<Data>();
    IEnumerable<Data> dataPage;

    bool asc = !SortExpression.Contains("DESC");
    switch (SortExpression.Split(' ')[0])
    {
        case "ColumnName":
            dataPage = DataContext.Data.Page(pageIndex, PageSize, p => p.ColumnName, asc, out totalRows);
            break;
        default:
            dataPage = DataContext.vwClientDetails1s.Page(pageIndex, PageSize, p => p.IdColumn, asc, out totalRows);
            break;
    }

    foreach (var d in dataPage)
    {
        clients.Add(d);
    }

    return data;
}
public int CountAll()
{
    return DataContext.Data.Count();
}

Question 11

    public LightDataTable PagerSelection(int pageNumber, int setsPerPage, Func<LightDataRow, bool> prection = null)
    {
        this.setsPerPage = setsPerPage;
        this.pageNumber = pageNumber > 0 ? pageNumber - 1 : pageNumber;
        if (!ValidatePagerByPageNumber(pageNumber))
            return this;

        var rowList = rows.Cast<LightDataRow>();
        if (prection != null)
            rowList = rows.Where(prection).ToList();

        if (!rowList.Any())
            return new LightDataTable() { TablePrimaryKey = this.tablePrimaryKey };
        //if (rowList.Count() < (pageNumber * setsPerPage))
        //    return new LightDataTable(new LightDataRowCollection(rowList)) { TablePrimaryKey = this.tablePrimaryKey };

        return new LightDataTable(new LightDataRowCollection(rowList.Skip(this.pageNumber * setsPerPage).Take(setsPerPage).ToList())) { TablePrimaryKey = this.tablePrimaryKey };
  }

এই আমি কি করেছি। সাধারণত আপনি 1 এ শুরু করেন তবে IList এ আপনি 0 দিয়ে শুরু করেন so সুতরাং আপনার যদি 152 টি সারি থাকে তার মানে আপনার 8 টি পেজিং রয়েছে তবে IList এ আপনার কেবল 7. আছে hop আশা করি এটি আপনার পক্ষে বিষয়টিকে পরিষ্কার করে তুলতে পারে

Question 12

var results = (medicineInfo.OrderBy(x=>x.id)
                       .Skip((pages -1) * 2)
                       .Take(2));

স্নিপেট প্রসারিত করুন

Question 13

দুটি প্রধান বিকল্প রয়েছে:

.NET> = 4.0 গতিশীল লিংক :

System.Linq.Dynamic ব্যবহার করে যুক্ত করুন; উপরে.
ব্যবহার: var people = people.AsQueryable().OrderBy("Make ASC, Year DESC").ToList();

আপনি এটি নুগেট দ্বারাও পেতে পারেন ।

.NET <4.0 সম্প্রসারণ পদ্ধতি :

private static readonly Hashtable accessors = new Hashtable();

private static readonly Hashtable callSites = new Hashtable();

private static CallSite<Func<CallSite, object, object>> GetCallSiteLocked(string name) {
    var callSite = (CallSite<Func<CallSite, object, object>>)callSites[name];
    if(callSite == null)
    {
        callSites[name] = callSite = CallSite<Func<CallSite, object, object>>.Create(
                    Binder.GetMember(CSharpBinderFlags.None, name, typeof(AccessorCache),
                new CSharpArgumentInfo[] { CSharpArgumentInfo.Create(CSharpArgumentInfoFlags.None, null) }));
    }
    return callSite;
}

internal static Func<dynamic,object> GetAccessor(string name)
{
    Func<dynamic, object> accessor = (Func<dynamic, object>)accessors[name];
    if (accessor == null)
    {
        lock (accessors )
        {
            accessor = (Func<dynamic, object>)accessors[name];
            if (accessor == null)
            {
                if(name.IndexOf('.') >= 0) {
                    string[] props = name.Split('.');
                    CallSite<Func<CallSite, object, object>>[] arr = Array.ConvertAll(props, GetCallSiteLocked);
                    accessor = target =>
                    {
                        object val = (object)target;
                        for (int i = 0; i < arr.Length; i++)
                        {
                            var cs = arr[i];
                            val = cs.Target(cs, val);
                        }
                        return val;
                    };
                } else {
                    var callSite = GetCallSiteLocked(name);
                    accessor = target =>
                    {
                        return callSite.Target(callSite, (object)target);
                    };
                }
                accessors[name] = accessor;
            }
        }
    }
    return accessor;
}
public static IOrderedEnumerable<dynamic> OrderBy(this IEnumerable<dynamic> source, string property)
{
    return Enumerable.OrderBy<dynamic, object>(source, AccessorCache.GetAccessor(property), Comparer<object>.Default);
}
public static IOrderedEnumerable<dynamic> OrderByDescending(this IEnumerable<dynamic> source, string property)
{
    return Enumerable.OrderByDescending<dynamic, object>(source, AccessorCache.GetAccessor(property), Comparer<object>.Default);
}
public static IOrderedEnumerable<dynamic> ThenBy(this IOrderedEnumerable<dynamic> source, string property)
{
    return Enumerable.ThenBy<dynamic, object>(source, AccessorCache.GetAccessor(property), Comparer<object>.Default);
}
public static IOrderedEnumerable<dynamic> ThenByDescending(this IOrderedEnumerable<dynamic> source, string property)
{
    return Enumerable.ThenByDescending<dynamic, object>(source, AccessorCache.GetAccessor(property), Comparer<object>.Default);
}