কীভাবে একটি তালিকা বাছাই করুন <T> অবজেক্টের কোনও সম্পত্তি দ্বারা

1246

আমি নামক একটি বর্গ আছে Orderযা বৈশিষ্ট্য যেমন রয়েছে OrderId, OrderDate, Quantity, এবং Total। আমার এই Orderক্লাসের একটি তালিকা রয়েছে :

List<Order> objListOrder = new List<Order>();
GetOrderList(objListOrder); // fill list of orders

এখন আমি Orderঅবজেক্টের একটি বৈশিষ্ট্যের উপর ভিত্তি করে তালিকাটি বাছাই করতে চাই , উদাহরণস্বরূপ আমাকে ক্রমের তারিখ বা অর্ডার আইডি অনুসারে বাছাই করতে হবে।

আমি সি # তে এটি কীভাবে করতে পারি?

c#  generics  list  sorting 
— Shyju
সূত্র
9
অপেক্ষা করুন - আপনি উভয় অর্ডার তারিখ এবং অর্ডার আইডি অনুসারে বাছাই করতে চান ? কারণ বেশিরভাগ উত্তর মনে হয়েছে যে আপনি কেবল এক বা অন্য দ্বারা সাজান sort
— গ্যালাকটিক কাউয়
@ গ্যালাকটিক কাউবয়, @ জেনেরিক টাইপটিয়া: প্রশ্নটি বলেছে যে "আমি অর্ডার অবজেক্টের একটি সম্পত্তির উপর ভিত্তি করে তালিকাটি বাছাই করতে চাই ", তবে আমি একমত যে অন্য কোথাও এটি সম্পূর্ণ পরিষ্কার নয়। যেভাবেই হোক, আপনাকে এক বা একাধিক বৈশিষ্ট্য অনুসারে বাছাই করতে হবে কিনা তা এক বিশাল পার্থক্য করে না।
— লুক
@ লুক্ক - সবেমাত্র পুনরায় পড়তে হবে এবং আমি সম্মত। 'আমি একটি সংখ্যার উপর ভিত্তি করে তালিকাটি বাছাই করতে চাই' ... এবং 'অর্ডার তারিখ বা অর্ডার আইডি'। সমস্ত উত্তরগুলির মধ্যে, আমরা সমস্ত ঘাঁটি কভার করেছি :)।
— djdd87

উত্তর:

1804

লিনক ব্যবহার করা সম্পর্কে আমি সবচেয়ে সহজ উপায়টি ভাবতে পারি:

List<Order> SortedList = objListOrder.OrderBy(o=>o.OrderDate).ToList();
— ভিখারি
সূত্র
22
আমি কিভাবে এটি সাজানো ক্রম অনুসারে বাছাই করতে পারি।
— সুন্দর ভালুক
228
@ বনাসকুন তালিকা <অর্ডার> সোর্টডলিস্ট = আইজেক্টলিস্ট অর্ডার। অর্ডারবাইডিসেন্ডিং (ও => ও.আর্ডারডেট)। টোললিস্ট ();
— জাভাজবজভাবাভাভা
77
মনে রাখবেন এটি মেমরির সমস্ত আইটেম সহ পুরো নতুন তালিকা তৈরি করে, যা পারফরম্যান্সের ক্ষেত্রে সমস্যাযুক্ত হতে পারে।
— staafl
14
@ স্টাফএল কি এ listWithObjects = listWithObjects.OrderByDescending(o => o.Status).ToList();জাতীয় প্রচেষ্টা যথেষ্ট?
— অ্যান্ড্রু গ্রিন্ডার
28
@ স্টাফএল আমরা অবজেক্টের রেফারেন্সগুলির একটি তালিকা অর্ডার করছি, যতক্ষণ না আমি অবগত আছি বস্তুগুলি সেগুলি নকল করে না। যদিও এটি রেফারেন্সের তালিকার দ্বারা ব্যবহৃত স্মৃতি দ্বিগুণ করে তোলে ততটা খারাপ নয় যতক্ষণ না প্রকৃতপক্ষে সমস্ত বস্তুর নিজস্ব নকল করা হয় তাই বেশিরভাগ পরিস্থিতিতে যেখানে আমরা বিশাল ডেটা সেট নিয়ে কাজ করছি এবং তাদের মেমরির মধ্যে রেখেছি তা ইতিমধ্যে একটি সমস্যা হয়ে দাঁড়িয়েছে then এটি যথেষ্ট হবে।
— লাজারাস
797

আপনার যদি তালিকায় স্থানটি সাজান প্রয়োজন হয় তবে আপনি Sortএকটি Comparison<T>প্রতিনিধিকে পাশ দিয়ে পদ্ধতিটি ব্যবহার করতে পারেন :

objListOrder.Sort((x, y) => x.OrderDate.CompareTo(y.OrderDate));

আপনি যদি জায়গায় স্থানে বাছাই না করে কোনও নতুন, বাছাই করা ক্রম তৈরি করতে পছন্দ করেন তবে আপনি OrderByঅন্যান্য উত্তরগুলিতে উল্লিখিত লিঙ্কের পদ্ধতিটি ব্যবহার করতে পারেন ।

— LukeH
সূত্র
30
হ্যাঁ, এটি "সঠিক" উত্তর এবং একটি নতুন আইইনামেবল তৈরি করার পরে এটি একটি নতুন তালিকায় রূপান্তর করার চেয়ে অনেক বেশি দক্ষ হওয়া উচিত।
— জোনাথন উড
45
অবশ্যই আপনার যদি সাজানোর দরকার হয় তবে অদলবদল করুন xএবং তীরটির yডানদিকে =>।
— জেপ্প স্টিগ নীলসেন
15
প্রকৃত উত্তর যা বাস্তবে তালিকায় স্থান অনুসারে বাছাই করে
— মিচেল কুরি
3
@ পিমব্রউবার্স এটি আরও ভাল বিকল্প সময়কাল। এমনকি আপনি যে পরিমাণ মেমরি ব্যবহার করছেন তা যদি সমস্যা না হয় তবে এই সমাধানটি অপ্রয়োজনীয় মেমরির বরাদ্দ এড়ানো যায় যা অত্যন্ত ব্যয়বহুল। এই বিকল্পটি ঠিক কোডওয়ালা এবং দ্রুততর মানের একটি ক্রম।
— Cdaragorn
12
@ জোনস্কিনিডার Nullable<>( DateTime?উদাহরণ হিসাবে গ্রহণ করুন) এর জন্য আপনি ব্যবহার করতে পারেন .Sort((x, y) => Nullable.Compare(x.OrderDate, y.OrderDate))যা নালকে সমস্ত অ-শূন্য মানের পূর্বে হিসাবে বিবেচনা করবে। এটা ঠিক হিসাবে একই .Sort((x, y) => Comparer<DateTime?>.Default.Compare(x.OrderDate, y.OrderDate)।
— জেপ্প স্টিগ
219

.NET2.0- এ লিনকিউ ছাড়াই এটি করতে:

List<Order> objListOrder = GetOrderList();
objListOrder.Sort(
    delegate(Order p1, Order p2)
    {
        return p1.OrderDate.CompareTo(p2.OrderDate);
    }
);

আপনি যদি নেট .৩.০ এ থাকেন তবে লুক হ'ল উত্তরটি আপনার পরে কী।

একাধিক বৈশিষ্ট্য বাছাই করতে, আপনি এখনও এটি একটি প্রতিনিধি মধ্যে করতে পারেন। উদাহরণ স্বরূপ:

orderList.Sort(
    delegate(Order p1, Order p2)
    {
        int compareDate = p1.Date.CompareTo(p2.Date);
        if (compareDate == 0)
        {
            return p2.OrderID.CompareTo(p1.OrderID);
        }
        return compareDate;
    }
);

এটি আপনাকে অবতরণ আদেশের সাথে আরোহণের তারিখগুলি দেবে।

তবে, আমি প্রতিনিধিদের স্টিকিংয়ের পরামর্শ দেব না কারণ এর অর্থ কোড পুনরায় ব্যবহার ছাড়াই প্রচুর জায়গা হবে। আপনার একটি প্রয়োগ করা উচিত IComparerএবং এটি আপনার Sortপদ্ধতিতে পাস করা উচিত । এখানে দেখুন ।

public class MyOrderingClass : IComparer<Order>
{
    public int Compare(Order x, Order y)
    {
        int compareDate = x.Date.CompareTo(y.Date);
        if (compareDate == 0)
        {
            return x.OrderID.CompareTo(y.OrderID);
        }
        return compareDate;
    }
}

এবং তারপরে এই আইকোপারপার ক্লাসটি ব্যবহার করতে, কেবল এটি ইনস্ট্যানিয়েট করুন এবং এটি আপনার বাছাই পদ্ধতিতে দিন:

IComparer<Order> comparer = new MyOrderingClass();
orderList.Sort(comparer);
— djdd87
সূত্র
1
মূল উত্তরটি (যা লিনকিউ সংস্করণ সর্বদা করবে) আরও ভাল এনক্যাপসুলেশন সরবরাহ করে মূল তালিকাটি পুনরায় আরম্ভ করার সুরক্ষার জন্য দুর্দান্ত উত্তর এবং সঠিক হওয়া উচিত।
— জেব
@ ওটন, না ধারণাটি IComparerআমাদের বহুরূপী আচরণ প্রদান করে বিভিন্ন বাস্তবায়ন করতে সক্ষম হয় ।
— রাডারবব
আমার জন্য কাজ করেছেন। আমি এর সংস্করণ বাছাইয়ের বিকল্পগুলির সাথে পোস্ট করেছি।
— জ্যাক গ্রিফিন
109

একটি তালিকা অর্ডার করার সহজ উপায় ব্যবহার করা হয় OrderBy

 List<Order> objListOrder = 
    source.OrderBy(order => order.OrderDate).ToList();

আপনি যদি এসকিউএল কোয়েরি অনুসরণ করে একাধিক কলাম দ্বারা অর্ডার করতে চান।

ORDER BY OrderDate, OrderId

এটি অর্জন করতে আপনি ThenByনীচের মত ব্যবহার করতে পারেন ।

  List<Order> objListOrder = 
    source.OrderBy(order => order.OrderDate).ThenBy(order => order.OrderId).ToList();
— পিএসসি
সূত্র
32

আপনি যেমন বলেছেন লিনক ছাড়াই এটি করা:

public class Order : IComparable
{
    public DateTime OrderDate { get; set; }
    public int OrderId { get; set; }

    public int CompareTo(object obj)
    {
        Order orderToCompare = obj as Order;
        if (orderToCompare.OrderDate < OrderDate || orderToCompare.OrderId < OrderId)
        {
            return 1;
        }
        if (orderToCompare.OrderDate > OrderDate || orderToCompare.OrderId > OrderId)
        {
            return -1;
        }

        // The orders are equivalent.
        return 0;
    }
}

তারপরে আপনার অর্ডারগুলির তালিকায় কেবল .sort () কল করুন

— জিমি হোফা
সূত্র
3
জন্য এক আবশ্যক প্রথম টেস্টের nullউপর asকাস্ট করুন। যা সম্পূর্ণরূপে হ'ল as(হা, হা) (Order)objব্যর্থ হলে এটি একটি ব্যতিক্রম ছুঁড়ে দেয়। if(orderToCompare == null) return 1;।
— রাডারবব
ইন্টারফেসটি ব্যবহারের জন্য +1, যা কোডটি বজায় রাখা সহজ করে এবং অবজেক্টের ক্ষমতাগুলি পরিষ্কারভাবে প্রকাশ করে।
— আইওনঅফটাইম
যদি বিল এবং টেড কখনও দেখাতে থাকে আমি তাদের 16 অক্টোবর, 2014 এ ফিরে যেতে বলব যাতে আমি আমার ভুলটি উপরের দিকে সংশোধন করতে পারি - asnull যদি কাস্ট ব্যর্থ হয় তবে ফেরত দেয়। তবে কমপক্ষে নাল-পরীক্ষা সঠিক।
— রডারবব
@ রেডারবব হ্যাঁ .. উফ! :) তবে! এই ফাংশনটি কোনও তালিকার উপরে বাছাইয়ের মাধ্যমে স্বয়ংক্রিয়ভাবে ব্যবহারের উদ্দেশ্যে যা List<Order>এই ধরণের asযাতে 2014 তে ম্যাচ করার গ্যারান্টি দেওয়া উচিত আপনি সম্ভবত কোনও বাগ লেখেননি, অপ্রয়োজনীয় প্রহরী বিবৃতি এড়ানো এতটা :)
— জিমি হোফা
গ্যারান্টিযুক্ত আকর্ষণীয় পয়েন্ট হওয়া উচিত । যদি এটি ভালভাবে এনপ্যাপুলেটেড থাকে তবে এটিকে পাস করা ছাড়া ডাকা যায় না List<Order>; তবে আপনি এবং আমি দুজনেই স্ব-ক্যাপসুলেটেড প্রোগ্রামারটির সাথে সাক্ষাত করেছি যিনি অপ্রকাশিত ধারণাটি হ'ল "আমি এই কোডটি লিখছি তাই এটি ভুল ব্যবহার করা হবে না"
— রাডারবব ob নভেম্বর'১17 2121
26

