Question

I’m trying to expose an API such that, I do the following

RegisterCallback<T>(Action<T> func)
{
    someObj.FuncPointer = func;
}

Later on, I call func(obj) .. and the obj is of type T that the user said.

More concrete example:

var callbackRegistrar = new CBRegistrar();
callbackRegistrar.RegisterCallback<ISomeClass>(SomeFunc);

public static void SomeFunc(ISomeClass data)
{
    //
}

EDIT: So I may not have been clear, so I’ll add more code:

I want to make only “one” object of CBRegistrar, and connect it with many Callbacks, as such:

var callbackRegistrar = new CBRegistrar();
callbackRegistrar.RegisterCallback<ISomeClass>(SomeFunc);
callbackRegistrar.RegisterCallback<ISomeOtherClass>(SomeFunc2);
...

In fact the above code is called by reflecting over a directory of plugins.

The user puts this in their code –>

public static void SomeFunc(ISomeClass data)
{
    //
}

public static void SumFunc2(ISomeOtherClass data)
{
    //
}

It looks to me as if this is not possible using Generics, etc. What it looks like I might have to do is make an interface called IPlugin or something, and ask the user to do this ..

[PluginIdentifier(typeof(ISomeClass))]
public static void SomeFunc(IPluginData data)
{
    var castedStuff = data as ISomeClass; // ISomeClass inherits from IPluginData
}

Seems like asking the user to do stuff that we should take care of, but anyway …

Answer 1

You need a Action<T> func to store it in. There is a semantic check to make here: if someone calls RegisterCallback twice (with different values), do you want to replace the callback, or keep both ? Assuming the latter, someObj probably wants an event (indeed, this entire API could be exposed as an event), so – in the someObj class:

public event Action<T> FuncPointer;
private void InvokeCallback(T data) {
    var handler = FuncPointer;
    if(handler != null) handler(data);
}

Noting that RegisterCallback could be replaced entirely, still keeping the data on obj:

public event Action<T> Completed {
    add { obj.FuncPointer += value; }
    remove { obj.FuncPointer -= value; }
}

Then usage would be:

var callbackRegistrar = new CBRegistrar();
callbackRegistrar.Completed += SomeFunc;