Is there a way to get a list of types that i can use in Generic Methods?

Question

Hi so what I wanted is something along the lines of, is it possible in c#? ~

(and without using reflection?)

Current:

    protected override void AddTelegrams()
    {
         TelegramPublisher.Subscribe<Telegram1>(TelegramReceived);
         TelegramPublisher.Subscribe<Telegram2>(TelegramReceived);
         TelegramPublisher.Subscribe<Telegram3>(TelegramReceived);
    }

    protected override void RemoveTelegrams()
    {
         TelegramPublisher.UnSubscribe<Telegram1>(TelegramReceived);
         TelegramPublisher.UnSubscribe<Telegram2>(TelegramReceived);
         TelegramPublisher.UnSubscribe<Telegram3>(TelegramReceived);
    }

Objective:

    private IEnumerable<Type> GetListTelegramTypes()
    {
        return new List<Type>()
        {
            typeof(Telegram1),
            typeof(Telegram2),
            typeof(Telegram3)
        };
    }

    protected override void AddTelegrams()
    {
        foreach (var type in GetListTelegramTypes())
            TelegramPublisher.Subscribe<type>(TelegramReceived);
    }

    protected override void RemoveTelegrams()
    {
        foreach (var type in GetListTelegramTypes())
            TelegramPublisher.UnSubscribe<type>(TelegramReceived);
    }

Also Subscribe and Unsubscribe generic type mas be or inherit from "Telegram"...

Answer 1

If you don't want to use reflection, you can do something like:

public interface ITelegramSubscriber
{
    void Subscribe(TelegramReceivedHandler handler);
    void Unsubscribe(TelegramReceivedHandler handler);
}

public class TelegramSubscriber<T> : ITelegramSubscriber
{
    public void Subscribe(TelegramReceivedHandler handler) =>
        TelegramPublisher.Subscribe<T>(handler);
    public void Unsubscribe(TelegramReceivedHandler handler) =>
        TelegramPublisher.Unsubscribe<T>(handler);
}

Then:

private IEnumerable<ITelegramSubscriber> GetListTelegramSubscribers()
{
    return new List<ITelegramSubscriber>()
    {
        new TelegramSubscriber<Telegram1>(),
        new TelegramSubscriber<Telegram2>(),
        new TelegramSubscriber<Telegram3>(),
        new TelegramSubscriber<Telegram4>(),
    };
}

protected override void AddTelegrams()
{
    foreach (var subscriber in GetListTelegramSubscribers())
        subscriber.Subscribe(TelegramReceived);
}

protected override void RemoveTelegrams()
{
    foreach (var subscriber in GetListTelegramSubscribers())
        subscriber.Unsubscribe(TelegramReceived);
}

---

This assumes that you have one TelegramReceivedHandler method type which handles all telegrams. If you in fact have multiple overloads (it isn't clear from your question), then you probably want something like:

public interface ITelegramSubscriber
{
    void Subscribe();
    void Unsubscribe();
}

public class TelegramSubscriber<T> : ITelegramSubscriber
{
    private readonly TelegramReceivedHandler<T> handler;
    public TelegramSubscriber(TelegramReceivedHandler<T> handler) => this.handler = handler;
 
    public void Subscribe() => TelegramPublisher.Subscribe<T>(handler);
    public void Unsubscribe() => TelegramPublisher.Unsubscribe<T>(handler);
}

Then:

private IEnumerable<ITelegramSubscriber> GetListTelegramSubscribers()
{
    return new List<ITelegramSubscriber>()
    {
        new TelegramSubscriber<Telegram1>(TelegramReceived),
        new TelegramSubscriber<Telegram2>(TelegramReceived),
        new TelegramSubscriber<Telegram3>(TelegramReceived),
        new TelegramSubscriber<Telegram4>(TelegramReceived),
    };
}

protected override void AddTelegrams()
{
    foreach (var subscriber in GetListTelegramSubscribers())
        subscriber.Subscribe();
}

protected override void RemoveTelegrams()
{
    foreach (var subscriber in GetListTelegramSubscribers())
        subscriber.Unsubscribe();
}