একটি ক্লাসিকাল অবজেক্ট ওরিয়েন্টেড সলিউশন

প্রথমে আমাকে লিনকিউ-এর দুর্দান্ততায় জেনুফুল করতে হবে .... এখন যে আমরা এটি শেষ করে ফেলেছি

জিমিহোফা উত্তরের একটি প্রকরণ। জেনেরিকের সাথে CompareToপ্যারামিটারটি নিরাপদ হয়ে যায়।

public class Order : IComparable<Order> {

    public int CompareTo( Order that ) {
        if ( that == null ) return 1;
        if ( this.OrderDate > that.OrderDate) return 1;
        if ( this.OrderDate < that.OrderDate) return -1;
        return 0;
    }
}

// in the client code
// assume myOrders is a populated List<Order>
myOrders.Sort();

এই ডিফল্ট বাছাইযোগ্যতা অবশ্যই পুনরায় ব্যবহারযোগ্য। এটি হ'ল প্রতিটি ক্লায়েন্টকে বাছাইয়ের যুক্তিটি পুনর্বারভাবে লিখতে হবে না। "1" এবং "-1" (বা লজিক অপারেটরগুলি, আপনার পছন্দ) অদলবদল সাজানোর ক্রমটিকে বিপরীত করে।

— radarbob
সূত্র
একটি তালিকায় বস্তু বাছাইয়ের জন্য সহজ পদ্ধতি। তবে আমি বুঝতে পারি না কেন আপনি যদি ১ টি ফেরেন (যে == নাল)?
— লোক Huynh
4
এর অর্থ হল thisবস্তুটি শূন্যের চেয়ে বড়। বাছাইয়ের উদ্দেশ্যে, একটি নাল অবজেক্ট রেফারেন্স " thisঅবজেক্টের চেয়ে কম" । নালগুলি কীভাবে বাছাই করা হবে তা নির্ধারণ করার সিদ্ধান্ত নিয়েছি।
— রডারবব
18

