protected generic type aliases in classes

[Gallimathias]

If you have an architecture that uses a handful of generics, you quickly come to the point that their use quickly becomes confusing and incomprehensible, especially due to long class names.

Generally, there is already the possibility to use aliases for types, but not for generics, and not even within a type.

As an example I have a static type of a TestFramework

The static class

public static class Fixture<TSystemUnderTest, TInput, TOutput, TExternalInput, TExternalOutput>
{
    public static void Run(Scenario scenario, Func<IObservable<TInput>, Func<TExternalInput, TExternalOutput>, IObservable<TOutput>> factory)
    {
        var inputs = new Subject<TInput>();
        
        //Do inital THings

        var sut
            = factory(inputs, CreateExternalDepedencys);
        
        //DO Test things
    }
}

If I now want to use this type within a class, it quickly becomes messy.

public sealed class TestFixture
{
    public static void Run(Scenario scenario)
    {        
        //Do inital THings

        Fixture<MyAwesomeType, Commands, Notifications, HttpRequestMessage, HttpResponseMessage>
        .Run(scenario, CreateNewSystemUnderTest)
        //DO Test things
    }
}

There are two simpler options.

Possibility A, declare the alias directly with the corresponding types.

public sealed class TestFixture
{
    using static Fixture = MyNamespace.Fixture<MyAwesomeType, Commands, Notifications, HttpRequestMessage, HttpResponseMessage>;

    public void Run(Scenario scenario)
    {        
        //Do inital THings

        Fixture.Run(scenario, CreateNewSystemUnderTest)
        //DO Test things
    }
}

Option B, write a base class that can pass the generics directly to the alias. Since the aliases would be protected and visible, all inheriting classes could use the alias.

public abstract class TestFixture<TSystemUnderTest, TInput, TOutput, TExternalInput, TExternalOutput>
{
    using static Fixture = MyNamespace.Fixture<TSystemUnderTest, TInput, TOutput, TExternalInput, TExternalOutput>;

    public  void Run(Scenario scenario)
    {        
        //Do inital THings

        Fixture.Run(scenario, CreateNewSystemUnderTest)
        //DO Test things
    }
}
public sealed class MyTestFixture : TestFixture<MyAwesomeType, Commands, Notifications, HttpRequestMessage, HttpResponseMessage>
{
    public void DoSetupThingsRun()
    {        
        //Do Crazy things

        Fixture.DoOtherAwesomeStuff();
    }
}

Especially in the example shown here, generalisation can make the problem much worse by adding at least one more external input and output pair. The aliases make the readability much easier.

[ufcpp]

related to #218