Pattern matching on a generic type argument

[FLAMESpl]

Not long ago in c# abstract static methods were introduced which allows us to do this:

public interface IService
{
    static abstract void DoAdditionalWork();
}

public class MyService
{
    public static void DoAdditionalWork()
    {
        ...
    }
}

public class Helper
{
    public void DoWork<T>() where T : IService
    {
         T.DoAdditionalWork();
    }
}

however, sometimes when I design methods I do not want them to be restricted to specific interface and apply this logic conditionally. I am looking into something like this:

public class Helper
{
    public void DoWork<T>()
    {
        // some other work
        
        if (T is IService) // invalid code currently
            T.DoAdditionalWork();
    }
}

I know I can do everything with reflection, but I hope to get some less noisy and safe at compile time solution. It wouldn't be that issue if I could overload methods by generic constraints like this:

public class Helper
{
    public void DoWork<T>()
    {
        DoCommonWork<T>();
    }

    public void DoWork<T>() where T : IService
    {
        DoCommonWork<T>();
        T.DoAdditionalWork();
    }
 
    private void DoCommonWork<T>()
    {
        ...
    }
}

any thoughts?

[HaloFour]

See: #6308

[KennethHoff]

It feels like half of all discussions being made to this repository is about this exact topic, which goes to show it is (for lack of a better word) a wart in the language.

It's also a highly complex problem, so it's natural that it takes a while to happen.