Considere la siguiente clase,

class Foo
{
    public Foo(int count)
    {
        /* .. */
    }

    public Foo(int count)
    {
        /* .. */
    }
}

El código anterior no es válido y no se compilará. Ahora considera el siguiente código,

class Foo<T>
{
    public Foo(int count)
    {
        /* .. */
    }

    public Foo(T t)
    {
        /* .. */
    }
}

static void Main(string[] args)
{
    Foo<int> foo = new Foo<int>(1);
}

El código anterior es válido y compila bien. LlamaFoo (cuenta int).

Mi pregunta es si el primero no es válido, ¿cómo puede ser válido el segundo? Yo se claseFoo <T> Es válido porque T e int son tipos diferentes. Pero cuando se usa comoFoo <int> foo = nuevo Foo <int> (1), T está obteniendo un tipo entero y ambos constructores tendrán la misma firma, ¿no? ¿Por qué el compilador no muestra el error en lugar de elegir una sobrecarga para ejecutar?