blocks|key|794775|text|这不会像您在问题中所要求的那样让您传递string，但它可能仍然适用于您。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|794776|OrderByDescending方法接受一个Func<TSource,+TKey>，因此您可以这样重写函数：|794777|List<Student>+QueryStudents<TKey>(Func<Student,+TKey>+orderBy)
{
++++return+existingStudents.OrderByDescending(orderBy).ToList();
}|code-block|syntax|javascript|794778|OrderByDescending还有其他重载，可以接受Expression<Func<TSource,+TKey>>和/或IComparer<TKey>。您还可以查看它们，看看它们是否为您提供了任何有用的东西。|794779|entityMap^0|J|6|0|0|H|N|J|0|0|0|H|S|V|1Q|F|0^^$0|@$1|2|3|4|5|6|7|Q|8|@$9|R|A|S|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|T|8|@$9|U|A|V|B|C]|$9|W|A|X|B|C]]|D|@]|E|$]]|$1|H|3|I|5|J|7|Y|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|Z|8|@$9|10|A|11|B|C]|$9|12|A|13|B|C]|$9|14|A|15|B|C]]|D|@]|E|$]]|$1|O|3|-4|5|6|7|16|8|@]|D|@]|E|$]]]|P|$]]

This doesn't let you pass a <code>string</code>, as you asked for in your question, but it might still work for you.

The <code>OrderByDescending</code> method takes a <code>Func&lt;TSource, TKey&gt;</code>, so you can rewrite your function this way:

<pre><code>List&lt;Student&gt; QueryStudents&lt;TKey&gt;(Func&lt;Student, TKey&gt; orderBy)
{
 return existingStudents.OrderByDescending(orderBy).ToList();
}
</code></pre>

There are other overloads for <code>OrderByDescending</code> as well that take a <code>Expression&lt;Func&lt;TSource, TKey&gt;&gt;</code>, and/or a <code>IComparer&lt;TKey&gt;</code>. You could also look into those and see if they provide you anything of use.

blocks|key|578908|text|您可以使用一点反射来构建表达式树，如下所示(这是一个扩展方法)：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|578909|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);
}|code-block|syntax|javascript|578910|orderByProperty是要作为排序依据的属性名称，如果将true作为desc的参数传递，则将按降序排序；否则，将按升序排序。|offset|length|style|CODE|578911|现在，您应该能够执行existingStudents.OrderBy("City",true);或existingStudents.OrderBy("City",false);了|578912|entityMap^0|0|0|0|F|12|4|0|A|12|1D|13|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|S|8|@$I|T|J|U|K|L]|$I|V|J|W|K|L]]|9|@]|A|$]]|$1|M|3|N|5|6|7|X|8|@$I|Y|J|Z|K|L]|$I|10|J|11|K|L]]|9|@]|A|$]]|$1|O|3|-4|5|6|7|12|8|@]|9|@]|A|$]]]|P|$]]

You can use a little bit of reflection to construct the expression tree as follows (this is an extension method):

<pre><code>public static IQueryable&lt;TEntity&gt; OrderBy&lt;TEntity&gt;(this IQueryable&lt;TEntity&gt; 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&lt;TEntity&gt;(resultExpression);
}
</code></pre>

<code>orderByProperty</code> is the Property name you want to order by and if pass true as parameter for <code>desc</code>, will sort in descending order; otherwise, will sort in ascending order.

Now you should be able to do <code>existingStudents.OrderBy("City",true);</code> or <code>existingStudents.OrderBy("City",false);</code>

blocks|key|794904|text|这里有一种使用反射的可能性。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|794905|var+param+=+"Address";++++
var+propertyInfo+=+typeof(Student).GetProperty(param);++++
var+orderByAddress+=+items.OrderBy(x+=>+propertyInfo.GetValue(x,+null));|code-block|syntax|javascript|794906|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Here's a possiblity using reflection...

<pre><code>var param = "Address"; 
var propertyInfo = typeof(Student).GetProperty(param); 
var orderByAddress = items.OrderBy(x =&gt; propertyInfo.GetValue(x, null));
</code></pre>

