Existe um nome para esse padrão?

Digamos que você queira criar um método que utilize um número variável de argumentos, cada um dos quais deve ser um de um conjunto fixo de tipos (em qualquer ordem ou combinação) e alguns desses tipos sobre os quais você não tem controle. Uma abordagem comum seria fazer com que seu método receba argumentos do tipo Object e valide os tipos em tempo de execução:

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");
    }
}

No entanto, digamos que, como eu, você esteja obcecado com a segurança do tipo em tempo de compilação e queira validar os tipos de argumento do seu método em tempo de compilação. Aqui está uma abordagem que eu criei:

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); }

}

Os lançamentos implícitos permitem que você transmita argumentos de tipos válidos diretamente para sua rotina, sem precisar explicitamente convertê-los ou agrupá-los. Se você tentar passar um valor de um tipo inaceitável, o erro será detectado no momento da compilaçã

Tenho certeza de que outras pessoas usaram essa abordagem, então estou me perguntando se existe um nome para esse padrã