Implement extensibility on callback?

Question

Currently, I am working on an API, and developers can subscribe to it to know the updates.

So right now I am implementing an interface IResult , so that I can send different parameters in the callback result. The problem right now is if in the future, I want to add a new callback, I have to add an argument in the method, and developers also need to change their method call. Is there a good solution for this?

public interface IResult
{
    int i { get; set; }
}

public class ConcreteResult : IResult
{
    public int i
    {
        get;set;
    }
}


public class MyAPI
{
    public delegate void MyAPIDelegate(IResult result);

    public void StartService(MyAPIDelegate callback, MyAPIDelegate callback2)
    {
        //step 1
        int i = 0;
        ConcreteResult result1 = new ConcreteResult();
        result1.i = i;
        callback(result1);
        //step 2
        i += 1;
        ConcreteResult result2 = new ConcreteResult();
        result2.i = i;
        callback2(result2);
        //potentially added in the future
        //i += 1;
        //callback3();
    }

    public void main()
    {
        //developers use my API
        StartService(developerCallback, developerCallback2);
    }
    private void developerCallback(IResult result)
    {
        Console.WriteLine(result.i);
    }
    private void developerCallback2(IResult result)
    {
        Console.WriteLine(result.i);
    }
}

Answer 1

I strongly recommend using events, like @Vikhram suggested, but here is your example, modified to use a class as you requested.

Notice that I did not specify a Callback3 when calling the function. The API uses .? when calling them, instead of just ., so that it doesn't cause a NullReferenceException if the developer doesn't pass one in.

When you add more callbacks, just add additional properties to MyCallbackInfo, and invoke them the same as the existing ones.

public interface IResult {... }

public class ConcreteResult : IResult {...}

public class MyStartServiceCallbackInfo
{
    public MyAPI.MyAPIDelegate Callback1 { get; set; }
    public MyAPI.MyAPIDelegate Callback2 { get; set; }
    public MyAPI.MyAPIDelegate Callback3 { get; set; }
}

public class MyAPI
{
    public delegate void MyAPIDelegate(IResult result);

    public void StartService(MyStartServiceCallbackInfo callbacks)
    {
        ...
        callbacks?.Callback1(result1);
        ...
        callbacks?.Callback2(result2);
        ...
        callbacks?.Callback3(result3);
    }

    public void main()
    {
        StartService(new MyCallbackInfo()
        {
            Callback1 = developerCallback,
            Callback2 = developerCallback2,         
        });
    }

    private void developerCallback(IResult result)
    {
        Console.WriteLine(result.i);
    }

    private void developerCallback2(IResult result)
    {
        Console.WriteLine(result.i);
    }
}

Answer 2

Oddly everyone is recommending events, but nobody is showing an example. I'll bite.

Judging by the naming conventions I'm guessing you come from Java land. (C# methods are generally PascalCase). C# has events, which make things like this much simpler. I recommend you study them up, as they're quite common in C# code.

All you have to do is define a public event on your class, and have that class invoke the event where necessary. (do ?. because an unsubscribed event is weirdly null).

Then from the consuming class, you subscribe handlers for it using +=.

This allows you to add new events in the future without your consumers having to worry about it.

public class MyAPI
{
    public event Action<IResult> Callback1;

    public event Action<IResult> Callback2;

    public void StartService()
    {
        //step 1
        int i = 0;
        ConcreteResult result1 = new ConcreteResult();
        result1.i = i;
        Callback1?.Invoke(result1);
        //step 2
        i += 1;
        ConcreteResult result2 = new ConcreteResult();
        result2.i = i;
        Callback2?.Invoke(result2);
        //potentially added in the future
        //i += 1;
        //callback3();
    }
}

public static class Program { 
    public static void Main()
    {
        //developers use my API
        var api = new MyAPI();
        api.Callback1 += DeveloperCallback;
        api.Callback2 += DeveloperCallback2;

        api.StartService();
    }
    private static void DeveloperCallback(IResult result)
    {
        Console.WriteLine(result.i);
    }
    private static void DeveloperCallback2(IResult result)
    {
        Console.WriteLine(result.i);
    }
}

Also for simple event handlers, you can subscribe inline:

api.Callback1 += result =>
    {
        Console.WriteLine(result.i);
    };

Or even simpler for one-liners:

api.Callback1 += result => Console.WriteLine(result.i);

Since you asked, another option a bit more heavier than simple events, but eventually more powerful is Reactive Extensions. If you want to use these, then you can write code like this:

using System.Reactive.Subjects;

public class MyAPI
{
    private readonly Subject<IResult> callback1 = new Subject<IResult>();

    private readonly Subject<IResult> callback2 = new Subject<IResult>();

    public void StartService()
    {
        //step 1
        int i = 0;
        ConcreteResult result1 = new ConcreteResult();
        result1.i = i;
        callback1.OnNext(result1);
        //step 2
        i += 1;
        ConcreteResult result2 = new ConcreteResult();
        result2.i = i;
        callback2.OnNext(result2);
    }

    public IObservable<IResult> Callback1 => this.callback1;

    public IObservable<IResult> Callback2 => this.callback2;
}

public static class Program
{
    public static void Main()
    {
        var api = new MyAPI();

        // Subscribing returns a disposable subscription, and disposing it unsubscribes.
        // That means you can use lambda syntax and still unsubscribe later
        IDisposable subscription =
            api.Callback1.Subscribe(result => Console.WriteLine(result.i)); 
        api.StartService(); // Writes result.

        // Once disposed, event is no longer called
        subscription.Dispose();
        api.StartService(); // Doesn't write result.

        // Since IDisposable is a special thing that can be scoped to using blocks in C#, you can do the following:
        using (api.Callback1.Subscribe(result => Console.WriteLine(result.i)))
        {
            api.StartService(); // Writes result
        }
        api.StartService(); // Doesn't write result

    }
}