// গ্রিডভিউ সহ ব্যবহারের জন্য সম্পূর্ণ জেনেরিক বাছাই

public List<T> Sort_List<T>(string sortDirection, string sortExpression, List<T> data)
    {

        List<T> data_sorted = new List<T>();

        if (sortDirection == "Ascending")
        {
            data_sorted = (from n in data
                              orderby GetDynamicSortProperty(n, sortExpression) ascending
                              select n).ToList();
        }
        else if (sortDirection == "Descending")
        {
            data_sorted = (from n in data
                              orderby GetDynamicSortProperty(n, sortExpression) descending
                              select n).ToList();

        }

        return data_sorted;

    }

    public object GetDynamicSortProperty(object item, string propName)
    {
        //Use reflection to get order type
        return item.GetType().GetProperty(propName).GetValue(item, null);
    }
— আচ্ছা
সূত্র
4
বা, আপনি জানেন data.OrderBy(),। বিট সহজ যে চক্রটি পুনরায় উদ্ভাবন করছে।
— gunr2171
4
ধারণাটি হ'ল এটি কোনও ধরণের অবজেক্টের সাথে কাজ করবে। যেখানে অর্ডারবাই () কেবল শক্তভাবে টাইপ করা অবজেক্টের সাথে কাজ করে।
— রোজার
1
আমার মতামত অনুসারে, গ্রিডের ডেটা বাছাই করা সবচেয়ে সহজ এবং ব্যবহারযোগ্য সমাধান!
— কোস্টাস সিএইচ।
6

এখানে একটি জেনেরিক লিনকিউ এক্সটেনশন পদ্ধতি রয়েছে যা তালিকার অতিরিক্ত অনুলিপি তৈরি করে না:

public static void Sort<T,U>(this List<T> list, Func<T, U> expression)
    where U : IComparable<U>
{
    list.Sort((x, y) => expression.Invoke(x).CompareTo(expression.Invoke(y)));
}

এটি ব্যবহার করতে:

myList.Sort(x=> x.myProperty);

আমি সম্প্রতি এই অতিরিক্তটি তৈরি করেছি যা কোনও গ্রহণ করে ICompare<U>, যাতে আপনি তুলনাটি কাস্টমাইজ করতে পারেন। যখন প্রাকৃতিক স্ট্রিং সাজানোর দরকার হয় তখন এটি কার্যকর হয়েছিল:

public static void Sort<T, U>(this List<T> list, Func<T, U> expression, IComparer<U> comparer)
    where U : IComparable<U>
{    
    list.Sort((x, y) => comparer.Compare(expression.Invoke(x), expression.Invoke(y)));
}
— পিটার
সূত্র
আমি এটি বাস্তবায়ন করেছি, ঠিক আছে। আমি একটি "ইসসেন্ডিং = ট্রু" পরামিতি যুক্ত করেছি। অবতরণ ক্রমে সাজানোর জন্য, দুটি ইনভোক () পদ্ধতির মধ্যে কেবল x এবং y এর অদলবদল করুন। ধন্যবাদ।
— রব এল
আপনি যদি কেবল প্রকাশটি সংকলন করতে যাচ্ছেন তবে আপনি কেবল একটি ডেলিগেটের সাথে শুরু করার জন্য গ্রহণ করতে পারেন। অতিরিক্তভাবে, এই পদ্ধতির বড় সমস্যা রয়েছে যদি নির্বাচক পার্শ্ব প্রতিক্রিয়া সৃষ্টি করে, গণনা করা ব্যয়বহুল, বা নির্বিচারক নয়। একটি নির্বাচিত অভিব্যক্তির উপর ভিত্তি করে একটি যথাযথ বাছাইয়ের জন্য নির্বাচককে তালিকার প্রতিটি আইটেমের জন্য একাধিকবার আহ্বান করা উচিত।
— পরিবেশন করুন
@ সার্ভি - এগুলি সমস্ত বৈধ পয়েন্ট, তবে আমি সত্যবাদী হবো, আমি নিশ্চিত না যে কীভাবে আপনার কিছু প্রস্তাবনা প্রয়োগ করা যায় (বিশেষত কোনও নির্বাচককে পার্শ্ব প্রতিক্রিয়া সৃষ্টি করা থেকে বিরত করা ...?)। আমি তাদের প্রতিনিধিদের মধ্যে পরিবর্তন করেছি। আপনি যদি এই কিছু পরিবর্তন করতে চান তবে আপনি আমার কোডটি সম্পাদনা করে খুশি হবেন।
— পিটার
3
@ পিটার আপনি প্রতিনিধিদের পার্শ্ব প্রতিক্রিয়া সৃষ্টি করতে বাধা দিতে পারবেন না । আপনি যা করতে পারেন তা হ'ল এটি নিশ্চিত করা হয় যে তারা কখনই প্রতি বস্তু হিসাবে একাধিকবার ডাকা হয় নি, এর অর্থ প্রতিটি বস্তুর জন্য মানগুলি গণনা করা, অবজেক্ট / প্রজেক্টড-মান জুড়ি সংরক্ষণ করা এবং তার পরে বাছাই করা । OrderByঅভ্যন্তরীণভাবে যে সব করে।
— 21
voidএই স্পিরিটে একটি এক্সটেনশন পদ্ধতিটি লেখার আরও একটি দুর্দান্ত উপায় : static class Extensions { public static void SortBy<TSource, TKey>(this List<TSource> self, Func<TSource, TKey> keySelector) { self.SortBy(keySelector, Comparer<TKey>.Default); } public static void SortBy<TSource, TKey>(this List<TSource> self, Func<TSource, TKey> keySelector, IComparer<TKey> comparer) { self.Sort((x, y) => comparer.Compare(keySelector(x), keySelector(y))); } }একটি SortByDescendingপদ্ধতি দ্বারা পরিপূরক হতে পারে । @ সার্ভির মন্তব্য আমার
— জেপ্প স্টিগ নীলসেন
3 
//Get data from database, then sort list by staff name:

List<StaffMember> staffList = staffHandler.GetStaffMembers();

