Passing a stack variable as an event argument

Question

I have an event broker that exposes an EventHandler<T> that allows observers to inspect the event argument and, if needed, modify it. While this works okay, I would ideally like to ensure that T only lives on the stack and, furthermore, that no component is able to take a reference to T, thereby extending its lifetime.

public class Game // mediator pattern
{
  public event EventHandler<Query> Queries; // effectively a chain

  public void PerformQuery(object sender, Query q)
  {
    Queries?.Invoke(sender, q);
  }
}

Sadly, a ref struct cannot be used as a generic argument:

ref struct Query {} // EventHandler<Query> not allowed

And similarly I cannot imbue EventHandler's TEventArgs with any sort of 'use structs, pass by reference' mechanics.

Now, in C#, we can decide whether variables live on the stack on the heap, e.g. with stackalloc and such, so what I'm after, I guess, is just a way of getting something equivalent to a ref struct inside an event.

I'm pretty sure you don't get to decide this. Where variables live is an implementation detail in c#. — Robert Harvey, Mar 10 '20 at 18:06
Ok, if you really want to extend lifetime, consider a mechanism like an object pool or an ioc container that has lifetime management features. — Robert Harvey, Mar 10 '20 at 18:08
Also, this might work out better if you describe the actual problem you're trying to solve, rather than your attempt to solve it. — Robert Harvey, Mar 10 '20 at 18:10
The stackalloc you refer to is intended for temporary allocations inside methods, not persistent state storage. — Robert Harvey, Mar 10 '20 at 20:36
I *don't* want persistent state storage. That's the whole point. A query gets thrown around the app, then it gets destroyed. I want exactly that. — Dmitri Nesteruk, Mar 10 '20 at 20:39
And an ordinary object won't suffice for that? Why would something like that need to be stored on the stack? — Robert Harvey, Mar 10 '20 at 20:41
See also [Why ref structs cannot be used as type arguments?](https://stackoverflow.com/q/50871135) — Peter Duniho, Mar 10 '20 at 20:57

Eugene Podskal · Answer 1 · 2020-03-10T21:52:28.617

While stackalloc applied/wrapped in a very convoluted way may (probably) give you some semblance of variables live on the stack on the heap, it will not be what stackalloc is intended for.

So I'd rather propose to concentrate on the no component is able to take a reference to T, thereby extending its lifetime part.

To get it we need

Wrapper class (probably, but not necessary with corresponding interface)
Implementing IDisposable
And storing the actual T as WeakReference

It will be something like

public interface ITakeNoRefClass
{
    void Change(string value);
}

public class TakeNoRefClass : ITakeNoRefClass
{
    ...
}

public class TakeNoRefClassWrapper : ITakeNoRefClass, IDisposable
{
    private bool _isDisposed;
    private readonly WeakReference<TakeNoRefClass> _takeNoRefWeakRef;

    public TakeNoRefClassWrapper(WeakReference<TakeNoRefClass> takeNoRefWeakRef)
    {
        _takeNoRefWeakRef = takeNoRefWeakRef;
    }

    public void Change(string value)
    {
        Execute(o => o.Change(value));
    }

    private void Execute(Action<ITakeNoRefClass> action)
    {
        if (_disposed)
        {
            throw new ObjectDisposedException("You should not have taken this ref");
        }
        var target = _takeNoRefWeakRef.Target;
        if (target == null)
        {
            throw new ObjectDisposedException("You should not have taken this ref");
        }
        action(target);
    }

    public void Dispose()
    {
        _isDisposed = true;
    }
}

And it should be used like

public void CreateObjectAndRaiseEvents()
{
    var target = new TakeNoRefClass();
    // Passing it into a separate method to ensure that it won't be GC'ed before executing all event handlers.
    RaiseEvents(target);
}

private void RaiseEvent(TakeNoRefClass target)
{
    using (var wrapper = new TakeNoRefClassWrapper(new WeakReference<TakeNoRefClass>(target))
    {
        _event?.Invoke(wrapper);
    }
}

Passing a stack variable as an event argument

1 Answers1