C# 如何对列表进行排序<；T>；其中T是我自己的类，我想按类进行排序

所以我有一节课

Class MyClass{
    string myString;

    MyClass(string newString){
    myString = newString;
    }
}

我有一份清单

List<MyClass> myList = new List<MyClass>();
myList.Add(new MyClass(some string...);

List myList=new List（）；
添加（新的MyClass（一些字符串…）；

我可以使用List.Sort根据类的字段值对对象进行排序吗？ 如果是这样，怎么办

---

谢谢您可以使用

可枚举。OrderBy

：

myList = myList.OrderBy(x => x.myString).ToList();

不过，请注意，这会在旧列表的基础上创建一个新列表。在许多情况下，这不会有什么不同，但需要注意

---

或者，由于您仅限于.NET 2.0，因此可以定义自定义函数进行比较

class MyClass
{
    string myString;

    ...

    public static int CompareByMyString(MyClass x, MyClass y)
    {
        return String.Compare(x.myString, y.myString);
    }
}

并提供给：

---

您可以使用可枚举的

myList = myList.OrderBy(x => x.myString).ToList();

不过，请注意，这会在旧列表的基础上创建一个新列表。在许多情况下，这不会有什么不同，但需要注意

---

或者，由于您仅限于.NET 2.0，因此可以定义自定义函数进行比较

class MyClass
{
    string myString;

    ...

    public static int CompareByMyString(MyClass x, MyClass y)
    {
        return String.Compare(x.myString, y.myString);
    }
}

并提供给：

---

您可以从IComparable继承。例如：

public class MyClass : IComparable
    {
        public int Day { get; set; }
        public int Hour { get; set; }

        public int CompareTo(object obj)
        {
            if (obj is MyClass)
            {
                MyClass slot = (MyClass)obj;

                if (Day < slot.Day)
                {
                    return -1;
                }
                else if (Day > slot.Day)
                {
                    return 1;
                }
                else
                {
                    if (Hour < slot.Hour)
                    {
                        return -1;
                    }
                    else if (Hour > slot.Hour)
                    {
                        return 1;
                    }
                    else
                    {
                        return 0;
                    }
                }
            }
            else
            {
                throw new ArgumentException("Object is not MyClass");
            }
        }

        public override int GetHashCode()
        {
            unchecked
            {
                return Day.GetHashCode() ^ Hour.GetHashCode();
            }
        }

        public override bool Equals(object obj)
        {
            if (obj is MyClass)
            {
                return this == (MyClass)obj;
            }
            else
            {
                throw new ArgumentException("Object is not MyClass");
            }
        }

        public static bool operator ==(MyClass a, MyClass b)
        {
            return a.CompareTo(b) == 0;
        }

        public static bool operator !=(MyClass a, MyClass b)
        {
            return a.CompareTo(b) != 0;
        }

        public static bool operator <(MyClass a, MyClass b)
        {
            return a.CompareTo(b) < 0;
        }

        public static bool operator >(MyClass a, MyClass b)
        {
            return a.CompareTo(b) > 0;
        }

        public static bool operator <=(MyClass a, MyClass b)
        {
            return a.CompareTo(b) <= 0;
        }

        public static bool operator >=(MyClass a, MyClass b)
        {
            return a.CompareTo(b) >= 0;
        }
    }

公共类MyClass:IComparable
{
公共整数日{get；set；}
公共整数小时{get；set；}
公共整数比较（对象对象对象）
{
如果（obj是MyClass）
{
MyClass插槽=（MyClass）obj；
如果（日<时段日）
{
返回-1；
}
else if（天>槽日）
{
返回1；
}
其他的
{
如果（小时<时段小时）
{
返回-1；
}
否则如果（小时>时段小时）
{
返回1；
}
其他的
{
返回0；
}
}
}
其他的
{
抛出新ArgumentException（“对象不是MyClass”）；
}
}
公共覆盖int GetHashCode（）
{
未经检查
{
返回日期。GetHashCode（）^Hour.GetHashCode（）；
}
}
公共覆盖布尔等于（对象对象对象）
{
如果（obj是MyClass）
{
返回this==（MyClass）obj；
}
其他的
{
抛出新ArgumentException（“对象不是MyClass”）；
}
}
公共静态布尔运算符==（MyClass a，MyClass b）
{
返回a.CompareTo（b）==0；
}
公共静态布尔运算符！=（MyClass a，MyClass b）
{
返回a.CompareTo（b）！=0；
}
公共静态布尔运算符（MyClass a、MyClass b）
{
返回a.CompareTo（b）>0；
}
公共静态布尔运算符=0；
}
}