var sortedList = from staffmember in staffList
                 orderby staffmember.Name ascending
                 select staffmember;
— ওয়াকাস আহমেদ
সূত্র
3

রজার সংস্করণে উন্নত।

গেটডিনমিকসোর্টপ্রোপার্টি নিয়ে সমস্যাটি হ'ল কেবল সম্পত্তির নাম পাওয়া যায় তবে গ্রিডভিউতে আমরা নেভিগেশনপোপার্টি ব্যবহার করি তবে কী হবে? এটি একটি ব্যতিক্রম প্রেরণ করবে, যেহেতু এটি শূন্য রয়েছে।

উদাহরণ:

"কর্মচারী.কম্পানি.নাম;" ক্রাশ হবে ... যেহেতু প্যারামিটার হিসাবে কেবল "নাম" এর মান পেতে দেয়।

এখানে একটি উন্নত সংস্করণ যা আমাদের নেভিগেশন বৈশিষ্ট্য অনুসারে বাছাই করতে দেয়।

public object GetDynamicSortProperty(object item, string propName)
    {
        try
        {                 
            string[] prop = propName.Split('.'); 

            //Use reflection to get order type                   
            int i = 0;                    
            while (i < prop.Count())
            {
                item = item.GetType().GetProperty(prop[i]).GetValue(item, null);
                i++;
            }                     

            return item;
        }
        catch (Exception ex)
        {
            throw ex;
        }


    }
— মিগুয়েল বেরসার
সূত্র
3

আপনার সম্পত্তি 'অর্ডার' ক্ষেত্রে আপনি যে ধরণের পছন্দগুলি বেছে নিচ্ছেন সে সম্পর্কে সুনির্দিষ্টভাবে সম্পত্তি বৈশিষ্ট্য সম্পর্কে আরও সাধারণ কিছু করতে পারেন:

জেনেরিক হিসাবে আপনার ফাংশন লিখুন:

public List<Order> GetOrderList<T>(IEnumerable<Order> orders, Func<Order, T> propertySelector)
        {
            return (from order in orders
                    orderby propertySelector(order)
                    select order).ToList();
        }

এবং তারপরে এটি ব্যবহার করুন:

var ordersOrderedByDate = GetOrderList(orders, x => x.OrderDate);

আপনি আরও জেনেরিক হতে পারেন এবং আপনি যেটি অর্ডার করতে চান তার জন্য একটি খোলার ধরণ নির্ধারণ করতে পারেন:

public List<T> OrderBy<T,P>(IEnumerable<T> collection, Func<T,P> propertySelector)
        {
            return (from item in collection
                    orderby propertySelector(item)
                    select item).ToList();
        }

এবং এটি একইভাবে ব্যবহার করুন:

var ordersOrderedByDate = OrderBy(orders, x => x.OrderDate);

লিনকিউ স্টাইলের 'অর্ডারবাই' করার কোনটি বোকা অপ্রয়োজনীয় জটিল উপায়, তবে এটি কীভাবে জেনেরিক উপায়ে প্রয়োগ করা যেতে পারে তার একটি ক্লু দেয় may

— ড্যানি মোড়
সূত্র
3

দয়া করে আমাকে কিছু নমুনা কোড সহ @ লুকএইচের উত্তরটি সম্পূর্ণ করতে দিন, কারণ আমি এটি পরীক্ষা করেছি বলে আমি বিশ্বাস করি এটি কারও পক্ষে কার্যকর হতে পারে:

public class Order
{
    public string OrderId { get; set; }
    public DateTime OrderDate { get; set; }
    public int Quantity { get; set; }
    public int Total { get; set; }

    public Order(string orderId, DateTime orderDate, int quantity, int total)
    {
        OrderId = orderId;
        OrderDate = orderDate;
        Quantity = quantity;
        Total = total;
    }
}