blocks|key|578962|text|+++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);++++|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|578963|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code> private Func&lt;T, object&gt; GetOrderByExpression&lt;T&gt;(string sortColumn)
 {
 Func&lt;T, object&gt; orderByExpr = null;
 if (!String.IsNullOrEmpty(sortColumn))
 {
 Type sponsorResultType = typeof(T);

 if (sponsorResultType.GetProperties().Any(prop =&gt; prop.Name == sortColumn))
 {
 System.Reflection.PropertyInfo pinfo = sponsorResultType.GetProperty(sortColumn);
 orderByExpr = (data =&gt; pinfo.GetValue(data, null));
 }
 }
 return orderByExpr;
 }

 public List&lt;T&gt; OrderByDir&lt;T&gt;(IEnumerable&lt;T&gt; source, string dir, Func&lt;T, object&gt; OrderByColumn)
 {
 return dir.ToUpper() == "ASC" ? source.OrderBy(OrderByColumn).ToList() : source.OrderByDescending(OrderByColumn).ToList();``
 }

 // Call the code like below
 var orderByExpression= GetOrderByExpression&lt;SearchResultsType&gt;(sort);

 var data = OrderByDir&lt;SponsorSearchResults&gt;(resultRecords, SortDirectionString, orderByExpression); 
</code></pre>

blocks|key|579025|text|这是我用来处理条件降序的方法。您可以将其与其他动态生成keySelector函数的方法结合使用。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|579026|++++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);
++++}|code-block|syntax|javascript|579027|用法：|579028|//imagine+this+is+some+parameter
var+direction+=+System.ComponentModel.ListSortDirection.Ascending;
query+=+query.OrderBy(ec+=>+ec.MyColumnName,+direction);|579029|请注意，这允许您使用新参数将此.OrderBy扩展链接到任何IQueryable上。|579030|//+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);|579031|entityMap^0|R|B|0|0|0|0|F|8|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@$9|V|A|W|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|X|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|Y|8|@]|D|@]|E|$]]|$1|M|3|N|5|H|7|Z|8|@]|D|@]|E|$I|J]]|$1|O|3|P|5|6|7|10|8|@$9|11|A|12|B|C]]|D|@]|E|$]]|$1|Q|3|R|5|H|7|13|8|@]|D|@]|E|$I|J]]|$1|S|3|-4|5|6|7|14|8|@]|D|@]|E|$]]]|T|$]]

Here's something I came up with for dealing with a conditional Descending. You could combine this with other methods of generating the <code>keySelector</code> func dynamically.

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

Usage:

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

Notice this allows you to chain this <code>.OrderBy</code> extension with a new parameter onto any IQueryable.

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

blocks|key|795021|text|唯一对我有效的解决方案是neoGeneva在这里发布的https://gist.github.com/neoGeneva/1878868。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|795022|我将重新发布他的代码，因为它运行良好，我不希望它丢失在互联网上！|795023|++++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;
++++}|code-block|syntax|javascript|795024|entityMap|0|LINK|mutability|MUTABLE|url|https://gist.github.com/neoGeneva/1878868^0|R|15|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@$A|T|B|U|1|V]]|C|$]]|$1|D|3|E|5|6|7|W|8|@]|9|@]|C|$]]|$1|F|3|G|5|H|7|X|8|@]|9|@]|C|$I|J]]|$1|K|3|-4|5|6|7|Y|8|@]|9|@]|C|$]]]|L|$M|$5|N|O|P|C|$Q|R]]]]

The only solution that worked for me was posted here <a href="https://gist.github.com/neoGeneva/1878868" rel="nofollow">https://gist.github.com/neoGeneva/1878868</a> by neoGeneva.

I will re-post his code because it works well and I wouldn't want it to be lost in the interwebs!

