Chiama i metodi di sottoclasse durante l'iterazione sulla raccolta del tipo di base [duplicato]

Immagina questo codice:

using System;

public enum BaseClassType
{
    DerivedA,
    DerivedB
}

public abstract class BaseClass
{
    public BaseClassType Type;

    public BaseClass(BaseClassType type)
    {
        Type = type;
    }

    public virtual void Interact()
    {
        Console.WriteLine("BaseClass.Interact()");
    }
}

public class DerivedA : BaseClass
{
    public DerivedA() : base(BaseClassType.DerivedA) {}

    public void SomeMethodA(int signature0, float signature1)
    {
        Console.WriteLine("DerivedA.SomeMethodA");
    }
}

public class DerivedB : BaseClass
{
    public DerivedB() : base(BaseClassType.DerivedB) {}

    public void SomeMethodB(float signature0)
    {
        Console.WriteLine("DerivedB.SomeMethodB");
    }
}

public class Test
{
    public static void Main()
    {
        BaseClass[] elements = new BaseClass[] { new DerivedA(), new DerivedB() };
        foreach (var element in elements)
        {
            switch (element.Type)
            {
                case BaseClassType.DerivedA:
                    (element as DerivedA).SomeMethodA(5, 5f);
                    break;
                case BaseClassType.DerivedB:
                    (element as DerivedB).SomeMethodB(3f);
                    break;
            }
        }
    }
}

Mi chiedo quale sia il miglior modo OOP per sbarazzarsi di questo tipo di interruttore? Forse qualche schema? I metodi delle sottoclassi hanno firme completamente diverse, quindi non posso estrarlo e renderlo virtuale nella classe base.