C# 需要LINQ OrderBy帮助吗

我正在尝试按照另一个数组定义的顺序创建字符串集合。听起来很困惑，我知道，让我解释一下

requiredOrderOfElements

{  
[0] category1,  
[1] categoryX,  
[2] something else  
}

我的客户机向上传递了一个包含键和值的字符串数组

从客户端传递

{  
[0][0] categoryX,  
[0][1] value from Category X,  
[1][0] something else,  
[1][1] value for something else,  
[2][0] category1,  
[2][1] value from Category 1  
}

我想要的是按键的顺序排列的“值”文本

我想要什么

[0]value from Category 1  
[1]value from Category X  
[2]value for something else 

我已经看过OrderBy/IComparer，但看不到一个明显的方法来实现我所需要的。我当前的解决方案是一个丑陋的嵌套for循环

任何关于更优雅的方式的想法都将不胜感激

更新：-这是测试

[TestFixture]
public class GL_Linq_Test
{
    [Test]
    public void CanOrderByAnotherArray()
    {
        var requiredOrder=new[]{"my","required","order"};
        var passedFromClient = new[]
                                   {
                                       new[] {"required", "cat"},
                                       new[] {"order", "dog"},
                                       new[] {"my", "bird"}
                                   };

        var ordered = FunkyOrderer.Order(requiredOrder, passedFromClient);

        Assert.That(ordered.First()[1],Is.EqualTo("bird"));
        Assert.That(ordered.Skip(1).First()[1], Is.EqualTo("cat"));
        Assert.That(ordered.Skip(2).First()[1], Is.EqualTo("dog"));
    }
}

public static class FunkyOrderer
{
//returns order bird,dog,cat not bird,cat,dog        
public static IEnumerable<string[]> Order(string[] requiredOrder, IEnumerable<string[]>passedFromClient)
    {
        return from o in requiredOrder
                     join f in passedFromClient on o equals f[0]
                     orderby o
                     select f;
    }
}

[TestFixture]
公共类GL_Linq_测试
{
[测试]
public void CanOrderByAnotherArray（）
{
var requiredOrder=new[]{“我的”、“必需的”、“订单”}；
var passedFromClient=new[]
{
新[]{“必需”、“类别”}，
新[]{“订单”，“狗”}，
新[]{“我的”，“鸟”}
};
var ordered=funkyorder.Order（requiredOrder，passedFromClient）；
Assert.That（ordered.First（）[1]是.EqualTo（“bird”）；
Assert.That（ordered.Skip（1.First（）[1]是.EqualTo（“cat”））；
Assert.That（ordered.Skip（2.First（）[1]是.EqualTo（“dog”））；
}
}
公共静态类FunkyOrder
{
//返回订单鸟，狗，猫不是鸟，猫，狗
公共静态IEnumerable顺序（字符串[]requiredOrder，IEnumerablepassedFromClient）
{
在requiredOrder中从o返回
在o=f[0]上的passedFromClient中加入f
奥德比
选择f；
}
}

问题在于，假设字符串数组将按其索引排序（不会）。使用内置字符串比较器，

“my”、“order”、“required”

的顺序是正确的。最简单的解决方案是修改LINQ查询，以便在排序时考虑索引

return from o in requiredOrder.Select((o, i) => new { Value = o, Index = i })
       join f in passedFromClient on o.Value equals f[0]
       orderby o.Index
       select f;

---

@吉莉——这几乎不足以让人开始有意义。请发布一些示例代码或每个数组的实际外观布局。嗯，不确定还要添加什么！我将在下面发布一个测试，看看这是否能更好地解释这一点。不完全正确地获取数组中的第一项，但其他两项是错误的。我将发布一个测试

return from o in requiredOrder.Select((o, i) => new { Value = o, Index = i })
       join f in passedFromClient on o.Value equals f[0]
       orderby o.Index
       select f;