Question

我正在学习C＃，我正在寻找一个问题的解决方案，这个问题可能是由糟糕的架构造成的，并且不会影响现实生活中的程序。

我想传递包含多个函数但不需要实例化的“某事”（不一定是类），例如，我想在字典中创建一个包含小时和任务列表的类，所以例如，在12:00我希望课程“午餐”，但午餐可能取决于其他变量，所以我有一个dict条目来检查像{12，LunchTask}，LunchTask是子类/实现/推导'任务'所以我们可以安全地传递它并调用SomeTask.Start，SomeTask.Pause，SomeTask.Stop之类的东西。

我虽然关于使用Dictionary（int，System.Type）但是无法使它工作，我也尝试过静态但是它们不能被子类化，并且就我所知，委托用于单个函数。我只是想在一个dict中传递一些东西，它具有可以直接访问而无需实例化的函数。我知道的一个解决方案可行，但我发现非常不优雅的是有一个带有所有不同任务实例的静态类。

我不知道有什么更好的方法来实现这样的基本功能，也许我做的一切都非常糟糕。所以，如果你们能指出我正确的方向，我将非常感激。提前谢谢。

这是一些（伪c＃）代码：

public abstract class Task {
    public abstract void ExecuteTask ();
    public virtual void PauseTask() {Console.WriteLine ("Task Paused")}
    public virtual void StopTask() {Console.WriteLine ("Task Stopped")}
}

public class Lunch : Task {
    public override void ExecuteTask ()
    {
        Console.WriteLine ("Lunch Task Started");
    }
}

//the following is gonna be instantiated
public class Human {
    Dictionary<int, Something> attributions =  new Dictionary<int, Something>(){{12, Lunch}};
    void ToBeCalledEveryHour () {
        int hour = someHour();
        if (attributions.ContainsKey(hour))
            attributions[hour].ExecuteTask();
    }
}

Answer 1

如果方法的参数始终相同，这很简单。但是，如果它们会有所不同，那么非常很难。

我会说，我没有看到这方面的优势，只是在Dispatcher之外实例化你想要的对象并在其中调用方法。

但这是一个非常基本的例子，说明了你想要实现的目标（根据你发布的代码进行编辑）：

//Method Call:
Dictionary<int, System.Type> attributions = new Dictionary<int, System.Type>(){{12, typeof[Lunch]}};
Dispatcher(attributions);

//Dispatcher
public void Dispatcher(IDictionary<int, System.Type> dictionary) {
    int hour = SomeHour()

    // Instantiate object
    var obj = Activator.CreateInstance(attributions[hour]);

    //Build args
    var args = new object[]{
        new object(),
    };

    // Invoke method
    type.InvokeMember("ExecuteTask", System.Reflection.BindingFlags.Public, null, obj, args);
}

Answer 2

您可以使用以下内容来存储函数字典，其中每个函数具有相同的签名。

然后，您可以将引用传递给此类字典。您还可以将对静态Compute方法的引用传递给任何接受Func＆lt; ArithmeticFunction，int，int，int＆gt;

的方法。

internal enum ArithmeticFunction
{
   Add,
   Subtract,
   Multiply,
   Divide,
   Min,
   Max,
}

internal static class FunctionMap
{
   private static readonly Dictionary<ArithmeticFunction, Func<int, int, int>> s_map;

   static FunctionMap()
   {
      s_map = new Dictionary<ArithmeticFunction, Func<int, int, int>>();

      s_map[ArithmeticFunction.Add] = (x, y) => x + y;
      s_map[ArithmeticFunction.Subtract] = (x, y) => x - y;
      s_map[ArithmeticFunction.Multiply] = (x, y) => x * y;
      s_map[ArithmeticFunction.Divide] = (x, y) => x / y;
      s_map[ArithmeticFunction.Min] = System.Math.Min;
      s_map[ArithmeticFunction.Max] = System.Math.Max;
   }

   //Don't allow callers access to the core map.  Return them a copy instead.
   internal static Dictionary<ArithmeticFunction, Func<int, int, int>> GetCopy()
   {
      return new Dictionary<ArithmeticFunction, Func<int, int, int>>(s_map); 
   }

   internal static int Compute(ArithmeticFunction op, int x, int y)
   {
      return s_map[op](x, y);
   }

}

static void Main(string[] args)
{

   System.Diagnostics.Trace.WriteLine("Example 1:");
   System.Diagnostics.Trace.WriteLine(FunctionMap.Compute(ArithmeticFunction.Add, 12, 4));
   System.Diagnostics.Trace.WriteLine(FunctionMap.Compute(ArithmeticFunction.Subtract, 12, 4));
   System.Diagnostics.Trace.WriteLine(FunctionMap.Compute(ArithmeticFunction.Multiply, 12, 4));
   System.Diagnostics.Trace.WriteLine(FunctionMap.Compute(ArithmeticFunction.Divide, 12, 4));
   System.Diagnostics.Trace.WriteLine(FunctionMap.Compute(ArithmeticFunction.Min, 12, 4));
   System.Diagnostics.Trace.WriteLine(FunctionMap.Compute(ArithmeticFunction.Max, 12, 4));

   var safeCopy = FunctionMap.GetCopy();
   System.Diagnostics.Trace.WriteLine("Example 2:");
   System.Diagnostics.Trace.WriteLine(safeCopy[ArithmeticFunction.Add](72, 9));
   System.Diagnostics.Trace.WriteLine(safeCopy[ArithmeticFunction.Subtract](72, 9));
   System.Diagnostics.Trace.WriteLine(safeCopy[ArithmeticFunction.Multiply](72, 9));
   System.Diagnostics.Trace.WriteLine(safeCopy[ArithmeticFunction.Divide](72, 9));
   System.Diagnostics.Trace.WriteLine(safeCopy[ArithmeticFunction.Min](72, 9));
   System.Diagnostics.Trace.WriteLine(safeCopy[ArithmeticFunction.Max](72, 9));

输出如下：

Example 1:
16
8
48
3
4
12

Example 2:
81
63
648
8
9
72

Answer 3

在您的情况下，您可以使用对象池模式或工厂模式。

如果是对象池模式，您可以使用一个Map，其中key应该是唯一标识该对象的字符串，例如它可以是类名，值可以是对应的对象。

像这样：

public abstract class Task {
public abstract void ExecuteTask ();
public virtual void PauseTask() {Console.WriteLine ("Task Paused")}
public virtual void StopTask() {Console.WriteLine ("Task Stopped")}
}

public class Lunch : Task {
   public override void ExecuteTask ()
   {
     Console.WriteLine ("Lunch Task Started");
   }
}

public class ObjectCollection{
    Dictionary<string,Task> objectStringMapper= new Dictionary<string,string>();
    Dictionary<string,Task> objectTimeMapper= new Dictionary<string,string>();
    public ObjectCollection(){
        objectMapper.Add("Lunch",new LunchTask());
        objectTimeMapper.Add(12,new LunchTask());        
    }
    public Task getObject(string objId){
        return objectMapper.get(objId);
    }
    public Task getObject(int time){
        return objectTimeMapper.get(time);
    } 

 }

public class Human {
    ObjetCollection objectsFactory = new ObjectCollection();
    void ToBeCalledEveryHour () {
        int hour = someHour();
        if (attributions.ContainsKey(hour))
            objectsFactory.getObject(hour).ExecuteTask();
      }
}

或者您可以选择工厂模式，您可以在其中使用反射或开关案例创建对象。

注意：由于我是Java开发人员并且是c＃的新用户，因此您可能会发现某些语法错误。

除了对象实例之外，我还可以使用什么可通过值来访问多个函数？

3 个答案: