Question

我有一个班级访客

class Guest
{
   bool f = true;
   bool g = false;
   bool s = false;
   string name = "";
}

列出所有包含的列表 - ＆gt; var g = new List<Guest>(); 它可能只是其中一个布尔值。

一开始，来自所有f客人，然后客人在中间，最后是客人。但是所有客人必须按字母顺序排列为f或g或一组。

也许是这样？

 var query = (from Guest in GuestList
                             orderby Guest.f, Guest.g, Guest.s, Guest.name
                             select Guest);

我不是。

谢谢和greetz，Malte

Answer 1

听起来很典型的嵌套排序。没有必要分组。

var result = source
  .OrderBy(guest =>
    guest.f ? 1 :
    guest.g ? 2 :
    guest.s ? 3 :
    4)
  .ThenBy(guest => guest.name);

对于那些不熟悉语法的人，请允许我阅读代码。

在对OrderBy的调用中，有一个lambda函数，它使用链式三元运算符为每一行生成一个排序键。 OrderBy按此排序键进行排序。
OrderBy的结果为IOrderedEnumerable<Guest>，并传递给ThenBy。
ThenBy保留先前订购操作的排序，并努力打破关系。

Answer 2

这应该有效。 Sort和OrderBy将使用CopmpareTo（）方法

    public class Guest : IComparable<Guest>
    {
        public bool f { get; set; }
        public bool g { get; set; }
        public bool s { get; set; }
        public string name { get; set; }

        public int CompareTo(Guest other)
        {
            int results = 0;

            if (this.f)
            {
                if (other.f)
                {
                    results = this.name.CompareTo(other.name);
                }
                else
                {
                    results = 1;
                }
            }
            else
            {
                if (other.f)
                {
                    results = -1;
                }
                else
                {
                    if (this.g)
                    {
                        if (other.g)
                        {
                            results = this.name.CompareTo(other.name);
                        }
                        else
                        {
                            results = 1;
                        }
                    }
                    else
                    {
                        if (other.g)
                        {
                            results = -1;
                        }
                        else
                        {
                            if (this.s)
                            {
                                if (other.s)
                                {
                                    results = this.name.CompareTo(other.name);
                                }
                                else
                                {
                                    results = 1;
                                }
                            }
                            else
                            {
                                results = this.name.CompareTo(other.name);
                            }
                        }
                    }
                }
            }
            return results;
        }

下面是一个更简单的方法，它甚至可以在多个属性为真时使用。请注意，我在其他解决方案中使用了1,2,4而不是1,2,3。 1,2,3的问题是，当多个属性为真时，有多种方法可以得到3。

   public class Guest : IComparable<Guest>
    {
        public bool f { get; set; }
        public bool g { get; set; }
        public bool s { get; set; }
        public string name { get; set; }

        public int CompareTo(Guest other)
        {
            int results = 0;
            int thisRank = (this.f ? 1 : 0) + (this.g ? 2 : 0) + (this.s ? 4 : 0);
            int otherRank = (other.f ? 1 : 0) + (other.g ? 2 : 0) + (other.s ? 4 : 0);

            if (thisRank == otherRank)
            {
                results = this.name.CompareTo(other.name);
            }
            else
            {
                results = thisRank.CompareTo(otherRank);
            }

            return results;
        }
    }

Answer 3

这是David B的示例，其中包含if语句的更常用语法。

var result = source
            .OrderBy(guest => { if (guest.f == true) return 1 else
                                if (guest.g == true) return 2 else
                                if (guest.s == true) return 3 else return 4;})
            .ThenBy(guest => guest.name);

使用Linq对列表进行排序，组按字母顺序排列

3 个答案: