关于 AsyncCallback 和 IAsyncResult 的回调模式的两个问题。

我用代码示例更改了问题:

using System;
using System.Collections.Generic;
using System.Text;

namespace TestAsync
{
    class Program
    {
        private static Wrapper test = new Wrapper();

        static void Main(string[] args)
        {
            test.BeginMethod("parameter 1", "parameter 2", Callback);
            Console.ReadKey();
        }

        private static void Callback(IAsyncResult ar)
        {
            string result = test.EndMethod(ar);
        }
    }

    public interface ITest
    {
        IAsyncResult BeginMethod(string s1, string s2, AsyncCallback cb, object state);
        string EndMethod(IAsyncResult result);
    }

    public class Wrapper
    {
        private ITest proxy = new Test();

        public void BeginMethod(string s1, string s2, AsyncCallback cb)
        {
            proxy.BeginMethod(s1, s2, cb, proxy);
        }

        public string EndMethod(IAsyncResult result)
        {
            return ((ITest)(result.AsyncState)).EndMethod(result);
        }
    }

    public class Test : ITest
    {
        private string WorkerFunction(string a, string b)
        {
            // "long running work"
            return a + "|" + b;
        }

        public IAsyncResult BeginMethod(string s1, string s2, AsyncCallback cb, object state)
        {
            Func<string, string, string> function = new Func<string, string, string>(WorkerFunction);
            IAsyncResult result = function.BeginInvoke(s1, s2, cb, state);
            return result;
        }

        public string EndMethod(IAsyncResult result)
        {
            return (string)(result.AsyncState);
        }
    }

    public delegate TResult Func<T1, T2, TResult>(T1 t1, T2 t2);
}

开始编辑
我开始明白发生了什么。 我混淆了 WCF 异步模式和普通异步模式。 在 WCF 中，使用代理并且 Begin- 和 EndMethod 必须通过代理而不是函数委托(delegate)。在 WCF 情况下，转换有效，在正常情况下则无效。 WCF 使用 [OperationContract(AsyncPattern = true)] 属性可能会强制实现一种稍微不同的模式。 结束编辑

为什么 return (string)(result.AsyncState); 行会出错？
生产代码中完全相同的模式是可以的。

其次，为什么不能调试Test类的BeginMethod中的代码？
我只能在 WorkerFunction 中打断。

最佳答案

让我给你这个示例代码，让事情变得更清楚。请创建一个新的控制台应用程序并使用它

public class Test
{
    private int WorkerFunction(string a, string b)
    {
        //this is the guy that is supposed to do the long running work 
        Console.WriteLine(a);
        Console.WriteLine(b);
        return a.Length + b.Length;
    }

    private void MyCallBack(IAsyncResult ar)
    {
        Func<string, string, int> function = ar.AsyncState as Func<string, string, int>;
        int result = function.EndInvoke(ar);
        Console.WriteLine("Result is {0}", result);
    }
    public void CallMethod()
    {
        Func<string, string, int> function = new Func<string, string, int>(WorkerFunction);
        IAsyncResult result = function.BeginInvoke("param1", "param2", MyCallBack, function);
    }


}

class Program
{

    static void Main(string[] args)
    {
        Test test = new Test();
        test.CallMethod();
    }
}

如您所见，回调函数 (MyCallBack) 获取传回给它的 IAsyncResult 对象。正是这个 IAsynchResult 对象的 AyncState 为您提供了您在 BeginInvoke 方法调用中传递的原始对象。在这种情况下(并且作为一般做法)，您将委托(delegate)本身作为对象(这是称为“函数”的变量)传递。 回调被调用后，我通过查询 ar.AsyncState 取回了原始委托(delegate)对象，然后调用了 EndInvoke 以取回结果。

至于断点没有被击中，恐怕我需要更多的信息。你到底什么意思？这个 Console.WriteLine 语句在哪里？

新回应 好的，这是我的代码版本。基本上，无论您从何处调用 EndInvoke，都需要在实际的委托(delegate)对象上调用它(在您的例子中是您实例化的“函数”变量，将其传递给实际的 IAsyncResult 对象)。您拥有的代码试图掩盖此功能，但是我必须说，执行此操作的方法不那么复杂。如果您愿意，我将非常乐意为您编写各种 wrapper 。现在，我只是将您的代码返回给您，并在其中添加了少量内容，这应该可以使它正常工作。由于您使用的是类级别变量，因此我不得不自己使用一个。目前这并不是真正的线程安全。但是这里是

using System;
using System.Collections.Generic;
using System.Text;

namespace TestAsync
{
    class Program
    {
        private static Wrapper test = new Wrapper();

        static void Main(string[] args)
        {
            var objectState = new object();
            test.BeginMethod("parameter 1", "parameter 2", Callback, objectState);
            Console.ReadKey();
        }

        private static void Callback(IAsyncResult ar)
        {
            string result = test.EndMethod(ar);
            Console.WriteLine(result);
        }
    }

    public interface ITest
    {
        IAsyncResult BeginMethod(string s1, string s2, AsyncCallback cb, object state);
        string EndMethod(IAsyncResult result);
    }

    public class Wrapper
    {
        private ITest proxy = new Test();

        public void BeginMethod(string s1, string s2, AsyncCallback cb)
        {
            proxy.BeginMethod(s1, s2, cb, proxy);
        }

        public string EndMethod(IAsyncResult result)
        {
            return ((ITest)(result.AsyncState)).EndMethod(result);
        }
    }

    public class Test : ITest
    {
        Func<string, string, string> _delgateObject;
        private string WorkerFunction(string a, string b)
        {
            // "long running work"
            return a + "|" + b;
        }

        public IAsyncResult BeginMethod(string s1, string s2, AsyncCallback cb, object state)
        {
            Func<string, string, string> function = new Func<string, string, string>(WorkerFunction);
            this._delgateObject = function;
            IAsyncResult result = function.BeginInvoke(s1, s2, cb, state);
            return result;
        }

        public string EndMethod(IAsyncResult result)
        {
            var test = result.AsyncState;
            return this._delgateObject.EndInvoke(result);
        }
    }

    public delegate TResult Func<T1, T2, TResult>(T1 t1, T2 t2);
}

关于c# - 关于 AsyncCallback 和 IAsyncResult 模式的两个问题，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/5089095/