C# 按用户定义的顺序执行Func委托

我创建了一些自定义函数，然后将它们添加到称为运算符的函数列表中，如下所示：

...
    Func<Vector3, Vector3> Move1MFunc = (v) => v.Z == 0 ? v.Add(1, 0, 1) : v.Subtract(1, 0, 1);

    Func<Vector3, Vector3> Move2MFunc = (v) => v.Z == 0 ? v.Add(2, 0, 1) : v.Subtract(2, 0, 1);

    protected List<Func<Vector3, Vector3>> Operators { get; set; }
...

。。。
Func Move1MFunc=（v）=>v.Z==0？v、 加（1,0,1）：v.减去（1,0,1）；
Func Move2MFunc=（v）=>v.Z==0？v、 加（2，0，1）：v.减去（2，0，1）；
受保护的列表运算符{get；set；}
...

在另一种方法中，我遍历操作符列表并执行每个委托：

    protected IEnumerable<Vector3> GetChildrenStates(Vector3 parentState)
    {
        foreach (var op in Operators)
        {
            // Get a child using the current operator
            var possibleChild = op(parentState);
            ...

受保护的IEnumerable GetChildrenState（Vector3 parentState）
{
foreach（运算符中的var op）
{
//使用当前运算符获取子对象
var possibleChild=op（父状态）；
...

现在，每个委托都是根据其在列表中的顺序执行的。我希望用户能够定义每个函数的执行顺序（相互之间的关系）。我将向用户提供一些表示每个委托的字符串，并在代码隐藏中将它们链接到委托本身（？）.我正在使用MVVM

我尝试过使用属性来实现这一点，但从我发现属性不支持Funcs

---

我似乎想不出另一种解决方案，因此我在问你。我才刚刚开始使用Funcs，如果有人有任何改进意见，我会很乐意考虑。你可以创建字典实例

运算符，其类型为

和函数

GetOrderedOperators

，如下所示：

    protected static Dictionary<string, Func<Vector3, Vector3>> OperatorsWithTypes 
    { get; set; }

    public static List<Func<Vector3, Vector3>> GetOrderedOperators()
    {
        return (from category in OperatorWithTypes
            orderby
                category.Key == "First"
                    ? 0
                    : category.Key == "Second"

                        ? 1
                        : category.Key == "Third"

                            ? 2
                            : category.Key == "Forth"

                                ? 3
                                : category.Key == "5th"

                                    ? 4
                                    : category.Key == "6th"
                                        ? 5
                                        : -1
            select category.Value)
            .ToList();
    }

//Defined in some class
protected List<FuncWrapper> Operators { get; set; }

private void CreateFunctors()
{

    Operators.Add(new FuncWrapper { Functor = (v) => v.Z == 0 ? v.Add(1, 0, 1) : v.Subtract(1, 0, 1), Order = 1 });
    Operators.Add(new FuncWrapper { Functor = (v) => v.Z == 0 ? v.Add(2, 0, 1) : v.Subtract(2, 0, 1), Order = 2 });

}

private void CallFunctors()
{
    Vector3 v = new Vector3();

    foreach (var f in Operators.OrderBy(o => o.Order))
        f.Functor(v);
}

//Defined somewhere else
public class FuncWrapper
{
    public Func<Vector3, Vector3> Functor { get; set; }
    public int Order { get; set; }
}

Dictionary<string, Func<Vector3, Vector3>> Operators = new Dictionary<string, Func<Vector3, Vector3>>()
{
    {"function1_display_name", Move1MFunc},
    {"function2_display_name", Move2MFunc}
};;

// list_of_names_from_user is the list of function names collected from the user
List<string> list_of_names_from_user = ......

List<Func<Vector3, Vector3>> ordered_functions =
    list_of_names_from_user.Select(x => Operators[x]).ToList();

---

我将Func委托包装在一个类中，并在该类上定义一个属性，表示执行Func所需的顺序

然后使用Linq的OrderBy，您可以执行以下操作：

    protected static Dictionary<string, Func<Vector3, Vector3>> OperatorsWithTypes 
    { get; set; }

    public static List<Func<Vector3, Vector3>> GetOrderedOperators()
    {
        return (from category in OperatorWithTypes
            orderby
                category.Key == "First"
                    ? 0
                    : category.Key == "Second"

                        ? 1
                        : category.Key == "Third"

                            ? 2
                            : category.Key == "Forth"

                                ? 3
                                : category.Key == "5th"

                                    ? 4
                                    : category.Key == "6th"
                                        ? 5
                                        : -1
            select category.Value)
            .ToList();
    }

//Defined in some class
protected List<FuncWrapper> Operators { get; set; }

private void CreateFunctors()
{

    Operators.Add(new FuncWrapper { Functor = (v) => v.Z == 0 ? v.Add(1, 0, 1) : v.Subtract(1, 0, 1), Order = 1 });
    Operators.Add(new FuncWrapper { Functor = (v) => v.Z == 0 ? v.Add(2, 0, 1) : v.Subtract(2, 0, 1), Order = 2 });

}

private void CallFunctors()
{
    Vector3 v = new Vector3();

    foreach (var f in Operators.OrderBy(o => o.Order))
        f.Functor(v);
}

//Defined somewhere else
public class FuncWrapper
{
    public Func<Vector3, Vector3> Functor { get; set; }
    public int Order { get; set; }
}

Dictionary<string, Func<Vector3, Vector3>> Operators = new Dictionary<string, Func<Vector3, Vector3>>()
{
    {"function1_display_name", Move1MFunc},
    {"function2_display_name", Move2MFunc}
};;

// list_of_names_from_user is the list of function names collected from the user
List<string> list_of_names_from_user = ......

List<Func<Vector3, Vector3>> ordered_functions =
    list_of_names_from_user.Select(x => Operators[x]).ToList();

//在某个类中定义
受保护的列表运算符{get；set；}
私有void CreateFunctors（）
{
运算符.Add（新函数{Functor=（v）=>v.Z==0？v.Add（1,0,1）：v.Subtract（1,0,1），Order=1}）；
运算符.Add（新函数{Functor=（v）=>v.Z==0？v.Add（2,0,1）：v.Subtract（2,0,1），Order=2}）；
}
私有void调用函数（）
{
Vector3 v=新Vector3（）；
foreach（Operators.OrderBy中的var f（o=>o.Order））
f、 函子（v）；
}
//在其他地方定义
公共类函数包装器
{
公共函子{get；set；}
公共整数顺序{get；set；}
}

这只是一个粗略的想法。根据需要进行调整

---

干杯你可以这样做：

    protected static Dictionary<string, Func<Vector3, Vector3>> OperatorsWithTypes 
    { get; set; }

    public static List<Func<Vector3, Vector3>> GetOrderedOperators()
    {
        return (from category in OperatorWithTypes
            orderby
                category.Key == "First"
                    ? 0
                    : category.Key == "Second"

                        ? 1
                        : category.Key == "Third"

                            ? 2
                            : category.Key == "Forth"

                                ? 3
                                : category.Key == "5th"

                                    ? 4
                                    : category.Key == "6th"
                                        ? 5
                                        : -1
            select category.Value)
            .ToList();
    }

//Defined in some class
protected List<FuncWrapper> Operators { get; set; }

private void CreateFunctors()
{

    Operators.Add(new FuncWrapper { Functor = (v) => v.Z == 0 ? v.Add(1, 0, 1) : v.Subtract(1, 0, 1), Order = 1 });
    Operators.Add(new FuncWrapper { Functor = (v) => v.Z == 0 ? v.Add(2, 0, 1) : v.Subtract(2, 0, 1), Order = 2 });

}

private void CallFunctors()
{
    Vector3 v = new Vector3();

    foreach (var f in Operators.OrderBy(o => o.Order))
        f.Functor(v);
}

//Defined somewhere else
public class FuncWrapper
{
    public Func<Vector3, Vector3> Functor { get; set; }
    public int Order { get; set; }
}

Dictionary<string, Func<Vector3, Vector3>> Operators = new Dictionary<string, Func<Vector3, Vector3>>()
{
    {"function1_display_name", Move1MFunc},
    {"function2_display_name", Move2MFunc}
};;

// list_of_names_from_user is the list of function names collected from the user
List<string> list_of_names_from_user = ......

List<Func<Vector3, Vector3>> ordered_functions =
    list_of_names_from_user.Select(x => Operators[x]).ToList();

首先定义将名称映射到函数的字典，如下所示：

    protected static Dictionary<string, Func<Vector3, Vector3>> OperatorsWithTypes 
    { get; set; }

    public static List<Func<Vector3, Vector3>> GetOrderedOperators()
    {
        return (from category in OperatorWithTypes
            orderby
                category.Key == "First"
                    ? 0
                    : category.Key == "Second"

                        ? 1
                        : category.Key == "Third"

                            ? 2
                            : category.Key == "Forth"

                                ? 3
                                : category.Key == "5th"

                                    ? 4
                                    : category.Key == "6th"
                                        ? 5
                                        : -1
            select category.Value)
            .ToList();
    }

//Defined in some class
protected List<FuncWrapper> Operators { get; set; }

private void CreateFunctors()
{

    Operators.Add(new FuncWrapper { Functor = (v) => v.Z == 0 ? v.Add(1, 0, 1) : v.Subtract(1, 0, 1), Order = 1 });
    Operators.Add(new FuncWrapper { Functor = (v) => v.Z == 0 ? v.Add(2, 0, 1) : v.Subtract(2, 0, 1), Order = 2 });

}

private void CallFunctors()
{
    Vector3 v = new Vector3();

    foreach (var f in Operators.OrderBy(o => o.Order))
        f.Functor(v);
}

//Defined somewhere else
public class FuncWrapper
{
    public Func<Vector3, Vector3> Functor { get; set; }
    public int Order { get; set; }
}

Dictionary<string, Func<Vector3, Vector3>> Operators = new Dictionary<string, Func<Vector3, Vector3>>()
{
    {"function1_display_name", Move1MFunc},
    {"function2_display_name", Move2MFunc}
};;

// list_of_names_from_user is the list of function names collected from the user
List<string> list_of_names_from_user = ......

List<Func<Vector3, Vector3>> ordered_functions =
    list_of_names_from_user.Select(x => Operators[x]).ToList();

字典运算符=新字典（）
{
{“function1\u display\u name”，Move1MFunc}，
{“函数2_显示_名称”，Move2MFunc}
};;

然后假设您从用户处收集了一个包含函数显示名称的

列表

，您可以创建如下函数列表：

    protected static Dictionary<string, Func<Vector3, Vector3>> OperatorsWithTypes 
    { get; set; }

    public static List<Func<Vector3, Vector3>> GetOrderedOperators()
    {
        return (from category in OperatorWithTypes
            orderby
                category.Key == "First"
                    ? 0
                    : category.Key == "Second"

                        ? 1
                        : category.Key == "Third"

                            ? 2
                            : category.Key == "Forth"

                                ? 3
                                : category.Key == "5th"

                                    ? 4
                                    : category.Key == "6th"
                                        ? 5
                                        : -1
            select category.Value)
            .ToList();
    }

//Defined in some class
protected List<FuncWrapper> Operators { get; set; }

private void CreateFunctors()
{

    Operators.Add(new FuncWrapper { Functor = (v) => v.Z == 0 ? v.Add(1, 0, 1) : v.Subtract(1, 0, 1), Order = 1 });
    Operators.Add(new FuncWrapper { Functor = (v) => v.Z == 0 ? v.Add(2, 0, 1) : v.Subtract(2, 0, 1), Order = 2 });

}

private void CallFunctors()
{
    Vector3 v = new Vector3();

    foreach (var f in Operators.OrderBy(o => o.Order))
        f.Functor(v);
}

//Defined somewhere else
public class FuncWrapper
{
    public Func<Vector3, Vector3> Functor { get; set; }
    public int Order { get; set; }
}

Dictionary<string, Func<Vector3, Vector3>> Operators = new Dictionary<string, Func<Vector3, Vector3>>()
{
    {"function1_display_name", Move1MFunc},
    {"function2_display_name", Move2MFunc}
};;

// list_of_names_from_user is the list of function names collected from the user
List<string> list_of_names_from_user = ......

List<Func<Vector3, Vector3>> ordered_functions =
    list_of_names_from_user.Select(x => Operators[x]).ToList();

//来自用户的函数名列表是从用户收集的函数名列表
列出来自用户的名称列表=。。。。。。
列出有序函数=
列出来自用户的名称。选择（x=>Operators[x]）。ToList（）；

---

现在，

ordered\u functions

将包含根据用户的

list\u\u\u name\u中函数显示名称的顺序排序的函数

您可以创建一个

字典

，它将您显示给用户的字符串映射到每个函数。然后，您可以循环浏览它们的选择并进行查找，以找到正确的函数选择执行。我如何存储执行顺序？首先在字典中执行第一项，然后在字典中执行第二项，依此类推？对我来说，感觉就像你在问如何根据用户选择填写列表-这听起来对我来说太宽泛了…但我可能遗漏了一些东西。我可以存储用户选择列表s、 但是我的问题是将选择映射到代理。正如@Rob提到的，字典可能是解决方案，我没有想到。好主意，我甚至可以从我的视图绑定到包装器中的属性，这样用户可以通过绑定进行排序。非常感谢！对！我喜欢这样的场景：-）