根据字符串位置（C#）对字符串数组进行排序

我想知道如何根据特定的字符串位置对字符串[]的项进行排序。例如，我想按子字符串“-”对以下数组进行排序

输入：{xx-c，xxxxx-b，yyy-a，mllll-d}

预期输出：{yyy-a，xxxxx-b，xx-c，mllll-d}

到目前为止，我掌握的情况如下：

public string[] SortByStringPos(string[] arr, string str, bool ascending)
{
    if (ascending)
    {
        var result = from s in arr
                     where s.Length >= s.IndexOf(str)
                     orderby s[s.IndexOf(str)] ascending
                     select s;

        return result.ToArray();
    }
    else
    {
        var result = from s in arr
                     where s.Length >= s.IndexOf(str)
                     orderby s[s.IndexOf(str)] descending
                     select s;

        return result.ToArray();
    }
}

谁能给我一个提示

orderby x=>x.Substring(x.LastIndexOf('-'))

我想

---

所以你需要以通常的方式订购，然后你可以使用这个，比如orderBy。。。。然后，为了获得更好的性能和设计，我建议您使用：

    public void SortByStringPos(string[] arr, string str, bool ascending)
    {
        Array.Sort(arr, new MyStrComparer("-", ascending));
    }

    class MyStrComparer : Comparer<string>
    {
        string delimiter;
        bool isAscending;

        public MyStrComparer(string aStr, bool ascending)
        {
            delimiter = aStr;
            isAscending = ascending;
        }

        public override int Compare(string x, string y)
        {
            var r = GetMySubstring(x).CompareTo(GetMySubstring(y));
            return isAscending ? r : -r;
        }

        string GetMySubstring(string str)
        {
            return str.IndexOf(delimiter) != -1 ? str.Substring(str.LastIndexOf(delimiter)) : string.Empty;
        }

    }

public void SortByStringPos（string[]arr，string str，bool升序）
{
Sort（arr，newmystrcomparer（“-”，升序））；
}
类MyStrComparer:Comparer
{
字符串分隔符；
布尔伊萨丁；
公共MyStrComparer（字符串aStr，布尔升序）
{
分隔符=aStr；
上升=上升；
}
公共覆盖整型比较（字符串x、字符串y）
{
var r=GetMySubstring（x）.CompareTo（GetMySubstring（y））；
返回isAscending？r:-r；
}
字符串GetMySubstring（字符串str）
{
返回str.IndexOf（分隔符）！=-1？str.Substring（str.LastIndexOf（分隔符））：string.Empty；
}
}

您还可以删除

SortByStringPos

方法并调用

Array.Sort（arr，newmystrcomparer（“-”，升序））从代码中的任意位置
 
static void Main（）
static void Main()
{
    var input = new[] { "xx - c", "xx - b", "yy - a", "ml - d", };
    var delimeter = "-";
    var isAscending = true;

    var res = Sort(input, delimeter, isAscending);
}

static string[] Sort(string[] input, string delimeter, bool isAscending)
{
    var withDelimeter = input.Where(p => p.Contains(delimeter));
    var withoutDelimeter = input.Except(withDelimeter);

    Func<string, string> selector = p => p.Substring(p.IndexOf(delimeter));

    return
        (
            isAscending

                ? withDelimeter.OrderBy(selector)
                    .Concat(withoutDelimeter.OrderBy(p => p))

                : withoutDelimeter.OrderByDescending(p => p)
                    .Concat(withDelimeter.OrderByDescending(selector))
        )
        .ToArray();
}

{
var输入=新[]{“xx-c”、“xx-b”、“yy-a”、“ml-d”，}；
var delimeter=“-”；
var isAscending=真；
var res=排序（输入、delimeter、isAscending）；
}
静态字符串[]排序（字符串[]输入、字符串delimeter、布尔isAscending）
{
var withDelimeter=输入，其中（p=>p.Contains（delimeter））；
var Without Delimeter=输入。除（Without Delimeter）外；
Func selector=p=>p.Substring（p.IndexOf（delimeter））；
返回
(
令人厌恶
？带Delimeter.订购人（选择器）
.Concat（不带delimeter.OrderBy（p=>p））
：不带Delimeter.OrderByDescending（p=>p）
.Concat（带delimeter.OrderByDescending（选择器））
)
.ToArray（）；
}
使用
子字符串
获取字符串的最后一部分。LINQ查询可以逐步构造。这减少了代码重复（=枯燥的原则，不要重复自己）：

var query=arr.Where（s=>s.Contains（str））；
Func-sortExpr=s=>s.Substring（s.IndexOf（str））；
if（升序）{
query=query.OrderBy（sortExpr）；
}否则{
query=query.OrderByDescending（sortExpr）；
}
返回query.ToArray（）；
看起来您想按
-
后面的字母排序，而不是按
-
的位置排序，这在所有字符串中都是相同的？那么您想要的是只根据字符串的最后一部分对字符串数组进行排序？比如忽略前4个字符？（或者，在您的情况下，仅是“-”？”后面的部分。很抱歉，我没有足够清楚地指定它。我想对字符串[]中第一次出现给定字符串X的所有项目进行排序。如果项目Y中不存在X，则只需将Y放在新字符串[]的末尾即可.我希望现在它更清楚了…？当输入中的字符串X没有带分隔符时，它会丢失…坏：-（丢失分隔符的大小写已修复：-）您能更具体地解释一下您想做什么吗achieve@oren这次我测试了一下@如果你满意，请将oren标记为答案并投票。我正在这里建立声誉！=）
var query = arr.Where(s => s.Contains(str));
Func<string,string> sortExpr = s => s.Substring(s.IndexOf(str));
if (ascending) {
    query = query.OrderBy(sortExpr);
} else {
    query = query.OrderByDescending(sortExpr);
}
return query.ToArray();