C# 列表.排序（自定义排序…）

我有一个列表对象，包括3项：部分、完整到H和完整到O

我将此列表绑定到asp OptionButtonList，并按字母顺序排序。但是，我想对列表进行如下排序：

满到H，部分，满到O

---

我如何才能做到这一点？

Linq非常适合这一点。您甚至可以构建订单序列来动态定义它，因为排序的执行直到

ToList

才执行

 var sortedList = yourList.OrderBy(i => i.FullToH).
     ThenBy(i => i.Partial).
     ThenBy(i => i.FullToO).ToList();

---

为自定义类型（实现IComparer接口）创建比较器。然后，您可以使用它对列表进行排序：

List<CustomType> list = new List<CustomType>();

// Fill list
list.Sort(new CustomComparer());

List List=新列表（）；
//填写清单
排序（new CustomComparer（））；

---

或者，如果您正在使用较新版本的框架，并且不需要重复使用排序逻辑，则可以使用

IEnumerable.OrderBy（）

方法。

为您的对象实现IComparer

您列出的项目（例如FullToHo）是否只是字符串？如果是这样，那么您所需要做的就是编写一个方法来使用该方法进行比较和排序

public int CompareEntries(string left, string right) {
  const string fullToH = "Full To H";
  const string partial = "Partial";
  const string fullToO = "Full To O";
  if ( left == right ) {
    return 0;
  } else if ( left == fullToH ) {
    return -1;
  } else if ( left == fullToO ) {
    return 1;
  } else if ( right == fullToH ) {
    return 1;
  } else {
    return -1; 
  }
}

list.Sort(CompareEntries);

---

假设您的列表不是

 List<object> myList = new List<object>();

---

谢谢大家的帮助

我是这样做的：

List<string> sortedList = new List<string>();
sortedList = list.OrderBy(i => i.CodeValue == "FullToH").ThenBy(i => i.CodeValue == "Partial").ThenBy(i => i.CodeValue == "FullToO").ToList();

List sortedList=new List（）；
sortedList=list.OrderBy（i=>i.CodeValue==“FullToH”）.ThenBy（i=>i.CodeValue==“Partial”）.ThenBy（i=>i.CodeValue==“FullToO”）.ToList（）；

---

然后绑定到分类列表

好的，我知道这已经有几年历史了，但我有一个替代解决方案，我认为比上述解决方案更优雅，未来的读者可能会考虑：

在你们班：

static readonly List<String> codeValueSortOrder = new List<String> {
    "Full To H", 
    "Partial",
    "Full To O"
};

---

假设您有字符串项，并且希望通过其他列表优先级对其进行优先级排序。 这里是我的例子，我有一个优先级列表，这些优先级将在按优先级排序的列表中排在第一位

结果

kitty , some item , kk abb , ccc , kk abc, some flash

类程序
{
静态void Main（字符串[]参数）
{
控制台。WriteLine（“你好，世界！”）；
var输入=新列表（）
{
“一些物品”，
“一些闪光”，
“基蒂”，
“ccc”，
“kk abc”，
“kk abb”
};
var sorted=input.OrderBy（x=>x，new Comparer（））.ToList（）；
Console.ReadKey（）；
}
}
公共类比较器：IComparer
{
私有列表优先级=新列表（）
{
新的KeyValuePair（“某些项”，2），
新的KeyValuePair（“kitty”，1），
新的KeyValuePair（“kk abb”，3），
};
公共整数比较（字符串x、字符串y）
{
var anyX=优先级.Any（z=>z.Key==x）；
var anyY=优先级.Any（z=>z.Key==y）；
if（anyX | | anyY）
{
var firstX=priorities.FirstOrDefault（z=>z.Key==x）；
var firstY=priorities.FirstOrDefault（z=>z.Key==y）；
if（anyX&&anyY）
{
if（firstX.Value>firstY.Value）
{
返回firstX.Value；
}
返回-firstX.Value；
}
if（anyX）
{
返回-firstX.Value；
}
如果（任何）
{
首先返回值；
}
}
返回string.Compare（x，y，StringComparison.Ordinal）；
}
}

什么是“满到H，部分到O”？请添加一些到目前为止您所掌握的代码。如果您发现答案最有用，请记住接受答案。注意：对于真正的代码，请使用

字典
而不是
codeValueSortOrder
列表进行O（1）搜索，并使用
Dictionary[value]
而不是O（n^2 log n）对于
List.IndexOf
，第一行中的分配是不必要的。这是更好的：List sortedList=List.OrderBy…..对于我们这些不想将比较压缩成一行的人来说，这是最干净、最通用的解决方案。Linq有很大的缺点：它无法在不产生内存开销的情况下对列表进行排序。
static readonly List<String> codeValueSortOrder = new List<String> {
    "Full To H", 
    "Partial",
    "Full To O"
};

sortedList = list.OrderBy(i=> codeValueSortOrder.IndexOf(i.CodeValue));

kitty , some item , kk abb , ccc , kk abc, some flash

class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Hello World!");
            var input = new List<string>()
            {
                "some item",
                "some flash",
                "kitty",
                "ccc",
                "kk abc",
                "kk abb"

            };

            var sorted = input.OrderBy(x => x, new Comparer()).ToList();

            Console.ReadKey();
        }
    }

    public class Comparer : IComparer<string>
    {
        private List<KeyValuePair<string, int>> priorities = new List<KeyValuePair<string, int>>()
        {
            new KeyValuePair<string, int>("some item", 2),
            new KeyValuePair<string, int>("kitty", 1),
            new KeyValuePair<string, int>("kk abb", 3),
        };
        public int Compare(string x, string y)
        {
            var anyX = priorities.Any(z => z.Key == x);
            var anyY = priorities.Any(z => z.Key == y);
            if (anyX || anyY)
            {
                var firstX = priorities.FirstOrDefault(z => z.Key == x);
                var firstY = priorities.FirstOrDefault(z => z.Key == y);
                if (anyX && anyY)
                {
                    if (firstX.Value > firstY.Value)
                    {
                        return firstX.Value;
                    }

                    return -firstX.Value;
                }

                if (anyX)
                {
                    return -firstX.Value;
                }

                if (anyY)
                {
                    return firstY.Value;
                }

            }


            return string.Compare(x, y, StringComparison.Ordinal);
        }
    }