C# System.Threading.ThreadPool.QueueUserWorkItem C的动态回调方法

我试图做的是能够将函数引用传递给另一个函数，并将其用作System.Threading.ThreadPool.QueueUserWorkItem的回调方法

请参见方法D中的“Any”参数

        private void A(object state)
    {
        // does one thing
    }

    private void B(object state)
    {
        // does a different thing
    }

    private void C(int i)
    {
        switch (i)
        {
            case 1:
                D(new System.Threading.WaitCallback(A));
                break;
            case 2:
                D(new System.Threading.WaitCallback(B));
                break;
            default:
                break;
        }
    }

    private void D(System.Threading.WaitCallback worker)
    { 
        System.Threading.ThreadPool.QueueUserWorkItem(worker);
    }

我需要能够传递“Any”参数的回调方法指针或引用。我不能使用委托，因为它需要是静态的，对吗

有什么想法吗

    private void A() { /*code*/ }

    private void B() { /*code*/ }

    private void C(int i)
    {
        switch(i)
        {
            case 1:
                D(A());
                break;
            case 2:
                D(B());
                break;
            default:
                break;
        }
    }

    private void D(type? Any)
    { 
        System.Threading.ThreadPool.QueueUserWorkItem(new System.Threading.WaitCallback(Any));
    }

我不能使用委托，因为它需要是静态的，对吗

delegate void MyMethods();

class Foo
{
    void Minstance() {}
    static void Mstatic() {}

    MyMethods m1 = Minstance;  // OK
    MyMethods m2 = Mstatic;    // OK
}

不，那是不对的

delegate void MyMethods();

class Foo
{
    void Minstance() {}
    static void Mstatic() {}

    MyMethods m1 = Minstance;  // OK
    MyMethods m2 = Mstatic;    // OK
}

以下是不正确的语法：

        case 1:
            D(A());  // here you call (execute) A
            break;

只需省略方法后面的括号：

        case 1:
            D(A);    // this passes a reference to A
            break;

现在您必须正确定义D：

void D(WaitCallback any)
{
      ThreadPool.QueueUserWorkItem(any);
}

---

是，您要使用代理：

public void CallbackDelegate();

private void D(CallbackDelegate D)
{
}

也许这会有帮助：

private void D(Delegate any)
        {    
            System.Threading.ThreadPool.QueueUserWorkItem(ignored => any.DynamicInvoke());
        }

---

我认为这将满足您的要求，但WaitCallback代理将对象作为参数

        private void A(object state)
    {
        // does one thing
    }

    private void B(object state)
    {
        // does a different thing
    }

    private void C(int i)
    {
        switch (i)
        {
            case 1:
                D(new System.Threading.WaitCallback(A));
                break;
            case 2:
                D(new System.Threading.WaitCallback(B));
                break;
            default:
                break;
        }
    }

    private void D(System.Threading.WaitCallback worker)
    { 
        System.Threading.ThreadPool.QueueUserWorkItem(worker);
    }

---

尝试使用像这里这样的委托。如果你有任何问题，请问我

using System;
using System.Threading;

namespace Thread.Pool.Test
{
    delegate void VoidDelegate (object obj);

    public class Delegate
    {
        /// <summary>
        /// ThreadPool Entry Point for A
        /// </summary>
        /// <param name='obj'>
        /// EventWaitHandle
        /// </param>
        /// <exception cref='ArgumentException'>
        /// Is thrown when an argument passed to a method is invalid.
        /// </exception>
        private void A (object obj) {
            if (!(obj is EventWaitHandle))
                throw new ArgumentException ("Only EventWaitHandle supported!");
            A ((EventWaitHandle)obj);
        }

        private void A (EventWaitHandle handle) {
            // does one thing

            //finsihed
            handle.Set ();
        }

        /// <summary>
        /// ThreadPool Entry Point for B
        /// </summary>
        /// <param name='obj'>
        /// EventWaitHandle
        /// </param>
        /// <exception cref='ArgumentException'>
        /// Is thrown when an argument passed to a method is invalid.
        /// </exception>
        private void B (object obj) {
            if (!(obj is EventWaitHandle))
                throw new ArgumentException ("Only EventWaitHandle supported!");
            B ((EventWaitHandle)obj);

        }

        private void B (EventWaitHandle handle) {
            // does a different thing

            //finsihed
            handle.Set ();
        }

        private void C (int i) {
            EventWaitHandle waitHandle = new ManualResetEvent (false);
            switch (i) {
            case 1:
                D (A ,waitHandle);
                break;
            case 2:
                D (B ,waitHandle);
                break;
            default:
                throw new Exception ("Case not supported");
            }
            //Wait for the thread to finish
            waitHandle.WaitOne ();
        }

        private void D (VoidDelegate any, EventWaitHandle waitHandle) { 
            ThreadPool.QueueUserWorkItem (new System.Threading.WaitCallback (any),waitHandle);
        }

    }
}

---

谢谢，这正是我需要的。编译器会为你把一个WaitCallbackA变成新的WaitCallbackA。是的，我只是一个老派。我想知道发生了什么事。不过我喜欢var类型，节省了时间，而且只是在清除。谢谢，当我有更多的时间时，我需要检查一下这个。