Tengo un método genérico que acepta el "T" type y este es el enumerador. Dentro del método, tengo que llamar a los métodos de clase auxiliar y el nombre del método depende del tipo de enumerador.
public Meth<T> (T type) { if (typeof(T) == typeof(FirstEnumType)) { FirstEnumType t = ??? // I somehow need to convert T type to FirstEnumType this.helperFirstCalcBll(t); } else { SecondEnumType t = ??? // I somehow need to convert T type to SecondEnumType this.helperSecondCalcBll(t); } }No hay una conversión válida de un tipo arbitrario a un tipo de enumeración, por lo que esto no está permitido. Necesitas lanzar al objeto primero:
FirstEnumType t = (FirstEnumType)(object)type; Esto "engaña" al compilador elevando al object (que siempre es válido) y luego bajando al tipo de enumeración. Suponiendo que haya realizado una verificación de tipo de tiempo de ejecución, el downcast nunca fallará. Sin embargo, implementar esto en la rama else, tal como se indica, no garantiza que funcione.
Uno se preguntaría por qué el método es incluso genérico en primer lugar, pero así es como puede hacer que este método en particular funcione.
public void Meth(FirstEnumType type) { this.helperFirstCalcBll(type); } public void Meth(SecondEnumType type) { this.helperSecondCalcBll(type); }Esto es algo dynamic es muy útil para:
public void Meth<T>(T enumValue) where T : struct { InternalMeth((dynamic)enumValue); } private void InternalMeth(FirstEnumType enumValue) { this.helperFirstCalcBll(enumValue); } private void InternalMeth(SecondEnumType enumValue) { this.helperSecondCalcBll(enumValue); } private void InternalMeth(object enumValue) { // Do whatever fallback you need } Esto evita tener que escribir todos esos if (typeof(T) == typeof(...)) y todo: deja que el envío dinámico se encargue de elegir la mejor sobrecarga en tiempo de ejecución. La sobrecarga de object está ahí si todos los demás fallan, por lo que puede, por ejemplo, lanzar una excepción.