दिलचस्प पोस्ट
@ViewChild और @ContentChild के बीच अंतर क्या है? मैं जावास्क्रिप्ट में वर्तमान तारीख कैसे प्राप्त करूं? चर के साथ अभिव्यक्ति के लिए grep दिए गए स्ट्रिंग के लिए सभी अनन्य सबस्ट्रिंग उत्पन्न करें क्या JAXB- एनोटेट किए गए वर्ग से एक्सएसडी उत्पन्न करना संभव है? प्रतिबिंब के माध्यम से जावा स्थिर अंतिम ivar मान तक पहुँचने सरलडेटफ़ॉर्मेट पार्स समयक्षेत्र खो देता है उद्देश्य सी के बजाय कोको के साथ सी ++ का उपयोग करें? स्ट्रिंग कैसे एनएटी में पारित हो जाती है? केंद्र और नीचे-संरेखित फ्लेक्स आइटम स्प्रिंग जेपीए विशिष्ट कॉलम का चयन करना कैसे पढ़ा जाए कि PHP में चेकबॉक्स की जाँच की जाती है? एक निर्देशिका में दो जीआईटी रिपॉजिटरी? सूचियों की सूची में अजगर खोज "प्रॉम्प्ट पर या स्क्रिप्ट में फ़ंक्शन परिभाषाएं अनुमत नहीं हैं"

मैं Linq आदेश को गतिशील रूप से तर्क कैसे निर्दिष्ट करूं?

मैं एक पैरामीटर के रूप में ले जाने वाले मान का उपयोग करके orderby लिए दिया गया तर्क कैसे निर्दिष्ट करूं?

उदाहरण के लिए:

 List<Student> existingStudends = new List<Student>{ new Student {...}, new Student {...}} 

वर्तमान में कार्यान्वयन:

 List<Student> orderbyAddress = existingStudends.OrderBy(c => c.Address).ToList(); 

सी। के बजाय, मैं यह कैसे एक पैरामीटर के रूप में ले सकता हूँ?

उदाहरण

  string param = "City"; List<Student> orderbyAddress = existingStudends.OrderByDescending(c => param).ToList(); 

वेब के समाधान से एकत्रित समाधान "मैं Linq आदेश को गतिशील रूप से तर्क कैसे निर्दिष्ट करूं?"

प्रतिबिंब का उपयोग करके यह एक संभावना है …

 var param = "Address"; var propertyInfo = typeof(Student).GetProperty(param); var orderByAddress = items.OrderBy(x => propertyInfo.GetValue(x, null)); 

आप अभिव्यक्ति के पेड़ का निर्माण करने के लिए थोड़ा सा प्रतिबिंब का उपयोग कर सकते हैं (यह एक एक्सटेंशन विधि है):

 public static IQueryable<TEntity> OrderBy<TEntity>(this IQueryable<TEntity> source, string orderByProperty, bool desc) { string command = desc ? "OrderByDescending" : "OrderBy"; var type = typeof(TEntity); var property = type.GetProperty(orderByProperty); var parameter = Expression.Parameter(type, "p"); var propertyAccess = Expression.MakeMemberAccess(parameter, property); var orderByExpression = Expression.Lambda(propertyAccess, parameter); var resultExpression = Expression.Call(typeof(Queryable), command, new Type[] { type, property.PropertyType }, source.Expression, Expression.Quote(orderByExpression)); return source.Provider.CreateQuery<TEntity>(resultExpression); } 

orderByProperty वह प्रॉपर्टी नाम है जिसे आप ऑर्डर करना चाहते हैं और यदि desc लिए पैरामीटर के रूप में सही है, तो अवरोही क्रम में क्रमबद्ध होगा; अन्यथा, आरोही क्रम में क्रमबद्ध होगा

अब आप existingStudents.OrderBy("City",true); स्टूडेंट्स को करने में सक्षम होना चाहिए। existingStudents.OrderBy("City",true); या existingStudents.OrderBy("City",false);

  private Func<T, object> GetOrderByExpression<T>(string sortColumn) { Func<T, object> orderByExpr = null; if (!String.IsNullOrEmpty(sortColumn)) { Type sponsorResultType = typeof(T); if (sponsorResultType.GetProperties().Any(prop => prop.Name == sortColumn)) { System.Reflection.PropertyInfo pinfo = sponsorResultType.GetProperty(sortColumn); orderByExpr = (data => pinfo.GetValue(data, null)); } } return orderByExpr; } public List<T> OrderByDir<T>(IEnumerable<T> source, string dir, Func<T, object> OrderByColumn) { return dir.ToUpper() == "ASC" ? source.OrderBy(OrderByColumn).ToList() : source.OrderByDescending(OrderByColumn).ToList();`` } // Call the code like below var orderByExpression= GetOrderByExpression<SearchResultsType>(sort); var data = OrderByDir<SponsorSearchResults>(resultRecords, SortDirectionString, orderByExpression); 

