क्या दो चर के साथ चयन कथन करने का कोई प्रभावी तरीका है?

Question

मेरे सी # कोड में, मुझे दो गैर-शून्य चर का मूल्यांकन करने की आवश्यकता है। मैंने का एक सेट तैयार किया है, यदि अन्य कथन, लेकिन मेरे दिमाग में यह बदसूरत और थोड़ा सा मैला दिखता है, भले ही यह सही हो।

मैंने MSDN Library में देखा और एकल चर के आधार पर चयन के लिए केवल उदाहरण देखा।

क्या एक ही परिणाम प्राप्त करने के लिए एक क्लीनर और अधिक कॉम्पैक्ट तरीका है?

अद्यतन: मैंने अधिक संदर्भ प्रदान करने के लिए कोड भर दिया। इसे और अधिक देखकर, शायद मैं पैरामीटर के आधार पर सीधे linq क्वेरी में हेरफेर कर सकता हूं। हालांकि, प्रश्न जो मैं उत्पन्न करता हूं, वह सामान्य है जिसे मैं ध्यान केंद्रित करना चाहता हूं: चयन के बाद उपयोग किए गए कोड के बजाय चयन।

public ActionResult Index(string searchBy, string orderBy, string orderDir) 
{ 
    var query = fca.GetResultsByFilter(searchBy); 

    if (orderBy == "Campus" && orderDir == "Asc") 
    { 
     query = query = query.OrderBy(s => s.Campus).ThenBy(s => s.Student_Name); 
    } 
    else if (orderBy == "Campus" && orderDir == "Desc") 
    { 
    query = query.OrderByDescending(s => s.Campus); 
    } 
    else if (orderBy == "Student Name" && orderDir == "Asc") 
    { 
     query = query = query.OrderBy(s => s.Student_Name); 
    } 
    else if (orderBy == "Student Name" && orderDir == "Desc") 
    { 
     query = query.OrderByDescending(s => s.Student_Name); 
    } 
    else if (orderBy == "Course Count" && orderDir == "Asc") 
    { 
    query = query.OrderBy(s => s.Course_Count); 
    } 
    else if (orderBy == "Course Count" && orderDir == "Desc") 
    { 
    query = query.OrderByDescending(s => s.Course_Count); 
    } 
} 

Answer 1

आप है कि या तो OrderBy या OrderByDescending साथ आदेश देने हैंडल IQueryable पर एक विस्तार विधि बना सकते हैं। यदि यह वास्तव में IEnumerable<> देता है, तो एक्सटेंशन विधि को IEnumerable<TSource> source पैरामीटर लेने और इसके बजाय IOrderedEnumerable<TSource> वापस करने की आवश्यकता होगी।

public ActionResult Index(string searchBy, string orderBy, string orderDir) 
{ 
    var query = fca.GetResultsByFilter(searchBy); 

    switch (orderBy) 
    { 
     case "Campus": 
      query = query.OrderByWithDirection(s => s.Campus, orderDir); 
      break; 
     case "Student Name": 
      query = query.OrderByWithDirection(s => s.Student_Name, orderDir); 
      break; 
     case "Course Count": 
      query = query.OrderByWithDirection(s => s.Course_Count, orderDir); 
      break; 
    } 

    if (orderBy == "Campus" && orderDir == "Asc") 
    { 
     // The Campus Asc case was also ordered by Student_Name in the question. 
     query = query.ThenBy(s => s.Student_Name); 
    } 
} 

Answer 2

मैं इस तरह पढ़ने के लिए अधिक कॉम्पैक्ट और आसान बनाने के लिए तीसरे ऑपरेटर का उपयोग करूंगा।

इससे कुछ बूलियन जांच भी समाप्त हो जाएगी क्योंकि यह उनमें से किसी को डुप्लिकेट नहीं करता है।

public ActionResult Index(string searchBy, string orderBy, string orderDir) 
    { 
     var query = fca.GetResultsByFilter(searchBy); 

     if (orderBy == "Campus") 
     { 
      query = (orderDir == "Asc") ? query.OrderBy(s => s.Campus).ThenBy(s => s.Student_Name) : 
       query.OrderByDescending(s => s.Campus); 
     } 
     else if (orderBy == "Student Name") 
     { 
      query = (orderDir == "Asc") ? query.OrderBy(s => s.Student_Name) : query.OrderByDescending(s => s.Student_Name); 
     } 
     else if (orderBy == "Course Count") 
     { 
      query = (orderDir == "Asc") ? query.OrderBy(s => s.Student_Name) : query.OrderByDescending(s => s.Course_Count); 
     } 
    } 

Answer 3

सीएनओटी सुनिश्चित करें कि यह बेहतर है, तो बस अलग है।

public static class QueryableExtensions 
{ 
    public static IOrderedQueryable<TSource> OrderByWithDirection<TSource,TKey> 
     (this IQueryable<TSource> source, 
     Expression<Func<TSource, TKey>> keySelector, 
     string orderDir) 
    { 
     return orderDir == "Desc" 
         ? source.OrderByDescending(keySelector) 
         : source.OrderBy(keySelector); 
    } 
} 

मैं यह सोचते हैं रहा है कि अपने GetResultsByFilter विधि एक IQueryable<> लौटा रहा है:

switch (orderDir) 
{ 
    case "Asc": 
     Switch (orderBy) 
     { 
      case "Campus": 
       //Code here for Campus orderBy and Asc orderDir 
       break; 
      case "Student Name": 
       //Code here for Student Name orderBy and Asc orderDir 
       break; 
      case "Course Count": 
       //Code here for Course Count orderBy and Asc orderDir 
       break; 
     } 
     break; 
    case "Desc": 
     Switch (orderBy) 
     { 
      case "Campus": 
       //Code here for Campus orderBy and Desc orderDir 
       break; 
      case "Student Name": 
       //Code here for Student Name orderBy and Desc orderDir 
       break; 
      case "Course Count": 
       //Code here for Course Count orderBy and Desc orderDir 
       break; 
     } 
     break; 
} 

Answer 4

मेरे ले:

public interface IOrder { 
    void perform(Query query) 
} 

public abstract class AbstractOrder : IOrder { 

    protected string orderString; 

    public AbstractOrder(string orderString) { 
     this.orderString = orderString; 
    } 
} 

public class OrderAsc { 

    public OrderAsc(string orderString) : base(orderString) { 
    } 

    public Query perform(Query query) { 
     query = query.OrderBy(s => s.Course_Count); //here you still have to do a mapping between orderString and your db field s.Course_count 
     return query; 
    } 
} 

public class OrderDesc { 

    public OrderDesc(string orderString) : base(orderString) { 
    } 

    public Query perform(Query query) { 
     query = query.OrderByDescending(s => s.Course_Count); //here you still have to do a mapping between orderString and your db field s.Course_count, or maybe it's equal, then you can just replace it. 
     return query; 
    } 
} 

फिर ...

IList<IOrder> list = new List<IOrder>() {new OrderAsc("Campus"), new OrderDesc("Student Name")} 

foreach(IOrder o in list) { 
    query = o.perform(query); 
} 

इसमें कुछ गलतियां हो सकता है, मैं डॉन

यह तो इस प्रकार किया जा सकता है हाथ पर एक आईडीई नहीं है।