Question

In my program, there is a place when I need to access a singleton resolved from a factory and attach to its event:

void MyMethod()
{
   myFactory.Resolve<MySingleton>().DoWork += WorkMethod;
}

The problem is that MyMethod can be executed multiple times, but I want to attach to event only once (otherwise I ll get multiple calls). So I want to attach only when I wasn t attached before. It there anything nicier than

   myFactory.Resolve<MySingleton>().DoWork -= WorkMethod;
   myFactory.Resolve<MySingleton>().DoWork += WorkMethod;

Answer 1

What about some flag to remember if MyMethod has already been called for the singleton?

object myCachedSingleton = null;

void MyMethod()
{
    var s = myFactory.Resolve<MySingleton>();
    if (myCachedSingleton == s) return;
    myCachedSingleton = s;
    myCachedSingleton.DoWork += WorkMethod;
}

Answer 2

Depending on how coupled you want these types to be, you could attach to the event in a static constructor. Then it would only be possible to get executed a single time (per AppDomain I think). Something like this:

public class MyConsumer
{
    static MyConsumer()
    {
        Factory.Resolve<Singleton>().DoWork += WorkMethod;
    }

    private static void WorkMethod(...) { ... }
}

The (over) use of static methods is a little off-putting, but depending on your requirements that may be ok.

I ll just add that the other answers here are also fine, but make sure you think about any threading issues.

Answer 3

You could also look into the InvocationList to see if anything has been attached to the event.

Edited to use an Action so you don t need to pass in some magic string.

Example:

public bool IsAttached(Action<string> methodToCheck)
{
    SomeWork completed = DoWork;
    return completed.GetInvocationList().Any(m => m.Method.Name == methodToCheck.Method.Name);
}

Usage:

    var b = new FooBar();
    b.DoWork += b_OnWorkCompleted;
    b.DoWork += c_OnWorkCompleted;

    Console.WriteLine(b.IsAttached(c_OnWorkCompleted));
    Console.WriteLine(b.IsAttached(b_OnWorkCompleted));
    Console.WriteLine(b.IsAttached(FooBar));

Output would be true, true, false

Answer 4

I just want to put the approach I used in the question for voting, too - if you disagree, vote it down...

Is there anything wrong with

var singleton = myFactory.Resolve<MySingleton>();
singleton.DoWork -= WorkMethod;   
singleton.DoWork += WorkMethod;

???

友情链接