Deux questions à propos de AsyncCallback et modèle IAsyncResult

Permettez-moi de vous donner cet exemple de code pour rendre les choses un peu. Veuillez créer une nouvelle application console et utiliser ce

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();
}
}

Comme vous pouvez le voir, la fonction de rappel (MyCallBack) obtient un objet IAsyncResult passé. C'est ce IAsynchResult objet dont AyncState vous donne l'objet d'origine tu avais passé dans la méthode BeginInvoke appel. Dans ce cas, (et en général) vous pouvez passer le délégué lui-même comme l'objet (qui est la variable appelée "fonction").
Un rappel a été appelé, je puis a obtenu le délégué d'origine de l'objet en arrière par quering l'ei.AsyncState, j'ai alors appelé EndInvoke sur elle pour obtenir le résultat en retour.

Comme pour le point d'arrêt ne pas être frappé, j'ai peur, j'ai besoin de plus d'informations sur elle. Que voulez-vous dire exactement? Où est cette Console.WriteLine déclaration?

NOUVELLE RÉPONSE
OK, voici ma version de votre code. Fondamentalement, n'importe où vous appelez la EndInvoke, vous devez appeler le délégué de l'objet (dans votre cas, la "fonction" de la variable à instancier, en lui passant le réel objet IAsyncResult). Le code que vous avez est d'essayer de masquer cette installation mais je dois dire qu'il y a de moins en moins compliqué façons de le faire. Je serai plus qu'heureux d'écrire un wrapper de toutes sortes pour vous si vous le souhaitez. Pour l'instant, je suis simplement en vous donnant votre code de retour avec mon petit plus, qui devrait le faire fonctionner. Puisque vous utilisez le niveau de la classe de variables donc je suis obligé d'utiliser un moi-même. Ce n'est pas vraiment thread-safe pour le moment. Mais voilà

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);
}

OriginalL'auteur Nikhil