වස්තුවක ඇති දේපලකින් ලැයිස්තුවක් වර්ග කරන්නේ කෙසේද <T>

මම නමින් පන්තියට Orderවැනි ගුණ ඇති OrderId, OrderDate, Quantity, සහ Total. මට මෙම Orderපන්තියේ ලැයිස්තුවක් ඇත :

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

දැන් මට Orderවස්තුවෙහි එක් දේපලක් මත පදනම්ව ලැයිස්තුව වර්ග කිරීමට අවශ්‍යයි , උදාහරණයක් ලෙස ඇණවුම් දිනය හෝ ඇණවුම් හැඳුනුම්පත අනුව එය වර්ග කිරීමට මට අවශ්‍යය.

C # හි මෙය කරන්නේ කෙසේද?

මට සිතිය හැකි පහසුම ක්‍රමය වන්නේ ලින්ක් භාවිතා කිරීමයි:

List<Order> SortedList = objListOrder.OrderBy(o=>o.OrderDate).ToList();

ඔබට ලැයිස්තුව නිසි පරිදි වර්ග කිරීමට අවශ්‍ය නම් ඔබට එම Sortක්‍රමය භාවිතා කළ හැකිය Comparison<T>.

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

තැනින් තැන වර්ග කරනවාට වඩා නව, වර්ග කළ අනුක්‍රමයක් නිර්මාණය කිරීමට ඔබ කැමති නම් OrderBy, අනෙක් පිළිතුරු වල සඳහන් පරිදි ඔබට LINQ ක්‍රමය භාවිතා කළ හැකිය .

.Net2.0 හි LINQ නොමැතිව මෙය කිරීමට:

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

ඔබ .Net3.0 හි සිටී නම්, ලූක්ගේ පිළිතුර ඔබ පසුපසින් යන දෙයයි.

බහු ගුණාංග වර්ග කිරීම සඳහා, ඔබට එය නියෝජිතයෙකු තුළ කළ හැකිය. උදාහරණයක් වශයෙන්:

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 පන්තිය භාවිතා කිරීම සඳහා, එය ක්ෂණිකව සකසා ඔබේ වර්ග කිරීමේ ක්‍රමයට යොමු කරන්න:

IComparer<Order> comparer = new MyOrderingClass();
orderList.Sort(comparer);

ලැයිස්තුවක් ඇණවුම් කිරීමට සරලම ක්‍රමය භාවිතා කිරීමයි OrderBy

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

ඔබට SQL විමසුම අනුගමනය කිරීම වැනි තීරු කිහිපයකින් ඇණවුම් කිරීමට අවශ්‍ය නම්.

ORDER BY OrderDate, OrderId

මෙය සාක්ෂාත් කර ගැනීම සඳහා ඔබට ThenByපහත සඳහන් පරිදි භාවිතා කළ හැකිය .

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

ඔබ කී පරිදි ලින්ක් නොමැතිව එය කිරීම:

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 () අමතන්න

සම්භාව්‍ය වස්තුව දිශානත විසඳුමක්

පළමුවෙන්ම මම ලින්ක් හි විශ්මය ජනක බව වටහා ගත යුතුය .... දැන් අපට එය මඟ හැරී ඇත

ජිමී හොෆා පිළිතුරේ වෙනසක්. ජනක විද්‍යාව සමඟ 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" මාරු කිරීම (හෝ තාර්කික ක්‍රියාකරුවන්, ඔබේ තේරීම) වර්ග කිරීමේ අනුපිළිවෙල ආපසු හරවයි.

ග්‍රිඩ් දර්ශනයක් සමඟ භාවිතා කිරීම සඳහා සම්පුර්ණයෙන්ම සාමාන්‍ය වර්ග කිරීම

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

ලැයිස්තුවේ අමතර පිටපතක් නිර්මාණය නොකරන සාමාන්‍ය LINQ දිගු කිරීමේ ක්‍රමයක් මෙන්න:

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

LINQ භාවිතා කිරීම

objListOrder = GetOrderList()
                   .OrderBy(o => o.OrderDate)
                   .ToList();

objListOrder = GetOrderList()
                   .OrderBy(o => o.OrderId)
                   .ToList();

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

රොජර්ගේ අනුවාදය වැඩි දියුණු කිරීම.

GetDynamicSortProperty හි ඇති ගැටළුව නම් දේපල නම් පමණක් ලබා ගැනීමයි. නමුත් ග්‍රිඩ්වීව් හි අපි NavigationProperties භාවිතා කරන්නේ නම් කුමක් සිදුවේද? එය ශුන්‍ය බව සොයා ගන්නා බැවින් එය ව්‍යතිරේකයක් යවනු ඇත.

උදාහරණයක්:

