C# technique for generating anonymous delegates that share same closure variable

Question

I have a situation where I need to generate a few similar anonymous delegates. Here's an example:

public void Foo(AnotherType theObj)
{
    var shared = (SomeType)null;

    theObj.LoadThing += () =>
    {
        if(shared == null)
            shared = LoadShared();

        return shared.Thing;
    };

    theObj.LoadOtherThing += () =>
    {
        if(shared == null)
            shared = LoadShared();

        return shared.OtherThing;
    };

    // more event handlers here...
}

The trouble I'm having is that my code isn't very DRY. The contents of each of the event handlers is EXTREMELY similar, and could be easily parameterized into a factory method. The only thing preventing me from doing that is that each delegate needs to share the reference to the shared variable. I can't pass shared to a factory method with the ref keyword, as you can't create a closure around a ref varaiable. Any ideas?

You're returning something from even handlers? I think that's a really unusual thing to do, especially you can add more handlers to one event, and only the value of the last one will be used. Maybe a delegate property would be more suitable for you? — svick, Mar 24 '12 at 13:31
A delegate property can be invoked outside the class, which isn't what I want. The `event` semantics, where anyone can attach, but only the class can invoke, is what I need in this case. — FMM, Mar 26 '12 at 13:31
I think a write-only delegate property fits better. Although it's still quite weird. — svick, Mar 26 '12 at 16:19
I'd call a write-only property even stranger than an `event` that returns a value. A "setter" method would be much more idiomatic than a write-only property in C#, IMO. With the event model, you've got the option to, say, unhook the previous handler on attach, for instance. — FMM, Mar 26 '12 at 17:43

Eric Lippert · Accepted Answer · 2012-03-23T15:36:58.023

There's no problem that can't be solved by adding more abstraction. (*)

The pattern you are repeating over and over again is the "lazy loading" pattern. That pattern is highly amenable to being captured in a type, and in fact, it has been, in version 4 of the framework. Documentation here:

http://msdn.microsoft.com/en-us/library/dd642331.aspx

You could then do something like:

public void Foo(AnotherType theObj)
{
    var shared = new Lazy<SomeType>(()=>LoadShared());
    theObj.LoadThing += () => shared.Value.Thing;
    theObj.LoadOtherThing += () => shared.Value.OtherThing;
    // more event handlers here...
}

And there you go. The first time shared.Value is accessed the value gets loaded; every subsequent time the cached value is used. Extra bonus: this is even threadsafe should the shared value be accessed on multiple threads. (See the documentation for details about precisely what guarantees we make regarding thread safety.)

(*) Except of course for the problem "I have too much abstraction."

@phoog: The abstraction you need to solve the halting problem is traditionally called an "oracle". The problem is that oracles cannot be implemented using any craft we now possess. — Eric Lippert, Mar 23 '12 at 19:40

score 1 · Answer 2 · answered Mar 23 '12 at 15:16

Add an extra layer of indirection. Create a class that is just a wrapper for the data that you want to keep:

public class MyPointer<T>
{
  public T Value{get;set;}
}

New up a MyPointer<SomeType> at the start of the method and pass it into the factory. Now the MyPointer reference is copied by value, so you can't change the MyPointer instance, but you can change the Value in each of the factory methods and it is reflected elsewhere.

score 1 · Answer 3 · answered Mar 23 '12 at 15:19

1

How about:

public void Foo(AnotherType theObj)
{
    var shared = (SomeType)null;

    Action handler = () =>
    {
        if(shared == null)
            shared = LoadShared();

        return Shared.Thing;
    };

    theObj.LoadThing += handler;
    theObj.LoadOtherThing += handler;

    // more event handlers here...
}

You can also put the Action in a method and pass a parameter:

public void Foo(AnotherType theObj)
{
    var shared = (SomeType)null;

    theObj.LoadThing += () => Handle("LoadThing");
    theObj.LoadOtherThing += () => Handle("LoadOtherThing");

    // more event handlers here...
}

private T Handle<T>(T returnParameter)
{
    if(shared == null)
        shared = LoadShared();

    return returnParameter;
}

answered Mar 23 '12 at 15:19

Arcturus

26,677
10
92
107

That returns `Shared.Thing` for both handlers. – recursive Mar 23 '12 at 15:22
Changed the second example to reflect that – Arcturus Mar 23 '12 at 15:25
I still don't think that works. `T` is always `string`, and `returnParameter` is just `"LoadThing"` and `"LoadOtherThing"`, respectively, not a property from `shared`. – recursive Mar 23 '12 at 15:35
You are right. It only works if the return type is not a property of shared! – Arcturus Mar 23 '12 at 15:39

score 1 · Answer 4 · answered Mar 23 '12 at 15:24

1

I like Eric's method better, but here's another approach borne out of some kind of lisp fueled delirium I think.

var LoaderMaker = (Func<SomeType, int> thingGetter) => {
    return () => {
        if(shared == null) shared = LoadShared();
        return thingGetter(shared);
    };
};

theObj.LoadThing = LoaderMaker(t => t.Thing);
theObj.LoadOtherThing = LoaderMaker(t => t.OtherThing);

answered Mar 23 '12 at 15:24

recursive

83,943
34
151
241

The problem here is: what if Thing and OtherThing are not integers? – Eric Lippert Mar 23 '12 at 15:34
You replace `int` with whatever type they actually are. – recursive Mar 23 '12 at 19:42
and if one is an int and the other is a string? – Eric Lippert Mar 23 '12 at 19:46
Oh good point. Somehow I assumed they had to be the same. `dynamic`? :) – recursive Mar 23 '12 at 19:54

score 1 · Answer 5 · answered Mar 23 '12 at 15:28

I suggest putting the repetitive code in a separate function.

public void Foo(AnotherType theObj)
{
    var shared = (SomeType)null;

    Func<SomeType> getShared = () =>
    {
        if(shared == null)
            shared = LoadShared();
        return shared;
    };

    // Or more compact
    Func<SomeType> getShared = () => shared ?? (shared = LoadShared());

    theObj.LoadThing += () => getShared().Thing;

    theObj.LoadOtherThing += () => getShared().OtherThing;

    // more event handlers here...
}

C# technique for generating anonymous delegates that share same closure variable

5 Answers5