C# 按字符串数组c对列表排序#

我试图按列表中的其他值对列表进行排序

当我试图完成时：当我向列表中添加一个值时，我将使用一个包含该值的方法，以及一个表示其依赖关系的字符串[]

我想根据ListObject内字符串[]中的值对列表进行排序

以下是一个编程示例：

public class ListObject {
    private string name;
    private string[] dependencies;
    private object value;

    public ListObject(string name, string[] dependencies, object value) {
        this.name = name;
        this.dependencies = dependencies;
        this.value = value;
    }
}

public class ExampleClass {
    public static void Main(string[] args) {
        List<ListObject> list = new List<ListObject>();
        list.Add(new ListObject("ran", new string[] { }, "Value"));
        list.Add(new ListObject("far", new string[] {"thest"}, "Value"));
        list.Add(new ListObject("the", new string[] {"ran"}, "Value"));
        list.Add(new ListObject("thest", new string[] {"the", "ran"}, "Value"));
        list.Add(new ListObject("man", new string[] {"ran", "thest"}, "Value"));

        //What I want the order of the list to become
        /* ran
         * the
         * far
         * thest
         * man
         */
    }
}

公共类ListObject{
私有字符串名称；
私有字符串[]依赖项；
私人客体价值；
公共ListObject（字符串名称、字符串[]依赖项、对象值）{
this.name=名称；
这是依赖项=依赖项；
这个值=值；
}
}
公共类示例类{
公共静态void Main（字符串[]args）{
列表=新列表（）；
Add（新的ListObject（“ran”，新字符串[]{}，“Value”）；
Add（新列表对象（“far”，新字符串[]{“thest”}，“Value”）；
Add（新的ListObject（“the”，新字符串[]{“ran”}，“Value”）；
Add（newlistObject（“thest”，新字符串[]{“the”，“ran”}，“Value”）；
Add（新的ListObject（“man”，新字符串[]{“ran”，“thest”}，“Value”）；
//我希望列表的顺序是什么
/*跑
*
*远
*塞斯特
*人
*/
}
}

---

更多信息：我在运行时生成类，我需要确保如果某个字段具有生成的类类型，那么在生成该字段所在的类之前，我需要确保生成该字段所依赖的类。

我不完全取消规则，您需要更改测试输入，但这里有一个版本可以生成您想要的序列，更一般地说，它是所有排序策略（badam tsh！）的蓝图

using System.Linq;

(...)

