Question

我一直在寻找几天来解决C或C ++中的一个小问题，但在C＃中似乎是不可能的。

另一个程序员创建类A.类A中的事件处理程序方法需要调用类B中的方法来处理事件。根据事件的类型，B类中的方法需要回调A类中的方法，并且该方法具有任意名称，甚至可能不存在。

这在C中很简单;你只需要一个指向回调函数的指针，如果它不为null，则间接调用它。我不知道如何在C＃中进行间接方法调用。以下是一些说明问题的代码示例。

public class A: ZZZ { // this class is NOT under my control
   private b = new B(this);

   public void myCallback(C x) {
      // do something
   }

   // Elsewhere in the application expects a protected
   // override method to exist in *this* class A to handle
   // an event. But we want a method in class B to handle
   // it and then call myCallback depending on the type of event

   protected override void handle_some_event(event e) {
      // doesn't work -- how do I pass a "pointer" to the callback??
      b.handle_event(e, myCallback);
   }
}


public class B {    // this class IS under my control
   private A base;

    public B(A a) {
       base = a; // allows for calling methods in class A from class B
    }

    public handle_event(event e, ??? callback pointer ??? cback) {
       // do stuff...
       // then do the callback
       // cback(); // this won't work
       base.myCallback(); // this WILL work but only if I hard-code "myCallback"
    }    
}

问题在于B类是我正在写的那个，而A类是由其他将使用我的B类的人创作的。其他人可以选择根本不定义回调，或创建一个任意名称。 B类需要知道它是什么以及如何访问它。在C或C ++中，其他程序员可以简单地将指针传递给他的回调函数。这可能在C＃中吗？

Answer 1

您希望将Action<T>传递给handle_some_event，您可以这样做：

public handle_some_event(event e, Action<C> cback) 
{
   // Do stuff
   if(cback != null)
       cback(myC);
}

你的class B实际上根本不需要了解class A，它只需要一个Action委托执行，其余部分无关紧要。

Answer 2

您可以使用Action委托来引用回调。

检查此网址以获取更多信息：http://msdn.microsoft.com/en-us/library/018hxwa8.aspx

将B类改为：公共课B { 私人基地;

    public B(A a) {
       base = a; // allows for calling methods in class A from class B
    }

   //#################### NOTE THE CHANGE HERE ##################//
    public handle_some_event(event e, Action<C> cback) {
       // do stuff...
       // then do the callback
       cback(x); // this will work assuming you have x defined somewhere in B
    }    
}

Answer 3

根据我最初的帖子

中的代码，这是我最终得到的解决方案

public class A: ZZZ { // this class is NOT under my control
   private b = new B(this);
   b.UserCallback = myCallback;

   static void myCallback(C x) {
      // do something
   }

   // Elsewhere in the application expects a protected
   // override method to exist in *this* class A to handle
   // an event. But we want a method in class B to handle
   // it and then call myCallback depending on the type of event

   protected override void handle_some_event(event e) {
      b.handle_event(e);
   }
}

public delegate void usercallback(Z z); // declare OUTSIDE both classes

public class B {    // this class IS under my control
   public usercallback UserCallback = defaultCallback;
   static void defaultCallback(Z z) { /* do nothing */ }

   public handle_event(event e) {
       // do stuff...
       // then do the callback
       UserCallback(z);
   }    
}

让我陷入困境的是围绕着这样一个事实：委托声明类似于C函数原型，并且委托可以用作类中的声明类型。

C＃用户定义了对不同类中的方法的回调

3 个答案: