Korrekt! Aber du kannst Typen eben nicht nur über generische Parameter kommunizieren, sondern auch über einen normalen System.Type-Parameter.
Statt
public void Foo<T>()
machst du
public void Foo(System.Type type)
Du kannst generische Parameter auch problemlos mit typeof() zu einem System.Type-Objekt umwandeln. So als Beispiel:
public bool Foo<T>(System.Type type)
{
return typeof(t) == type;
}
Das gibt dann true zurück, wenn man das so aufruft:
Foo<Light>(typeof(Light))
// oder
Foo<Light>(GetComponent<Light>().GetType())
Umgekehrt braucht man halt leider Reflection und sollte das vermeiden. Aber man kann oft von der anderen Seite ankommen, z.B. so:
class MyGenericClass<T>
{
public System.Type GenericType => typeof(T);
}
Objekte dieser Klasse geben die mit der Property "GenericType" den Typ zurück, den du beim Erstellen für T übergeben hast:
var thing = new MyGenericClass<Light>();
Debug.Log(thing.GenericType.Name); // "Light"
Damit geht eine ganze Menge. Du könntest zum Beispiel beim Start alle deine Objekte laden und sie in ein Dictionary packen.
Das Dictionary kann so aussehen:
private Dictionary<System.Type, List<MyGenericClass<>> genericClassObjectsByGenericType = new Dictionary<...>();
Und dann lädst du da alle geladenen Objekte rein und sortierst sie nach ihrem generischen Typ:
foreach (var loadedObject in allLoadedObjects)
{
var type = loadedObject.GenericType;
List<MyGenericClass<>> list;
if (genericClassObjectByType.TryGetValue(type, out list))
{
list.Add(loadedObject);
}
else
{
list = new List<MyGenericClass<>>();
list.Add(loadedObject);
genericClassObjectByType.Add(type, list);
}
}
Und wenn du dann alle Objekte eines bestimmten generischen Type haben willst, holst du sie dir einfach aus dem Dictionary:
public List<MyGenericClass<>> GetAllObjectsForType(System.Type type)
{
return genericClassObjectsByType[type];
}
Da fehlt noch die Ausnahmebehandlung, falls der Typ nicht gefunden wird. Und ich hab das jetzt so runtergetippt, kann sein dass die Syntax mit <> nicht ganz richtig verwendet wird. Aber ich hoffe, die Idee ist einigermaßen klar.
Ja schon, aber eine Datenstruktur wachsen zu lassen ist besserer Stil als ein switch-case, das ständig erweitert werden muss. Vor allem, weil du bei einem Dictionary einfach mit der Schleife über alle Typen gehen kannst (siehe oben), anstatt deinen switch-case-Code jedes Mal anzufassen.