public void SampleDataAndTest()
{
    List<Order> objListOrder = new List<Order>();

    objListOrder.Add(new Order("tu me paulo ", Convert.ToDateTime("01/06/2016"), 1, 44));
    objListOrder.Add(new Order("ante laudabas", Convert.ToDateTime("02/05/2016"), 2, 55));
    objListOrder.Add(new Order("ad ordinem ", Convert.ToDateTime("03/04/2016"), 5, 66));
    objListOrder.Add(new Order("collocationem ", Convert.ToDateTime("04/03/2016"), 9, 77));
    objListOrder.Add(new Order("que rerum ac ", Convert.ToDateTime("05/02/2016"), 10, 65));
    objListOrder.Add(new Order("locorum ; cuius", Convert.ToDateTime("06/01/2016"), 1, 343));


    Console.WriteLine("Sort the list by date ascending:");
    objListOrder.Sort((x, y) => x.OrderDate.CompareTo(y.OrderDate));

    foreach (Order o in objListOrder)
        Console.WriteLine("OrderId = " + o.OrderId + " OrderDate = " + o.OrderDate.ToString() + " Quantity = " + o.Quantity + " Total = " + o.Total);

    Console.WriteLine("Sort the list by date descending:");
    objListOrder.Sort((x, y) => y.OrderDate.CompareTo(x.OrderDate));
    foreach (Order o in objListOrder)
        Console.WriteLine("OrderId = " + o.OrderId + " OrderDate = " + o.OrderDate.ToString() + " Quantity = " + o.Quantity + " Total = " + o.Total);

    Console.WriteLine("Sort the list by OrderId ascending:");
    objListOrder.Sort((x, y) => x.OrderId.CompareTo(y.OrderId));
    foreach (Order o in objListOrder)
        Console.WriteLine("OrderId = " + o.OrderId + " OrderDate = " + o.OrderDate.ToString() + " Quantity = " + o.Quantity + " Total = " + o.Total);

    //etc ...
}
— molbalga
সূত্র
1

জেনেরিক টাইপটির তুলনার ভিত্তিতে :
আমরা বাছাই করা পতাকাগুলি যুক্ত করে আরও নমনীয়তা অর্জন করতে পারি: 

public class MyOrderingClass : IComparer<Order> {  
    public int Compare(Order x, Order y) {  
        int compareDate = x.Date.CompareTo(y.Date);  
        if (compareDate == 0) {  
            int compareOrderId = x.OrderID.CompareTo(y.OrderID);  

            if (OrderIdDescending) {  
                compareOrderId = -compareOrderId;  
            }  
            return compareOrderId;  
        }  

        if (DateDescending) {  
            compareDate = -compareDate;  
        }  
        return compareDate;  
    }  

    public bool DateDescending { get; set; }  
    public bool OrderIdDescending { get; set; }  
}

এই দৃশ্যে, এর বাছাই করার বৈশিষ্ট্যগুলি নির্ধারণের জন্য আপনাকে অবশ্যই এটি স্পষ্টভাবে মাইআর্ডারিংক্লাস হিসাবে ইনস্ট্যান্ট করতে হবে (বরং তারপরে আইসি কম্পিউটার )
: 

MyOrderingClass comparer = new MyOrderingClass();  
comparer.DateDescending = ...;  
comparer.OrderIdDescending = ...;  
orderList.Sort(comparer);
— জ্যাক গ্রিফিন
সূত্র
1

উপরের উত্তরগুলির মধ্যে আমার পক্ষে যথেষ্ট জেনেরিক ছিল না তাই আমি এটি একটি করেছিলাম:

var someUserInputStringValue = "propertyNameOfObject i.e. 'Quantity' or 'Date'";
var SortedData = DataToBeSorted
                   .OrderBy(m => m.GetType()
                                  .GetProperties()
                                  .First(n => 
                                      n.Name == someUserInputStringValue)
                   .GetValue(m, null))
                 .ToList();

যদিও বিশাল ডেটা সেটগুলিতে যত্নশীল। এটি সহজ কোড তবে সংগ্রহটি বিশাল এবং সংগ্রহের অবজেক্টের ধরণের একটি বিশাল সংখ্যক ক্ষেত্র থাকলে আপনাকে সমস্যায় ফেলতে পারে। রান সময় NxM যেখানে:

সংগ্রহের উপাদানগুলির N = #

অবজেক্টের মধ্যে থাকা বৈশিষ্ট্যগুলির এম = #

— itcropper
সূত্র
1

Valueযেহেতু nallable প্রকারের সাথে কাজ করছেন, এটি ব্যবহার করা প্রয়োজন CompareTo।

objListOrder.Sort((x, y) => x.YourNullableType.Value.CompareTo(y.YourNullableType.Value));

— যিহূদা
সূত্র
0

