C# Linq和order by

我有一个泛型类，它可以使用泛型OrderBy参数

课程安排如下

 class abc<T> where T : myType
 {
   public abc(....., orderBy_Argument ){ ... }
   void someMethod(arg1, arg2, bool afterSort = false)
   {
       IEnumerable<myType> res ;
       if ( afterSort && orderBy_Argument != null )
          res = src.Except(tgt).OrderBy( .... );
       else
          res = src.Except(tgt);
   }
}

我们的目标是通过一个参数来创建order，而不是将其嵌入

---

有什么想法吗？

只需作为代理传递排序键：

 class abc<T, TSort> where T : myType
 {
   public abc(....., Func<T, TSort> sortKeySelector ){ ... }
   void someMethod(arg1, arg2, bool afterSort = false)
   {
       IEnumerable<myType> res ;
       if ( afterSort && sortKeySelector != null )
          res = src.Except(tgt).OrderBy(sortKeySelector);
       else
          res = src.Except(tgt);
   }
}

abc类，其中T:myType
{
公共abc（…，Func sortKeySelector）{…}
void someMethod（arg1、arg2、bool afterSort=false）
{
可数名词；
if（afterSort&&sortKeySelector！=null）
res=src.Except（tgt）.OrderBy（sortKeySelector）；
其他的
res=src.除外（tgt）；
}
}

缺点是它需要一个额外的类型参数…

不要在转换

IEnumerable

（或

IQueryable

）的函数中将参数传递给

OrderBy

修改示例以执行此操作将导致以下程序：

using System;
using System.Collections.Generic;
using System.Linq;

class abc<T>  {
    Func<IEnumerable<T>,IEnumerable<T>> sorter;
    public abc(Func<IEnumerable<T>,IEnumerable<T>> sorter) {
        this.sorter=sorter ?? (x=>x);
    }
    public void someMethod(IEnumerable<T> src, bool afterSort = false) {
        var res= (afterSort?sorter:x=>x) (src.Skip(5).Take(10));

        Console.WriteLine(string.Join(", ",res.Select(el=>el.ToString()).ToArray()));
    }
}

public class Program {
    static void Main()    {
        var strs = Enumerable.Range(0,1000).Select(i=>i.ToString());

        var myAbc = new abc<string>(
            xs=>xs.OrderByDescending(x=>x.Length).ThenByDescending(x=>x.Substring(1))
        );

        myAbc.someMethod(strs);      //5, 6, 7, 8, 9, 10, 11, 12, 13, 14
        myAbc.someMethod(strs,true); //14, 13, 12, 11, 10, 5, 6, 7, 8, 9
    }
}

使用系统；
使用System.Collections.Generic；
使用System.Linq；
abc班{
Func分拣机；
公共abc（功能分拣机）{
这个。分拣机=分拣机？？（x=>x）；
}
公共方法（IEnumerable src，bool afterSort=false）{
var res=（后分拣机：x=>x）（src.Skip（5.Take（10））；
Console.WriteLine（string.Join（“，”，res.Select（el=>el.ToString（））.ToArray（））；
}
}
公共课程{
静态void Main（）{
var strs=Enumerable.Range（01000）.Select（i=>i.ToString（））；
var myAbc=新abc(
xs=>xs.OrderByDescending（x=>x.Length）。然后是ByDescending（x=>x.Substring（1））
);
myAbc.someMethod（strs）；//5,6,7,8,9,10,11,12,13,14
myAbc.someMethod（strs，true）；//14、13、12、11、10、5、6、7、8、9
}
}

---

当然，这是一个非常奇怪的排序，也是一个毫无意义的

someMethod

——但它表明，只需很短的实现，您就可以传递一个非常灵活的排序委托（实际上，该委托可以做的不仅仅是排序）。

可能您可以使用这个著名问题中的某些内容：。马克·格雷威尔有一个很好的答案，他投了很多赞成票。

using System;
using System.Collections.Generic;
using System.Linq;

class abc<T>  {
    Func<IEnumerable<T>,IEnumerable<T>> sorter;
    public abc(Func<IEnumerable<T>,IEnumerable<T>> sorter) {
        this.sorter=sorter ?? (x=>x);
    }
    public void someMethod(IEnumerable<T> src, bool afterSort = false) {
        var res= (afterSort?sorter:x=>x) (src.Skip(5).Take(10));

        Console.WriteLine(string.Join(", ",res.Select(el=>el.ToString()).ToArray()));
    }
}

public class Program {
    static void Main()    {
        var strs = Enumerable.Range(0,1000).Select(i=>i.ToString());

        var myAbc = new abc<string>(
            xs=>xs.OrderByDescending(x=>x.Length).ThenByDescending(x=>x.Substring(1))
        );

        myAbc.someMethod(strs);      //5, 6, 7, 8, 9, 10, 11, 12, 13, 14
        myAbc.someMethod(strs,true); //14, 13, 12, 11, 10, 5, 6, 7, 8, 9
    }
}