Tengo una clase base:

public abstract class StuffBase
{
    public abstract void DoSomething();
}

Y dos clases derivadas

public class Stuff1 : StuffBase
{
    public void DoSomething()
    {
        Console.WriteLine("Stuff 1 did something cool!");
    }
    public Stuff1()
    {
        Console.WriteLine("New stuff 1 reporting for duty!");
    }
}

public class Stuff2 : StuffBase
{
    public void DoSomething()
    {
        Console.WriteLine("Stuff 2 did something cool!");
    }
    public Stuff1()
    {
        Console.WriteLine("New stuff 2 reporting for duty!");
    }
}

Bien, ahora di que tengo una lista de artículos:

var items = new List<StuffBase>();
items.Add(new Stuff1());
items.Add(new Stuff2());

y quiero que todos llamen a su método DoSomething (). Podría esperar solo iterar la lista y llamar a su método DoSomething (), así que digamos que tengo un método para hacer eso llamado AllDoSomething () que simplemente itera sobre la lista y hace el trabajo:

public static void AllDoSomething(List<StuffBase> items)
{
    items.ForEach(i => i.DoSomething());
}

¿Cuál es la diferencia práctica del siguiente método?

public static void AllDoSomething<T>(List<T> items) where T: StuffBase
{
    items.ForEach(i => i.DoSomething());
}

Ambos métodos aparecen en términos reales, aunque sintácticamente diferentes, para estar haciendo lo mismo.

¿Son solo formas diferentes de hacer lo mismo? Entiendo los genéricos y las restricciones de tipo, pero no puedo ver por qué usaría una manera sobre la otra en esta instancia.