<pre><code> public static IQueryable&lt;T&gt; OrderBy&lt;T&gt;(this IQueryable&lt;T&gt; 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 &gt; 0 &amp;&amp; parts[0] != "")
 {
 propertyName = parts[0];

 if (parts.Length &gt; 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&lt;,&gt;)
 .MakeGenericType(tType, prop.PropertyType);

 var lambdaBuilder = typeof(Expression)
 .GetMethods()
 .First(x =&gt; x.Name == "Lambda" &amp;&amp; x.ContainsGenericParameters &amp;&amp; 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 =&gt; x.Name == (isDescending ? "OrderByDescending" : "OrderBy") &amp;&amp; x.GetParameters().Length == 2)
 .MakeGenericMethod(new[] { tType, prop.PropertyType });

 return (IQueryable&lt;T&gt;)sorter
 .Invoke(null, new object[] { source, sortLambda });
 }

 return source;
 }
</code></pre>

blocks|key|795188|text|在answer+by+@Icarus上展开:如果您希望扩展方法的返回类型是IOrderedQueryable而不是IQueryable，您可以简单地将结果转换为以下内容：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|795189|public+static+IOrderedQueryable<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+(IOrderedQueryable<TEntity>)source.Provider.CreateQuery<TEntity>(resultExpression);
}|code-block|syntax|javascript|795190|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/a/7265354/1677912^0|1|H|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@$A|R|B|S|1|T]]|C|$]]|$1|D|3|E|5|F|7|U|8|@]|9|@]|C|$G|H]]|$1|I|3|-4|5|6|7|V|8|@]|9|@]|C|$]]]|J|$K|$5|L|M|N|C|$O|P]]]]

To expand on the <a href="https://stackoverflow.com/a/7265354/1677912">answer by @Icarus</a>: if you want the return type of the extension method to be an IOrderedQueryable instead of an IQueryable, you can simply cast the result as follows: 

<pre><code>public static IOrderedQueryable&lt;TEntity&gt; OrderBy&lt;TEntity&gt;(this IQueryable&lt;TEntity&gt; 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 (IOrderedQueryable&lt;TEntity&gt;)source.Provider.CreateQuery&lt;TEntity&gt;(resultExpression);
}
</code></pre>

