¿Hay un nombre para este patrón? (C # tiempo de compilación tipo-seguridad con argumentos "params" de diferentes tipos)

¿Hay un nombre para este patrón?

Supongamos que desea crear un método que tome un número variable de argumentos, cada uno de los cuales debe ser uno de un conjunto fijo de tipos (en cualquier orden o combinación), y algunos de esos tipos no tiene control. Un enfoque común sería hacer que su método tome argumentos de tipo Object y valide los tipos en tiempo de ejecución:

void MyMethod (params object[] args)
{
    foreach (object arg in args)
    {
        if (arg is SomeType)
            DoSomethingWith((SomeType) arg);
        else if (arg is SomeOtherType)
            DoSomethingElseWith((SomeOtherType) arg);
        // ... etc.
        else throw new Exception("bogus arg");
    }
}

Sin embargo, digamos que, como yo, estás obsesionado con la seguridad de los tipos en tiempo de compilación y quieres poder validar los tipos de argumentos de tu método en tiempo de compilación. Aquí hay un enfoque que se me ocurrió:

void MyMethod (params MyArg[] args)
{
    // ... etc.
}

struct MyArg
{
    public readonly object TheRealArg;

    private MyArg (object obj) { this.TheRealArg = obj; }

    // For each type (represented below by "GoodType") that you want your 
    // method to accept, define an implicit cast operator as follows:

    static public implicit operator MyArg (GoodType x)
    { return new MyArg(x); }

}

Las conversiones implícitas le permiten pasar argumentos de tipos válidos directamente a su rutina, sin tener que emitirlos o ajustarlos explícitamente. Si intenta pasar un valor de un tipo inaceptable, el error se detectará en el momento de la compilación.

Estoy seguro de que otros han utilizado este enfoque, por lo que me pregunto si hay un nombre para este patrón.