C# 如何用C对字符串排序#

我有一门课

public class KeyNamePair
{
 public string Key {get;set;}

 public string Name{get;set;}
}

我的代码

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

    list.Add("1", "Day 1");
    list.Add("2", "Day 11");
    list.Add("4", "Day 5");
    list.Add("6", "Day 13");

按顺序

我试过了

var SortedList = source.OrderBy(x => x.Name).ToList();
            return SortedList;

---

这不做任何排序

它是不是碰巧这样排序的

第一天 第11天 第13天 第5天

这就是我所期望的。OrderBy上有一个重载，允许您指定如何排序。正在进行的排序是字母数字排序，因此它是正确的。如果你做了

第01天 第11天 第13天 第05天

---

您会看到它的排序是正确的。

它是这样排序的吗

第一天 第11天 第13天 第5天

这就是我所期望的。OrderBy上有一个重载，允许您指定如何排序。正在进行的排序是字母数字排序，因此它是正确的。如果你做了

第01天 第11天 第13天 第05天

您将看到它的排序正确。

请尝试以下操作：

var SortedList = source.OrderBy(x=>int.Parse(x.Name.Split(' ')[1])).ToList();
return SortedList;

如果数据是其他格式，它将不起作用，但它应该使用您提供的格式。您不能按字符串本身排序，因为字符串“13”<“5”

请尝试以下操作：

var SortedList = source.OrderBy(x=>int.Parse(x.Name.Split(' ')[1])).ToList();
return SortedList;

如果数据是其他格式，它将不起作用，但它应该使用您提供的格式。您不能按字符串本身排序，因为字符串“13”<“5”

应该可以：

list = list.OrderBy(kn => {
    var digits = kn.Name.Split().Last();
    int num = int.MaxValue;
    if (digits.All(Char.IsDigit))
    { 
        num = int.Parse(new string(digits.ToArray()));
    }
    return num;
}).ToList();

旁注：您也可以使用已有的

KeyValuePair

这应该可以：

list = list.OrderBy(kn => {
    var digits = kn.Name.Split().Last();
    int num = int.MaxValue;
    if (digits.All(Char.IsDigit))
    { 
        num = int.Parse(new string(digits.ToArray()));
    }
    return num;
}).ToList();

---

旁注：您也可以使用已有的

KeyValuePair

我认为这不是一个好方法，但这很有效

list.OrderBy(x =>
     {
         return Int32.Parse(x.Name.Split(' ')[1]);
     });

---

我认为这不是一个好办法，但这是一项工作

list.OrderBy(x =>
     {
         return Int32.Parse(x.Name.Split(' ')[1]);
     });

---

这里有几个问题：

您正在尝试按Name属性排序，该属性将“第1天”和“第11天”计算为比“第1天”和“第2天”更接近匹配

您可能会更好地对键进行排序（另外，如果键只包含数值，我会将其设置为数字，而不是字符串）

这是我的修订版：

public class KeyNamePair
{
    public int Key { get; set; }

    public string Name { get; set; }
}

List<KeyNamePair> list = new List<KeyNamePair>
    {
        new KeyNamePair() {Key = 1, Name = "Day 1"},
        new KeyNamePair() {Key = 4, Name = "Day 11"},
        new KeyNamePair() {Key = 2, Name = "Day 5"},
        new KeyNamePair() {Key = 6, Name = "Day 13"}
    };

var sortedList = list.Select(x => x).OrderBy(x => x.Key).ToList();

公共类密钥名对
{
公共int密钥{get；set；}
公共字符串名称{get；set；}
}
列表=新列表
{
新的KeyNamePair（）{Key=1，Name=“Day 1”}，
新的KeyNamePair（）{Key=4，Name=“Day 11”}，
新的KeyNamePair（）{Key=2，Name=“Day 5”}，
新的KeyNamePair（）{Key=6，Name=“Day 13”}
};
var sortedList=list.Select（x=>x.OrderBy（x=>x.Key.ToList（）；

---

[编辑]-我在思考这样一个事实，我觉得重构类的逻辑和它的填充比尝试执行一些可能在特定于区域性的实现中失败的任意顺序要好，因为字符串在这方面是出了名的脆弱。

您这里有几个问题：

您正在尝试按Name属性排序，该属性将“第1天”和“第11天”计算为比“第1天”和“第2天”更接近匹配

您可能会更好地对键进行排序（另外，如果键只包含数值，我会将其设置为数字，而不是字符串）

这是我的修订版：

public class KeyNamePair
{
    public int Key { get; set; }

    public string Name { get; set; }
}

List<KeyNamePair> list = new List<KeyNamePair>
    {
        new KeyNamePair() {Key = 1, Name = "Day 1"},
        new KeyNamePair() {Key = 4, Name = "Day 11"},
        new KeyNamePair() {Key = 2, Name = "Day 5"},
        new KeyNamePair() {Key = 6, Name = "Day 13"}
    };

var sortedList = list.Select(x => x).OrderBy(x => x.Key).ToList();