blocks|key|795266|text|为了扩展@Icarus的响应:如果您想按两个字段排序，我可以执行以下函数(对于一个字段，Icarius的响应工作得很好)。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|795267|public+static+IQueryable<T>+OrderByDynamic<T>(this+IQueryable<T>+q,+string+SortField1,+string+SortField2,+bool+Ascending)
++++++++{
++++++++++++var+param+=+Expression.Parameter(typeof(T),+"p");
++++++++++++var+body+=+GetBodyExp(SortField1,+SortField2,+param);
++++++++++++var+exp+=+Expression.Lambda(body,+param);

++++++++++++string+method+=+Ascending+?+"OrderBy"+:+"OrderByDescending";
++++++++++++Type[]+types+=+new+Type[]+{+q.ElementType,+exp.Body.Type+};
++++++++++++var+mce+=+Expression.Call(typeof(Queryable),+method,+types,+q.Expression,+exp);
++++++++++++return+q.Provider.CreateQuery<T>(mce);
++++++++}|code-block|syntax|javascript|795268|这是body为lambda表达式返回的函数，它适用于string和int，但根据每个程序员的需要添加更多类型就足够了|795269|public+static+NewExpression+GetBodyExp(string+field1,+string+field2,+ParameterExpression+Parametro)
++++++++{++++
++++++++++++//+SE+OBTIENE+LOS+NOMBRES+DE+LOS+TIPOS+DE+VARIABLE+
++++++++++++string+TypeName1+=+Expression.Property(Parametro,+field1).Type.Name;
++++++++++++string+TypeName2+=+Expression.Property(Parametro,+field2).Type.Name;

++++++++++++//+SE+DECLARA+EL+TIPO+ANONIMO+SEGUN+LOS+TIPOS+DE+VARIABLES
++++++++++++Type+TypeAnonymous+=+null;
++++++++++++if+(TypeName1+==+"String")
++++++++++++{
++++++++++++++++string+var1+=+"0";
++++++++++++++++if+(TypeName2+==+"Int32")
++++++++++++++++{
++++++++++++++++++++int+var2+=+0;
++++++++++++++++++++var+example+=+new+{+var1,+var2+};
++++++++++++++++++++TypeAnonymous+=+example.GetType();
++++++++++++++++}

++++++++++++++++if+(TypeName2+==+"String")
++++++++++++++++{
++++++++++++++++++++string+var2+=+"0";
++++++++++++++++++++var+example+=+new+{+var1,+var2+};
++++++++++++++++++++TypeAnonymous+=+example.GetType();
++++++++++++++++}++++
++++++++++++}++++

++++++++++++if+(TypeName1+==+"Int32")
++++++++++++{
++++++++++++++++int+var1+=+0;
++++++++++++++++if+(TypeName2+==+"Int32")
++++++++++++++++{
++++++++++++++++++++string+var2+=+"0";
++++++++++++++++++++var+example+=+new+{+var1,+var2+};
++++++++++++++++++++TypeAnonymous+=+example.GetType();
++++++++++++++++}

++++++++++++++++if+(TypeName2+==+"String")
++++++++++++++++{
++++++++++++++++++++string+var2+=+"0";
++++++++++++++++++++var+example+=+new+{+var1,+var2+};
++++++++++++++++++++TypeAnonymous+=+example.GetType();
++++++++++++++++}++++
++++++++++++}

++++++++++++//se+declaran+los+TIPOS+NECESARIOS+PARA+GENERAR+EL+BODY+DE+LA+EXPRESION+LAMBDA
++++++++++++MemberExpression[]+args+=+new[]+{+Expression.PropertyOrField(Parametro,+field1),+Expression.PropertyOrField(Parametro,+field2)+};
++++++++++++ConstructorInfo+CInfo+=+TypeAnonymous.GetConstructors()[0];
++++++++++++IEnumerable<MemberInfo>+a+=+TypeAnonymous.GetMembers().Where(m+=>+m.MemberType+==+MemberTypes.Property);

++++++++++++//BODY+
++++++++++++NewExpression+body+=+Expression.New(CInfo,+args,+TypeAnonymous.GetMembers().Where(m+=>+m.MemberType+==+MemberTypes.Property));

++++++++++++return+body;
++++++++}|795270|要使用它，请执行以下操作|795271|IQueryable<MyClass>+IqMyClass=+context.MyClass.AsQueryable();
List<MyClass>+ListMyClass=+IqMyClass.OrderByDynamic("UserName",+"IdMyClass",+true).ToList();|795272|如果有更好的方法来做这件事，那就更好了。|795273|多亏了How+can+I+make+a+Multiple+property+lambda+expression+with+Linq，我才设法解决了这个问题。|offset|length|795274|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/45555536/how-can-i-make-a-multiple-property-lambda-expression-with-linq^0|0|0|0|0|0|0|0|3|1Q|0|0^^$0|@$1|2|3|4|5|6|7|12|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|13|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|14|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|15|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|16|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|17|8|@]|9|@]|A|$E|F]]|$1|O|3|P|5|6|7|18|8|@]|9|@]|A|$]]|$1|Q|3|R|5|6|7|19|8|@]|9|@$S|1A|T|1B|1|1C]]|A|$]]|$1|U|3|-4|5|6|7|1D|8|@]|9|@]|A|$]]]|V|$W|$5|X|Y|Z|A|$10|11]]]]

To extend the response of @Icarus: if you want to sort by two fields I could perform the following function (for one field the response of Icarius works very well).

<pre><code>public static IQueryable&lt;T&gt; OrderByDynamic&lt;T&gt;(this IQueryable&lt;T&gt; q, string SortField1, string SortField2, bool Ascending)
 {
 var param = Expression.Parameter(typeof(T), "p");
 var body = GetBodyExp(SortField1, SortField2, param);
 var exp = Expression.Lambda(body, param);

 string method = Ascending ? "OrderBy" : "OrderByDescending";
 Type[] types = new Type[] { q.ElementType, exp.Body.Type };
 var mce = Expression.Call(typeof(Queryable), method, types, q.Expression, exp);
 return q.Provider.CreateQuery&lt;T&gt;(mce);
 }
</code></pre>

This is the function that the body returns for the lambda expression, it works with string and int, but it is enough to add more types to make it work according to the need of each programmer

<pre><code>public static NewExpression GetBodyExp(string field1, string field2, ParameterExpression Parametro)
 { 
 // SE OBTIENE LOS NOMBRES DE LOS TIPOS DE VARIABLE 
 string TypeName1 = Expression.Property(Parametro, field1).Type.Name;
 string TypeName2 = Expression.Property(Parametro, field2).Type.Name;

 // SE DECLARA EL TIPO ANONIMO SEGUN LOS TIPOS DE VARIABLES
 Type TypeAnonymous = null;
 if (TypeName1 == "String")
 {
 string var1 = "0";
 if (TypeName2 == "Int32")
 {
 int var2 = 0;
 var example = new { var1, var2 };
 TypeAnonymous = example.GetType();
 }

 if (TypeName2 == "String")
 {
 string var2 = "0";
 var example = new { var1, var2 };
 TypeAnonymous = example.GetType();
 } 
 } 

 if (TypeName1 == "Int32")
 {
 int var1 = 0;
 if (TypeName2 == "Int32")
 {
 string var2 = "0";
 var example = new { var1, var2 };
 TypeAnonymous = example.GetType();
 }

 if (TypeName2 == "String")
 {
 string var2 = "0";
 var example = new { var1, var2 };
 TypeAnonymous = example.GetType();
 } 
 }

 //se declaran los TIPOS NECESARIOS PARA GENERAR EL BODY DE LA EXPRESION LAMBDA
 MemberExpression[] args = new[] { Expression.PropertyOrField(Parametro, field1), Expression.PropertyOrField(Parametro, field2) };
 ConstructorInfo CInfo = TypeAnonymous.GetConstructors()[0];
 IEnumerable&lt;MemberInfo&gt; a = TypeAnonymous.GetMembers().Where(m =&gt; m.MemberType == MemberTypes.Property);

 //BODY 
 NewExpression body = Expression.New(CInfo, args, TypeAnonymous.GetMembers().Where(m =&gt; m.MemberType == MemberTypes.Property));

 return body;
 }
</code></pre>

to use it the following is done

<pre><code>IQueryable&lt;MyClass&gt; IqMyClass= context.MyClass.AsQueryable();
List&lt;MyClass&gt; ListMyClass= IqMyClass.OrderByDynamic("UserName", "IdMyClass", true).ToList();
</code></pre>

if there is a better way to do this, it would be great if they share it

I managed to solve it thanks to: <a href="https://stackoverflow.com/questions/45555536/how-can-i-make-a-multiple-property-lambda-expression-with-linq">How can I make a Multiple property lambda expression with Linq</a>

How do I specify the argument passed to <code>orderby</code> using a value I take as a parameter?

Ex:

<pre><code>List&lt;Student&gt; existingStudends = new List&lt;Student&gt;{ new Student {...}, new Student {...}}
</code></pre>

Currently implementation:

<pre><code>List&lt;Student&gt; orderbyAddress = existingStudends.OrderBy(c =&gt; c.Address).ToList();
</code></pre>

Instead of <code>c.Address</code>, how can I take that as a parameter?

Example 

<pre><code> string param = "City";
 List&lt;Student&gt; orderbyAddress = existingStudends.OrderByDescending(c =&gt; param).ToList();
</code></pre>

How do I specify the Linq OrderBy argument dynamically?

如何使用作为参数的值指定传递给orderby的参数？例如：List<Student> existingStudends = new List<Student>{ new Student {...}, new Student {...}}目前正在实施：List<Student> orderbyAddress = exis...

问如何动态指定Linq OrderBy参数？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何动态指定Linq OrderBy参数？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何动态指定Linq OrderBy参数？
EN