Có cách nào hiệu quả để thực hiện câu lệnh chọn với hai biến không?

Question

Trong mã C# của tôi, tôi cần đánh giá hai biến không null. Tôi đã làm việc ra một tập hợp các câu lệnh if-else nếu, nhưng trong đầu tôi có vẻ xấu xí và hơi quá cẩu thả, ngay cả khi nó đúng.

Tôi đã xem trong số MSDN Library và chỉ xem các ví dụ để lựa chọn dựa trên một biến duy nhất.

Có cách nào gọn gàng hơn và gọn gàng hơn để đạt được kết quả tương tự không?

Cập nhật: Tôi điền mã để cung cấp thêm ngữ cảnh. Nhìn vào điều này nhiều hơn, có lẽ tôi có thể thao tác truy vấn LINQ trực tiếp dựa trên các tham số. Tuy nhiên, câu hỏi tôi đặt ra là là loại chung mà tôi muốn tập trung vào: lựa chọn thay vì mã được sử dụng sau khi lựa chọn được thực hiện.

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

Bạn có thể tạo ra một phương pháp mở rộng trên IQueryable xử lý đặt hàng với một trong hai OrderBy hoặc OrderByDescending:

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

Tôi giả định rằng phương pháp GetResultsByFilter của bạn được trả lại một IQueryable<>. Nếu nó thực sự trả về một IEnumerable<>, thì phương pháp mở rộng sẽ cần phải tham số IEnumerable<TSource> source và trả lại một IOrderedEnumerable<TSource> thay thế.

này sau đó có thể được sử dụng như sau:

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

Tôi sẽ sử dụng toán tử bậc ba để làm gọn hơn và dễ đọc hơn như thế này.

Điều này cũng sẽ cắt bỏ một số kiểm tra boolean vì nó không trùng lặp bất kỳ trong số chúng.

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

CNot chắc chắn nếu điều này tốt hơn, chỉ khác nhau.

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

mất của tôi:

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

sau đó ...

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

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

Có thể có một số sai lầm trong nó, tôi don không có một IDE trong tầm tay.