"Employee.Company.Name;" බිඳ වැටෙනු ඇත ... පරාමිතියක් ලෙස එහි නම ලබා ගැනීමට "නම" පමණක් ඉඩ දෙන බැවින්.

සංචාලන ගුණාංග අනුව වර්ග කිරීමට අපට ඉඩ දෙන වැඩි දියුණු කළ අනුවාදයක් මෙන්න.

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


    } 

දේපල තේරීම පිළිබඳව ඔබට වඩාත් සාමාන්‍ය දෙයක් කළ හැකි නමුත් ඔබ තෝරා ගන්නා වර්ගය ගැන නිශ්චිත වන්න.

ඔබේ ශ්‍රිතය සාමාන්‍ය එකක් ලෙස ලියන්න:

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

එය ලින්ක් ශෛලියක් වන 'ඕඩර්බයි' කිරීමේ මෝඩ අනවශ්‍ය සංකීර්ණ ක්‍රමයකි, නමුත් එය සාමාන්‍ය ආකාරයකින් ක්‍රියාත්මක කළ හැකි ආකාරය පිළිබඳ ඉඟියක් ඔබට ලබා දෙනු ඇත.

කරුණාකර නියැදි කේතයක් සමඟ ukLukeH විසින් පිළිතුර සම්පූර්ණ කිරීමට මට ඉඩ දෙන්න, මම එය පරීක්ෂා කර ඇති බැවින් එය සමහරුන්ට ප්‍රයෝජනවත් වනු ඇතැයි මම විශ්වාස කරමි:

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

var obj = db.Items.Where...

var orderBYItemId = obj.OrderByDescending(c => Convert.ToInt32(c.ID));

LiNQ භාවිතා කරන්න OrderBy

List<Order> objListOrder=new List<Order> ();
    objListOrder=GetOrderList().OrderBy(o=>o.orderid).ToList();

GenericTypeTea හි සංසන්දකයා මත පදනම්ව
: කොඩි වර්ග කිරීමෙන් අපට වඩාත් නම්‍යශීලී බවක් ලබා ගත හැකිය:

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 ලෙස (ඒ වෙනුවට IComparer )
ස්ථාපනය කළ යුතුය:

MyOrderingClass comparer = new MyOrderingClass();  
comparer.DateDescending = ...;  
comparer.OrderIdDescending = ...;  
orderList.Sort(comparer);  

ඉහත පිළිතුරු කිසිවක් මට ප්‍රමාණවත් නොවූ නිසා මම මෙය කළෙමි:

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 = #

M = # වස්තුව තුළ ඇති දේපල

අහෝසි කළ හැකි වර්ග සමඟ වැඩ කරන ඕනෑම කෙනෙකුට Valueභාවිතා කිරීමට අවශ්‍ය වේ CompareTo.

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

ඔබට පහත කේතය ඇතැයි සිතමු, මෙම කේතයේ, අපට පදනම් කර ගෙන වර්ග කිරීමට අවශ්‍ය ගුණාංග කිහිපයක් සහිත මගී පන්තියක් අප සතුව ඇත.

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

    }
}

එබැවින් සංයුති නියෝජිතයා භාවිතා කිරීමෙන් ඔබට ඔබේ වර්ග කිරීමේ ව්‍යුහය ක්‍රියාත්මක කළ හැකිය.

කාර්ය සාධන දෘෂ්ටි කෝණයෙන් බැලූ විට හොඳම දෙය වන්නේ වර්ග කළ ලැයිස්තුවක් භාවිතා කිරීමයි. වෙනත් ප්‍රවේශයන් සඳහා දත්ත සඳහා අවම වශයෙන් එක් අමතර ක්‍රියාවක් අවශ්‍ය වන අතර බොහෝ ඒවා දත්ත පිටපතක් නිර්මාණය කරයි, එවිට කාර්ය සාධනය පමණක් නොව මතක භාවිතය ද බලපානු ඇත. මූලද්‍රව්‍ය සිය ගණනක් සමඟ ගැටළුවක් නොවිය හැකි නමුත් දහස් ගණනක් සමඟ විය හැකිය, විශේෂයෙන් බොහෝ සමගාමී ඉල්ලීම් එකවර වර්ග කිරීම කළ හැකි සේවාවන්හි. System.Collections.Generic නාම අවකාශය දෙස බලා ලැයිස්තුව වෙනුවට වර්ග කිරීම සහිත පන්තියක් තෝරන්න.

හැකි සෑම විටම පරාවර්තනය භාවිතා කරමින් සාමාන්‍ය ක්‍රියාත්මක කිරීමෙන් වළකින්න, මෙය කාර්ය සාධන ගැටළු ද ඇති කළ හැකිය.