C# 4.0 在C#中，如何使用Func<；从另一个类传递方法；T>；？

我有一个状态机，它需要根据我所处的状态对对象列表中的每个对象调用不同的方法。基本上，我试图重构在我的状态机的每个case语句中都有一个循环的代码，使其看起来像下面的代码。但是，我似乎不知道如何将相关方法传递给重构函数（更不用说我不知道如何对每个项调用它）

任何帮助都将不胜感激

下面是示例代码：

    public class MyOtherType
    {
        public bool Method1()
        { return false; }
        public bool Method2()
        { return false; }
        public bool Method3()
        { return false; }
        public bool Method4()
        { return false; }
    }

    public class MyType
    {
        public enum MyState
        {
            DoSomething1,
            DoSomething2,
            DoSomething3,
            DoSomething4
        }
        private MyState State = MyState.DoSomething1;

        List<MyOtherType> MyListOfObjects = new List<MyOtherType>() { new MyOtherType(), new MyOtherType() };

        private void StateMachine()
        {
            switch (State)
            {
                case MyState.DoSomething1:
                    //How do I pass this in? Do I need to set it up differnetly?
                    Process(() => MyOtherType.Method1());
                    break;
                case MyState.DoSomething2:
                    Process(() => MyOtherType.Method2);
                    break;
                case MyState.DoSomething3:
                    Process(() => MyOtherType.Method3);
                    break;
                case MyState.DoSomething4:
                    Process(() => MyOtherType.Method4);
                    break;
            }
        }

        private void Process(Func<bool> method)
        {
            foreach (MyOtherType item in MyListOfObjects)
            {
                //How do I call the method on each item?
                if (item.method())
                {
                    //Do something
                }
            }
        }
    }

公共类MyOtherType
{
公共布尔方法1（）
{返回false；}
公共布尔方法2（）
{返回false；}
公共布尔方法3（）
{返回false；}
公共布尔方法4（）
{返回false；}
}
公共类MyType
{
公共枚举我的状态
{
DoSomething1，
DoSomething2，
DoSomething3，
DoSomething4
}
私有MyState State=MyState.DoSomething1；
List MyListOfObjects=new List（）{new MyOtherType（），new MyOtherType（）}；
私有void状态机（）
{
开关（状态）
{
case MyState.DoSomething1：
//我如何传递这个？我需要不同的设置吗？
进程（（）=>MyOtherType.Method1（））；
打破
case MyState.DoSomething2：
过程（（）=>MyOtherType.Method2）；
打破
case MyState.DoSomething3：
过程（（）=>MyOtherType.Method3）；
打破
案例MyState.DoSomething4：
过程（（）=>MyOtherType.Method4）；
打破
}
}
专用作废处理（Func方法）
{
foreach（MyListOfObjects中的MyOtherType项）
{
//如何对每个项调用该方法？
if（item.method（））
{
//做点什么
}
}
}
}

我建议摆脱这种

开关

块，通过引入每个状态的灵活策略图，将每个特定方法与状态解耦，以便可以轻松更改甚至注入：

IDictionary<MyState, Func<bool>> strategyMap;

---

如果有任何问题，请随时提问

一种可能的解决方案是使方法保持静态，并将它们应操作的类引用作为参数：

public class MyOtherType
{
    public static bool Method1(MyOtherType instance)
    { 
        return instance == null;  
    }
}

---

在我看来，这更多的是一个设计问题，而不是

Func

的问题。这是一个很好的主意，尽管在我的真实代码中，在给定状态下我可能有其他处理。不过，这个答案将使我能够根据需要进行重构，所以谢谢！是的，我考虑过这一点，但由于我试图重构一个只随方法调用而变化的重复循环，因此仅为此目的生成大量额外的静态方法似乎适得其反。不过，这仍然是一个有效的建议，谢谢。