1) स्थापित करें System.Linq.Dynamic

2) निम्न कोड जोड़ें

 public static class OrderUtils { public static string ToStringForOrdering<T, TKey>(this Expression<Func<T, TKey>> expression, bool isDesc = false) { var str = expression.Body.ToString(); var param = expression.Parameters.First().Name; str = str.Replace("Convert(", "(").Replace(param + ".", ""); return str + (isDesc ? " descending" : ""); } } 

3) लम्बेडा फ़ंक्शन का चयन करने के लिए अपना स्विच लिखें

 public static class SortHelper { public static Expression<Func<UserApp, object>> UserApp(string orderProperty) { orderProperty = orderProperty?.ToLowerInvariant(); switch (orderProperty) { case "firstname": return x => x.PersonalInfo.FirstName; case "lastname": return x => x.PersonalInfo.LastName; case "fullname": return x => x.PersonalInfo.FirstName + x.PersonalInfo.LastName; case "email": return x => x.Email; } } } 

4) अपने सहायकों का उपयोग करें

 Dbset.OrderBy(SortHelper.UserApp("firstname").ToStringForOrdering()) 

5) आप इसे pagging ( PagedList ) के साथ उपयोग कर सकते हैं

 public virtual IPagedList<T> GetPage<TOrder>(Page page, Expression<Func<T, bool>> where, Expression<Func<T, TOrder>> order, bool isDesc = false, params Expression<Func<T, object>>[] includes) { var orderedQueryable = Dbset.OrderBy(order.ToStringForOrdering(isDesc)); var query = orderedQueryable.Where(where).GetPage(page); query = AppendIncludes(query, includes); var results = query.ToList(); var total = Dbset.Count(where); return new StaticPagedList<T>(results, page.PageNumber, page.PageSize, total); } 

व्याख्या

System.Linq.Dynamic हमें OrderBy विधि में स्ट्रिंग मान सेट करने की अनुमति देता है। लेकिन इस विस्तार के अंदर स्ट्रिंग लैम्ब्डा को पार्स किया जाएगा। तो मैंने सोचा कि यह काम करेगा अगर हम लैम्ब्डा को स्ट्रिंग में पार्स करते हैं और इसे ऑर्डर-बीआई विधि को देते हैं। और यह काम करता है!

यह एक ऐसी स्थिति है जिसमें मैं सशर्त उतरने के साथ काम करने के लिए आया हूं। आप keySelector को keySelector करने के अन्य तरीकों के साथ गठबंधन कर सकते हैं।

  public static IOrderedQueryable<TSource> OrderBy<TSource, TKey>(this IQueryable<TSource> source, System.Linq.Expressions.Expression<Func<TSource, TKey>> keySelector, System.ComponentModel.ListSortDirection sortOrder ) { if (sortOrder == System.ComponentModel.ListSortDirection.Ascending) return source.OrderBy(keySelector); else return source.OrderByDescending(keySelector); } 

उपयोग:

 //imagine this is some parameter var direction = System.ComponentModel.ListSortDirection.Ascending; query = query.OrderBy(ec => ec.MyColumnName, direction); 

नोटिस यह आपको यह चेन करने की अनुमति देता है। किसी भी IQueryable पर किसी नए पैरामीटर के साथ .OrderBy एक्सटेंशन।

 // perhaps passed in as a request of user to change sort order // var direction = System.ComponentModel.ListSortDirection.Ascending; query = context.Orders .Where(o => o.Status == OrderStatus.Paid) .OrderBy(ec => ec.OrderPaidUtc, direction); 

यह आपको एक string , जैसा कि आपने अपने प्रश्न में पूछा था, लेकिन यह अभी भी आपके लिए काम कर सकता है

OrderByDescending विधि एक Func<TSource, TKey> लेता है, ताकि आप अपने फ़ंक्शन को इस तरीके से दोबारा लिख ​​सकें:

 List<Student> QueryStudents<TKey>(Func<Student, TKey> orderBy) { return existingStudents.OrderByDescending(orderBy).ToList(); } 

OrderByDescending लिए अन्य अतिरिक्त बोझ भी हैं जो Expression<Func<TSource, TKey>> , और / या IComparer<TKey> Expression<Func<TSource, TKey>> । आप उन में भी देख सकते हैं और देखें कि क्या वे आपको कुछ भी उपयोग करते हैं

मेरे लिए काम करने वाला एकमात्र समाधान यहां https://gist.github.com/neoGeneva/1878868 पर neoGeneva द्वारा पोस्ट किया गया था।

मैं अपने कोड को फिर से पोस्ट करूंगा क्योंकि यह अच्छी तरह से काम करता है और मैं यह नहीं चाहता कि यह इंटरवेज में खो जाए!

  public static IQueryable<T> OrderBy<T>(this IQueryable<T> source, string sortExpression) { if (source == null) throw new ArgumentNullException("source", "source is null."); if (string.IsNullOrEmpty(sortExpression)) throw new ArgumentException("sortExpression is null or empty.", "sortExpression"); var parts = sortExpression.Split(' '); var isDescending = false; var propertyName = ""; var tType = typeof(T); if (parts.Length > 0 && parts[0] != "") { propertyName = parts[0]; if (parts.Length > 1) { isDescending = parts[1].ToLower().Contains("esc"); } PropertyInfo prop = tType.GetProperty(propertyName); if (prop == null) { throw new ArgumentException(string.Format("No property '{0}' on type '{1}'", propertyName, tType.Name)); } var funcType = typeof(Func<,>) .MakeGenericType(tType, prop.PropertyType); var lambdaBuilder = typeof(Expression) .GetMethods() .First(x => x.Name == "Lambda" && x.ContainsGenericParameters && x.GetParameters().Length == 2) .MakeGenericMethod(funcType); var parameter = Expression.Parameter(tType); var propExpress = Expression.Property(parameter, prop); var sortLambda = lambdaBuilder .Invoke(null, new object[] { propExpress, new ParameterExpression[] { parameter } }); var sorter = typeof(Queryable) .GetMethods() .FirstOrDefault(x => x.Name == (isDescending ? "OrderByDescending" : "OrderBy") && x.GetParameters().Length == 2) .MakeGenericMethod(new[] { tType, prop.PropertyType }); return (IQueryable<T>)sorter .Invoke(null, new object[] { source, sortLambda }); } return source; } 

मैं पार्टी में देर से हूं लेकिन इनमें से कोई भी समाधान मेरे लिए काम नहीं करता। मैं सिस्टम की कोशिश करने के लिए उत्सुक था। Linq.Dynamic, लेकिन मुझे लगता है कि Nuget पर, शायद घिस पाया नहीं जा सका? किसी भी तरह से…

यहाँ एक समाधान है जिसके साथ मैं आया हूं। मुझे क्रमशः आदेश , मिश्रण, आदेश और आदेश के मिश्रण का उपयोग करने के लिए गतिशील रूप से आवश्यक था।

मैं बस मेरी सूची ऑब्जेक्ट के लिए एक एक्सटेंशन विधि बनाया, एक बिट हैकी जो मुझे पता है … मैं यह नहीं सुझाऊंगा कि यह बहुत कुछ कर रहा था, लेकिन यह एक के लिए अच्छा है।

 List<Employee> Employees = GetAllEmployees(); foreach(Employee oEmployee in Employees.ApplyDynamicSort(eEmployeeSort)) { //do stuff } public static IOrderedEnumerable<Employee> ApplyDynamicSort(this List<Employee> lEmployees, Enums.EmployeeSort eEmployeeSort) { switch (eEmployeeSort) { case Enums.EmployeeSort.Name_ASC: return lEmployees.OrderBy(x => x.Name); case Enums.EmployeeSort.Name_DESC: return lEmployees.OrderByDescending(x => x.Name); case Enums.EmployeeSort.Department_ASC_Salary_DESC: return lEmployees.OrderBy(x => x.Department).ThenByDescending(y => y.Salary); default: return lEmployees.OrderBy(x => x.Name); } } 
  • अपने कोड के लिए डायगमाइट पैकेज जोड़ें

  • नामस्थान डायनेमाइट जोड़ें। एक्सटेंशन उदाहरण: डायनामाइट का उपयोग। एक्सटेंशन;

  • किसी भी एसक्यूएल क्वेरी ईग की तरह क्वेरी से ऑर्डर दें: students.OrderBy ("City DESC, पता")। ToList ();