公共类密钥名对
{
公共int密钥{get；set；}
公共字符串名称{get；set；}
}
列表=新列表
{
新的KeyNamePair（）{Key=1，Name=“Day 1”}，
新的KeyNamePair（）{Key=4，Name=“Day 11”}，
新的KeyNamePair（）{Key=2，Name=“Day 5”}，
新的KeyNamePair（）{Key=6，Name=“Day 13”}
};
var sortedList=list.Select（x=>x.OrderBy（x=>x.Key.ToList（）；

---

[编辑]-我在思考这样一个事实，我觉得重构类的逻辑和类的填充比尝试执行一些可能在特定于文化的实现中失败的任意顺序要好，因为字符串在这方面是出了名的脆弱。

我们完全可以通过PInvoking来作弊，PInvoking在两个字符串之间进行自然排序顺序比较

然后我们就可以使用内置的List.Sort（）。根本不需要Linq参与：

using System;
using System.Collections.Generic;
using System.Runtime.InteropServices;

namespace Demo
{
    class Program
    {
        [DllImport("shlwapi.dll", CharSet = CharSet.Unicode)]
        private static extern int StrCmpLogicalW(string lhs, string rhs);

        private void run()
        {
            var list = new List<KeyValuePair<string, string>>
            {
                new KeyValuePair<string, string>("1", "Day 1"), 
                new KeyValuePair<string, string>("2", "Day 11"), 
                new KeyValuePair<string, string>("4", "Day 5"),
                new KeyValuePair<string, string>("6", "Day 13")
            };

            list.Sort((lhs, rhs) => StrCmpLogicalW(lhs.Value, rhs.Value));

            foreach (var keyValuePair in list)
                Console.WriteLine(keyValuePair);
        }

        static void Main(string[] args)
        {
            new Program().run();
        }
    }
}

---

我们完全可以通过PInvoking在两个字符串之间进行自然排序顺序比较来作弊

然后我们就可以使用内置的List.Sort（）。根本不需要Linq参与：

using System;
using System.Collections.Generic;
using System.Runtime.InteropServices;

namespace Demo
{
    class Program
    {
        [DllImport("shlwapi.dll", CharSet = CharSet.Unicode)]
        private static extern int StrCmpLogicalW(string lhs, string rhs);

        private void run()
        {
            var list = new List<KeyValuePair<string, string>>
            {
                new KeyValuePair<string, string>("1", "Day 1"), 
                new KeyValuePair<string, string>("2", "Day 11"), 
                new KeyValuePair<string, string>("4", "Day 5"),
                new KeyValuePair<string, string>("6", "Day 13")
            };

            list.Sort((lhs, rhs) => StrCmpLogicalW(lhs.Value, rhs.Value));

            foreach (var keyValuePair in list)
                Console.WriteLine(keyValuePair);
        }

        static void Main(string[] args)
        {
            new Program().run();
        }
    }
}

---

我相信你会对此感到高兴：）

公共类KeyNamePair:IComparable
{
公共字符串密钥{get；set；}
公共字符串名称{get；set；}
公钥名称对（字符串键、字符串名称）
{
这个。键=键；
this.Name=Name；
}
公共整数比较（对象对象对象）
{
var tmp=（KeyNamePair）obj；
var newKey=int.Parse（tmp.Name.Split（“”）[1]）；
var oldKey=int.Parse（Name.Split（“”）[1]）；
如果（旧键>新键）
申报表（1）；
如果（旧键<新键）
返回（-1）；
其他的
返回（0）；
}
}
列表=新列表（）；
添加（新的密钥对（“1”，“第1天”）；
添加（新的密钥对（“2”，“第11天”）；
添加（新的密钥对（“4”，“第5天”）；
添加（新的密钥对（“6”，“第13天”）；
list.Sort（）；
foreach（列表中的var keyNamePair）
{
System.Console.Write（keyNamePair）；
}

我相信您会满意的：）

公共类KeyNamePair:IComparable
{
公共字符串密钥{get；set；}
公共字符串名称{get；set；}
公钥名称对（字符串键、字符串名称）
{
这个。键=键；
this.Name=Name；
}
公共整数比较（对象对象对象）
{
var tmp=（KeyNamePair）obj；
var newKey=int.Parse（tmp.Name.Split（“”）[1]）；
var oldKey=int.Parse（Name.Split（“”）[1]）；
如果（旧键>新键）
申报表（1）；
如果（旧键<新键）
返回（-1）；
其他的
返回（0）；
}
}
列表=新列表（）；
添加（新的密钥对（“1”，“第1天”）；
添加（新的密钥对（“2”，“第11天”）；
添加（新的密钥对（“4”，“第5天”）；
添加（新的密钥对（“6”，“第13天”）；
list.Sort（）；
foreach（列表中的var keyNamePair）
{
System.Console.Write（keyNamePair）；
}

有错误吗？你能不能比“

这不做任何排序”

”更具描述性。类似于按空格拆分、解析为int-second元素、按此元素排序：

x=