পারফরম্যান্সের দৃষ্টিকোণ থেকে সর্বাধিক হ'ল একটি বাছাই করা তালিকা ব্যবহার করা যাতে ফলাফলের সাথে যুক্ত হওয়ার সাথে সাথে ডেটা বাছাই করা হয়। অন্যান্য পদ্ধতির ডেটাতে কমপক্ষে একটি অতিরিক্ত পুনরাবৃত্তি প্রয়োজন এবং বেশিরভাগ ডেটার একটি অনুলিপি তৈরি করে তাই কেবল কার্য সম্পাদনই নয় মেমরির ব্যবহারও প্রভাবিত হবে। কয়েক শতাধিক উপাদানগুলির সাথে সমস্যা নাও হতে পারে তবে কয়েক হাজারের সাথে থাকবে, বিশেষত পরিষেবাগুলিতে যেখানে একই সাথে অনেকগুলি সমবর্তী অনুরোধগুলি বাছাই করতে পারে। সিস্টেম.কলেকশন.জেনেরিক নেমস্পেসটি দেখুন এবং তালিকার পরিবর্তে বাছাই সহ একটি শ্রেণি চয়ন করুন।

এবং সম্ভব হলে প্রতিবিম্ব ব্যবহার করে জেনেরিক প্রয়োগগুলি এড়িয়ে চলুন, এটি পারফরম্যান্সের সমস্যার কারণও হতে পারে।

— user3285954
সূত্র
কীভাবে এটি আরও পারফরম্যান্স হতে পারে? বাছাই করা তালিকায় ডেটা োকানো হয় ও (এন), সুতরাং এন আইটেম যুক্ত করা হ'ল হে (এন ^ 2)। এটি অনেকগুলি সমবর্তী আইটেমগুলি যুক্ত করার চেষ্টা করছে? এমন কিছু পরিস্থিতি রয়েছে যখন আইটেম যুক্ত করার সময় আপনার কাছে অতিরিক্ত সিপিইউ চক্র জ্বলতে থাকে তবে এটি ভাল সাধারণ সমাধান নয়।
— জন লা রুই
0

ধরুন আপনার এই কোডটিতে নীচের কোড রয়েছে, আমাদের কয়েকটি যাত্রীর ক্লাস রয়েছে যার কয়েকটি বৈশিষ্ট্য আমরা ভিত্তিতে বাছাই করতে চাই।

public class Passenger
{
    public string Name { get; }
    public string LastName { get; }
    public string PassportNo { get; }
    public string Nationality { get; }

    public Passenger(string name, string lastName, string passportNo, string nationality)
    {
        this.Name = name;
        this.LastName = lastName;
        this.PassportNo = passportNo;
        this.Nationality = nationality;
    }

    public static int CompareByName(Passenger passenger1, Passenger passenger2)
    {
        return String.Compare(passenger1.Name, passenger2.Name);
    }

    public static int CompareByLastName(Passenger passenger1, Passenger passenger2)
    {
        return String.Compare(passenger1.LastName, passenger2.LastName);
    }

    public static int CompareNationality(Passenger passenger1, Passenger passenger2)
    {
        return String.Compare(passenger1.Nationality, passenger2.Nationality);
    }
}

public class TestPassengerSort
{
    Passenger p1 = new Passenger("Johon", "Floid", "A123456789", "USA");
    Passenger p2 = new Passenger("Jo", "Sina", "A987463215", "UAE");
    Passenger p3 = new Passenger("Ped", "Zoola", "A987855215", "Italy");

    public void SortThem()
    {
        Passenger[] passengers = new Passenger[] { p1, p2, p3 };
        List<Passenger> passengerList = new List<Passenger> { p1, p2, p3 };

        Array.Sort(passengers, Passenger.CompareByName);
        Array.Sort(passengers, Passenger.CompareByLastName);
        Array.Sort(passengers, Passenger.CompareNationality);

        passengerList.Sort(Passenger.CompareByName);
        passengerList.Sort(Passenger.CompareByLastName);
        passengerList.Sort(Passenger.CompareNationality);

    }
}

সুতরাং আপনি রচনা প্রতিনিধি ব্যবহার করে আপনার সাজানোর কাঠামো বাস্তবায়ন করতে পারেন।

— সাইয়েদরাফ মোদার্রেসি
সূত্র
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.