public class ListObject
    {
        public string name {get;} // Made into properties and public

(...)

       List<ListObject> list = new List<ListObject>();
       list.Add(new ListObject("ran", new string[] { }, "Value"));
       list.Add(new ListObject("far", new string[] {"thest"}, "Value"));
       list.Add(new ListObject("the", new string[] {"ran"}, "Value"));
       list.Add(new ListObject("thest", new string[] {"ran", "the"}, "Value"));

            //What I want the order of the list to become
            /* ran
             * the
             * far
             * thest
             */

        foreach(var o in list) { Console.WriteLine(o.name);}

        var ordered = list
            .OrderBy(o => o.dependencies.Count()) // This is not needed, it's here just to show that you can chain OrderBy
            .ThenBy( o => string.Join(",",o.dependencies));
        Console.WriteLine(">>>Sorted");
        foreach(var o in ordered) { Console.WriteLine(o.name);}

---

这是一个使用对象引用而不是字符串的版本

    public class ListObject
    {
        public string name { get; }

        public ListObject[] dependencies{get;}

        private object value;
        public ListObject(string name, ListObject[] dependencies, object value)
        {
            this.name = name;
            this.dependencies = dependencies;
            this.value = value;
        }
    }

    public static void Main(string[] args)
    {
        var ran = new ListObject("ran", new ListObject[0], "Value");
        var the = new ListObject("the", new[]{ran}, "Value");
        var thest = new ListObject("thest", new[]{ran, the}, "Value");
        var far = new ListObject("far", new[]{thest}, "Value");

        List<ListObject> list = new List<ListObject>(){ran, the, thest, far};
        //What I want the order of the list to become
        /* ran
             * the
             * far
             * thest
             */
        foreach (var o in list)
        {
            Console.WriteLine(o.name);
        }

        var ordered = list
              .OrderBy(o => o.dependencies.Count()) // This is not needed, it's here just to show that you can chain OrderBy
              .ThenBy(o => string.Join(",", o.dependencies.Select(d => d.name)));
        Console.WriteLine(">>>Sorted");
        foreach (var o in ordered)
        {
            Console.WriteLine(o.name);
        }
    }

公共类ListObject
{
公共字符串名称{get；}
公共ListObject[]依赖项{get；}
私人客体价值；
公共ListObject（字符串名称、ListObject[]依赖项、对象值）
{
this.name=名称；
这是依赖项=依赖项；
这个值=值；
}
}
公共静态void Main（字符串[]args）
{
var ran=new ListObject（“ran”，new ListObject[0]，“Value”）；
var=newlistObject（“the”，new[]{ran}，“Value”）；
var-thest=newlistObject（“thest”，new[]{ran，the}，“Value”）；
var far=新列表对象（“far”，new[]{thest}，“Value”）；
List List=new List（）{ran，the，the，the，far}；
//我希望列表的顺序是什么
/*跑
*
*远
*塞斯特
*/
foreach（列表中的var o）
{
控制台写入线（o.name）；
}
变量排序=列表
.OrderBy（o=>o.dependencies.Count（））//这不是必需的，它只是显示您可以链接OrderBy
.ThenBy（o=>string.Join（“，”，o.dependencies.Select（d=>d.name））；
Console.WriteLine（“>>>排序”）；
foreach（有序中的变量o）
{
控制台写入线（o.name）；
}
}

在以下位置找到了我的问题的解决方案：

---

它被称为拓扑排序。

对于初学者来说，如果顺序很重要，你应该使用正确的字典：其余的我并不清楚。但是，如果问题确实是键没有被排序，这将解决它。实际上，最好使用SortedList，并使用DictionaryObject对值进行排序。我将更新这个问题。在您的代码示例中，没有任何东西可以排序，甚至没有任何东西可以比较值（这是排序的核心）。请回答这个问题并改进代码示例，这样我们就可以看到排序在这种情况下意味着什么，应该在哪里进行排序以及如何进行排序。我更新了我的问题，希望能够使我试图完成的事情更加清楚。可能重复我没有尝试按名称排序，我尝试按字符串数组中的值排序。谢谢！我编辑了测试输入，以便更清楚地了解我的要求。是的，更新它是个好主意！它变得更清晰了。抱歉，实际上它还没有解决，我再次编辑了这个问题以使它更清晰，ListObject中的这个字符串[]应该是对其他ListObject的引用排序仍然会给出预期的输出。您没有提供规则，只是提供了预期的输出。

    public class ListObject
    {
        public string name { get; }

        public ListObject[] dependencies{get;}

        private object value;
        public ListObject(string name, ListObject[] dependencies, object value)
        {
            this.name = name;
            this.dependencies = dependencies;
            this.value = value;
        }
    }

    public static void Main(string[] args)
    {
        var ran = new ListObject("ran", new ListObject[0], "Value");
        var the = new ListObject("the", new[]{ran}, "Value");
        var thest = new ListObject("thest", new[]{ran, the}, "Value");
        var far = new ListObject("far", new[]{thest}, "Value");

        List<ListObject> list = new List<ListObject>(){ran, the, thest, far};
        //What I want the order of the list to become
        /* ran
             * the
             * far
             * thest
             */
        foreach (var o in list)
        {
            Console.WriteLine(o.name);
        }

        var ordered = list
              .OrderBy(o => o.dependencies.Count()) // This is not needed, it's here just to show that you can chain OrderBy
              .ThenBy(o => string.Join(",", o.dependencies.Select(d => d.name)));
        Console.WriteLine(">>>Sorted");
        foreach (var o in ordered)
        {
            Console.WriteLine(o.name);
        }
    }