然后你可以这样做：

List<MyClass> listOfStuff = new List<MyClass>();}
// Add some stuff to the list E.G. 
listOfStuff.add(new MyClass());
// Sort the list
listOfStuff.sort();

List listofsuff=new List（）；}
//在列表中添加一些内容。
添加（新的MyClass（））；
//对列表排序
listofsuff.sort（）；

您可以从IComparable继承。例如：

public class MyClass : IComparable
    {
        public int Day { get; set; }
        public int Hour { get; set; }

        public int CompareTo(object obj)
        {
            if (obj is MyClass)
            {
                MyClass slot = (MyClass)obj;

                if (Day < slot.Day)
                {
                    return -1;
                }
                else if (Day > slot.Day)
                {
                    return 1;
                }
                else
                {
                    if (Hour < slot.Hour)
                    {
                        return -1;
                    }
                    else if (Hour > slot.Hour)
                    {
                        return 1;
                    }
                    else
                    {
                        return 0;
                    }
                }
            }
            else
            {
                throw new ArgumentException("Object is not MyClass");
            }
        }

        public override int GetHashCode()
        {
            unchecked
            {
                return Day.GetHashCode() ^ Hour.GetHashCode();
            }
        }

        public override bool Equals(object obj)
        {
            if (obj is MyClass)
            {
                return this == (MyClass)obj;
            }
            else
            {
                throw new ArgumentException("Object is not MyClass");
            }
        }

        public static bool operator ==(MyClass a, MyClass b)
        {
            return a.CompareTo(b) == 0;
        }

        public static bool operator !=(MyClass a, MyClass b)
        {
            return a.CompareTo(b) != 0;
        }

        public static bool operator <(MyClass a, MyClass b)
        {
            return a.CompareTo(b) < 0;
        }

        public static bool operator >(MyClass a, MyClass b)
        {
            return a.CompareTo(b) > 0;
        }

        public static bool operator <=(MyClass a, MyClass b)
        {
            return a.CompareTo(b) <= 0;
        }

        public static bool operator >=(MyClass a, MyClass b)
        {
            return a.CompareTo(b) >= 0;
        }
    }

公共类MyClass:IComparable
{
公共整数日{get；set；}
公共整数小时{get；set；}
公共整数比较（对象对象对象）
{
如果（obj是MyClass）
{
MyClass插槽=（MyClass）obj；
如果（日<时段日）
{
返回-1；
}
else if（天>槽日）
{
返回1；
}
其他的
{
如果（小时<时段小时）
{
返回-1；
}
否则如果（小时>时段小时）
{
返回1；
}
其他的
{
返回0；
}
}
}
其他的
{
抛出新ArgumentException（“对象不是MyClass”）；
}
}
公共覆盖int GetHashCode（）
{
未经检查
{
返回日期。GetHashCode（）^Hour.GetHashCode（）；
}
}
公共覆盖布尔等于（对象对象对象）
{
如果（obj是MyClass）
{
返回this==（MyClass）obj；
}
其他的
{
抛出新ArgumentException（“对象不是MyClass”）；
}
}
公共静态布尔运算符==（MyClass a，MyClass b）
{
返回a.CompareTo（b）==0；
}
公共静态布尔运算符！=（MyClass a，MyClass b）
{
返回a.CompareTo（b）！=0；
}
公共静态bool运算符（MyClass a，MyClass b）
{
返回a.CompareTo（b）>0；
}
公共静态布尔运算符=0；
}
}

然后你可以这样做：

List<MyClass> listOfStuff = new List<MyClass>();}
// Add some stuff to the list E.G. 
listOfStuff.add(new MyClass());
// Sort the list
listOfStuff.sort();

List listofsuff=new List（）；}
//在列表中添加一些内容。
添加（新的MyClass（））；
//对列表排序
listofsuff.sort（）；

忘了提到im仅限于.net 2.0，因为我在mono for unity中工作，而那似乎是.net 3.5earliest@user1711383：我已经使用List.Sort添加了一个替代选项，它应该也适用于.net 2.0。忘记提及im仅限于.net 2.0，因为我使用mono for unity，而这似乎是.net 3.5earliest@user1711383：I've添加了一个使用List.Sort的替代方法，该方法也应适用于.NET2.0。