Struct implementing interface function without boxing

Background

I want to allow a class instance to register callbacks with an event system while avoiding boxing.

A bit of background: I have a home-grown Event System structured as shown below:

class EventSystem
{
    // registers a struct instance with an event
    // when the event triggers, it calls the run() method and passes in some info
    public void Register(ICallback callbackStruct, Event e);
}

public enum Event
{
    SOME_EVENT,
    SOME_OTHER_EVENT
}

interface ICallback
{
   void Run(string data);
}

An example implementation of this is:

class Example
{
    private Behaviour_A a = new Behaviour_A();
    private Behaviour_B b = new Behaviour_B();

    public Example()
    {
        eventSystem.Register(a, SOME_EVENT);
        eventSystem.Register(b, SOME_OTHER_EVENT);
    }

    struct Behaviour_A : ICallback
    {
        void Run(string data)
        {
            // some behvaiour
        }
    }

    struct Behaviour_B : ICallback
    {
        void Run(string data)
        {
            // some other behvaiour
        }
    }

}

Pros

I like this solution because it makes use of composition rather than inheritance (and also supports multiple callback behaviours for the same event in one instance), and I'd prefer to use structs over anonymous functions since they are stateful and might be re-used with different parameters and a few other reasons.

Cons

However, I dislike this solution because it requires boxing each time the struct is passed around and I'm trying to avoid heap allocations as much as possible.

Question

Is there any way I can implement custom behaviouron a struct as shown while avoiding boxing?

The key to avoiding boxing when using structs that implement interfaces is to use interface-constrained generics.

If one has a function that receives an argument of type T, where T is constrained to IEquatable<T>, then the .NET runtime will generate a separate machine code version of that function for every distinct structure type that is passed to it, and within those machine-code versions of the function no boxing will be required.

It's not a answer but just a suggestion . Decoupling Data and Behaviour , it's more clean design. and make sure Register param is a class. this way is good to handle boxing by you self. maybe use object pool or something. This way can handle unnecessary GC.

public class EventSystem
{
    // here make sure T is a class , not struct.
    public void Register<T>(T callbackStruct, Event e) where T : class , ICallback
    {
    }
}

public enum Event
{
    SOME_EVENT,
    SOME_OTHER_EVENT
}

public interface ICallback
{
    void Run(string data);
}

class Example
{
    private Behaviour_A a = new Behaviour_A();
    private Behaviour_B b = new Behaviour_B();

    public Example()
    {
        EventSystem eventSystem = new EventSystem();

        staticAObj.PutData(a);
        eventSystem.Register(staticAObj, Event.SOME_EVENT);
        eventSystem.Register(b, Event.SOME_OTHER_EVENT);
    }

    struct A
    {
    }
    struct B
    {
    }

    class Behaviour_A : ICallback
    {
        A a;
        public void Run(string data)
        {
            // some behvaiour
        }
    }

    class Behaviour_B : ICallback
    {
        B b;
        public void Run(string data)
        {
            // some other behvaiour
        }
    }

}

Unless I missed something obvious, your registration method should just add the ref modifier:

public void Register(ref ICallback callbackStruct, Event e);

This guarantees your structure will not be copied on the stack because only the reference will be copied, and your original struct can be used through that. The heap remains intact.

You will have to modify the callsite:

eventSystem.Register(ref a, SOME_EVENT);
eventSystem.Register(ref b, SOME_OTHER_EVENT);

And, based on Guru's comments, this might be a solution: further modify the signature to

void Register<T>(ref T callbackStruct, Event e) where T : ICallback;

or

void Register<T>(ref T callbackStruct, Event e) where T : struct, ICallback;

to remove the box, but you're possibly adding brittleness to this code.

For yourEventSystem to register this it would need to be either non-abstract and provide the method below, or it would need a subclass that implements

public void Register<T>(ref T callbackStruct, Event e) where T : struct, ICallback
{}