Encapsualting an event into a method?

Question

Let's say, I can not modify class A.

I have this in class A<T>: There is a JumpNext() method:

public void JumpNext();

It fires an event in class A<T>, called Next

And this in my class B:

public T Next()
{
    instanceofA.JumpNext();
    //instanceofA.Next += something;
    // wait for event
    // someting(object sender, AEventArgs e)
    //return e.Entry
}

The problem is, that my Next method has to return the instance of T contained in the Entry filed of AEventArgs returned by the A.Next event.

So How can I do this inside one method in class B?

I'm using .net 2.0, but if it is indeed possible in any later version only, that might be fine also.

Thx

Answer 1

You could do something like that :

    public void T Next()
    {
        T value = default(T);
        EventHandler<AEventArgs> handler = new EventHandler<AEventArgs>(delegate(object sender, AEventArgs e) { value = e.Entry; });
        instanceofA.Next += handler;
        instanceofA.JumpNext();
        instanceofA.Next -= handler;
        return value;
    }

Answer 2

If I understand your question correctly, you want to handle the A.Next event inside the B.Next() method. You can do that with an anonymous method, but you must be careful not to register the event handler more than once:

Say the Next event is defined as a delegate declared thusly:

public delegate vote NextHandler(object sender, AEventArgs e);

you could do:

public T Next()
{
    T entry;
    NextHandler handler = delegate(object sender, AEventArgs e) {
        entry = e.entry;
    }

    instanceOfA.Next += handler;
    try {
        instanceOfA.JumpNext();
    } finally {
        instanceOfA -= handler;
    }

    return entry;
}

Answer 3

I did the combination of the two, it seems to be ok now, thx again.

  public T Next()
    {
        T entry = default(T);
        EventHandler<AEventArgs> handler = delegate(object sender, AEventArgs e)
        { entry = e.Entry; };
        instanceofA.Next+= handler;
        try
        {
            instanceofA.JumpNext();
        }
        finally
        {
            instanceofA.Next-= handler;
        }
        return entry;
    }