C# LINQ按代表排序

我有一个对象集合，这些对象按对象的字段值排序。当前的问题是订单取决于业务逻辑

public enum Order : byte {
    a = 1,
    b = 2,
    c = 3
}

public class Foo{
    public long A {get;set;}
    public long B {get;set;}
    public long C {get;set;}
}

public class Worker(){
    private Foo[] orderFoos(Foo[] foos, Func<Order, long> sort){
        return foos.OrderByDescending(f => sort(f)).ToArray(foos.Length);
    }

    public void Work(){
        Foo[] foos = getFoos();

        var orderByA = orderFoos(foos, f => f.A);
        var orderByB = orderFoos(foos, f => f.B);
        var orderByC = orderFoos(foos, f => f.C);
    }
}

公共枚举顺序：字节{
a=1，
b=2，
c=3
}
公开课Foo{
公共long A{get；set；}
公共长B{get；set；}
公共长C{get；set；}
}
公营工人（）{
私有Foo[]orderFoos（Foo[]foos，Func排序）{
返回foos.OrderByDescending（f=>sort（f））.ToArray（foos.Length）；
}
公共工程（）{
Foo[]foos=getFoos（）；
var orderByA=orderFoos（foos，f=>f.A）；
var orderByB=orderFoos（foos，f=>f.B）；
var orderByC=orderFoos（foos，f=>f.C）；
}
}

---

编译器抛出一个错误，

参数1:无法从“Foo”转换为“Order”

。有什么变通方法或解决方案吗？

似乎您想要实现的是对不同字段进行排序。如果仅用于此目的，您可能不需要订单枚举，并替换：

private Foo[] orderFoos(Foo[] foos, Func<Order, long> sort){
    return foos.OrderByDescending(f => sort(f)).ToArray(foos.Length);
}

private Foo[]orderFoos（Foo[]foos，Func-sort）{
返回foos.OrderByDescending（f=>sort（f））.ToArray（foos.Length）；
}

进入

private Foo[]orderFoos（Foo[]foos，Func-sort）{
返回foos.OrderByDescending（sort.ToArray）（foos.Length）；
}

---

注意：我不确定您是否打算在ToArray方法中添加foos.Length，但我认为这超出了问题的范围。

@hsoesanto给出了一个很好的解决方案，但它没有按照我预期的方式工作。
所以我创建了临时解决方案

private  Func<Foo, long> GetOrderFunction(Order orderType)
{
    switch (orderType)
    {
        case Order.A:
            return (f) => f.A;
        case Order.B:
            return (f) => f.B;
        case Order.C:
            return (f) => f.C;
     }
}

private Foo[] orderFoos(Foo[] foos, Order order)
{
    var orderFunction = GetOrderFunction(order);
    return foos
        .OrderByDescending(f => orderFunction (f))
        .ToArray(foos.Length);
}

private Func GetOrderFunction（订单类型）
{
开关（订单类型）
{
案件顺序A：
返回值（f）=>f.A；
案件顺序B：
返回值（f）=>f.B；
案件顺序C：
返回值（f）=>f.C；
}
}
私有Foo[]订单foos（Foo[]foos，订单）
{
var orderFunction=GetOrderFunction（订单）；
返回foos
.OrderByDescending（f=>orderFunction（f））
.ToArray（食物长度）；
}

下面的代码似乎有效。这是对orderFoos方法的一个小改动，其中有一些示例代码供您测试结果

using System;
using System.Linq;

public enum Order : byte
{
    a = 1,
    b = 2,
    c = 3
}

public class Foo
{
    public long A { get; set; }
    public long B { get; set; }
    public long C { get; set; }
}

public class Worker
{
    private Foo[] orderFoos(Foo[] foos, Func<Foo, long> sort)
    {
        return foos.OrderByDescending(sort).ToArray();
    }

    public void Work()
    {
        Foo[] foos = { new Foo() { A = 1, B = 2, C = 3 }, new Foo() { A = 10, B = 1, C = 2 }, new Foo() { A = -1, B = 1, C = 10 } };

        var orderByA = orderFoos(foos, f => f.A);
        var orderByB = orderFoos(foos, f => f.B);
        var orderByC = orderFoos(foos, f => f.C);

        Console.WriteLine(orderByA.First().A); // I expect the second to be first here so 10
        Console.WriteLine(orderByB.First().A); // I expect the first to be first here so 1
        Console.WriteLine(orderByC.First().A); // I expect the third to be first here so -1
    }
}

class Program
{
    static void Main(string[] args)
    {
        var worker = new Worker();

        worker.Work();
        Console.ReadLine();
    }
}

使用系统；
使用System.Linq；
公共枚举顺序：字节
{
a=1，
b=2，
c=3
}
公开课Foo
{
公共long A{get；set；}
公共长B{get；set；}
公共长C{get；set；}
}
公社工人
{
私有Foo[]orderFoos（Foo[]foos，Func排序）
{
返回foos.OrderByDescending（sort.ToArray（）；
}
公共工程（）
{
Foo[]foos={newfoo（）{A=1，B=2，C=3}，newfoo（）{A=10，B=1，C=2}，newfoo（）{A=-1，B=1，C=10}；
var orderByA=orderFoos（foos，f=>f.A）；
var orderByB=orderFoos（foos，f=>f.B）；
var orderByC=orderFoos（foos，f=>f.C）；
Console.WriteLine（orderByA.First（）.A）；//我希望第二个在这里是第一个，所以10
Console.WriteLine（orderByB.First（）.A）；//我希望这里的第一个是第一个，所以1
Console.WriteLine（orderByC.First（）.A）；//我希望第三个在这里是第一个，所以-1
}
}
班级计划
{
静态void Main（字符串[]参数）
{
var-worker=新的worker（）；
工人。工作（）；
Console.ReadLine（）；
}
}

Foo.A、

Foo.B

和

Foo.C

支持什么值？@NtFreX

long

，在Foo类声明中提到了它。说明什么值，而不是什么类型。我这样问是因为我不太明白你想做什么。请删除类名旁边的括号（）。将

orderFoos

更改为

private Foo[]orderFoos（Foo[]foos，Func-sort）{返回foos.OrderByDescending（sort.ToArray（）；}

work？您的解决方案没有按预期工作，但它让我更好地理解了委托的工作方式。好吧，这就是我使用代理

顺序

参数所做的。

using System;
using System.Linq;

public enum Order : byte
{
    a = 1,
    b = 2,
    c = 3
}

public class Foo
{
    public long A { get; set; }
    public long B { get; set; }
    public long C { get; set; }
}

public class Worker
{
    private Foo[] orderFoos(Foo[] foos, Func<Foo, long> sort)
    {
        return foos.OrderByDescending(sort).ToArray();
    }

    public void Work()
    {
        Foo[] foos = { new Foo() { A = 1, B = 2, C = 3 }, new Foo() { A = 10, B = 1, C = 2 }, new Foo() { A = -1, B = 1, C = 10 } };

        var orderByA = orderFoos(foos, f => f.A);
        var orderByB = orderFoos(foos, f => f.B);
        var orderByC = orderFoos(foos, f => f.C);

        Console.WriteLine(orderByA.First().A); // I expect the second to be first here so 10
        Console.WriteLine(orderByB.First().A); // I expect the first to be first here so 1
        Console.WriteLine(orderByC.First().A); // I expect the third to be first here so -1
    }
}

class Program
{
    static void Main(string[] args)
    {
        var worker = new Worker();

        worker.Work();
        Console.ReadLine();
    }
}