Llamadas de método genérico con comprobaciones de tipos genéricos.

Answer

1. 

   davy.ai

   June 4, 2023 at 12:44 pm

   Sí, hay una forma de verificar el tipo de un tipo genérico y pasarlo a otro método genérico. Una opción es utilizar el operador typeof para obtener el tipo de T en tiempo de ejecución y luego utilizar la reflexión para invocar el método apropiado según la(s) interfaz(es) que implemente T. Aquí hay una implementación de ejemplo que demuestra esta aproximación:

   void HandleStandards<t>(.. constructor ..) where T : class, IEntity
   {
       Type t = typeof(T);
   
       if (typeof(IIdentifiable).IsAssignableFrom(t))
       {
           MethodInfo handleIdentifiableMethod = typeof(YourClass).GetMethod("HandleIdentifiable", BindingFlags.NonPublic | BindingFlags.Instance);
           MethodInfo genericHandleIdentifiableMethod = handleIdentifiableMethod.MakeGenericMethod(t);
           genericHandleIdentifiableMethod.Invoke(this, new object[] { constructor });
       }
   
       if (typeof(ITrackable).IsAssignableFrom(t))
       {
           MethodInfo handleTrackableMethod = typeof(YourClass).GetMethod("HandleTrackable", BindingFlags.NonPublic | BindingFlags.Instance);
           MethodInfo genericHandleTrackableMethod = handleTrackableMethod.MakeGenericMethod(t);
           genericHandleTrackableMethod.Invoke(this, new object[] { constructor });
       }
   }
   

   En esta implementación, primero utilizamos typeof(IIdentifiable).IsAssignableFrom(t) para verificar si T implementa la interfaz IIdentifiable. Si es así, utilizamos la reflexión para obtener el método HandleIdentifiable y crear una versión genérica de él con MakeGenericMethod(t). Luego, invocamos ese método con Invoke(this, new object[] { constructor }), pasando el parámetro constructor.

   Seguimos un proceso similar para la interfaz ITrackable. Tenga en cuenta que estamos suponiendo que HandleIdentifiable y HandleTrackable son ambos métodos de instancia privados de YourClass (o cualquier clase en la que se defina HandleStandards).

   Este enfoque puede ser útil si tiene muchas interfaces diferentes que desea verificar y manejar de forma genérica. Sin embargo, tiene algunas desventajas: puede ser más lento que simplemente verificar si T implementa una interfaz y luego llamar al método correspondiente directamente, y puede ser más propenso a errores debido al uso de la reflexión. Si solo tiene algunas interfaces para manejar y / o prefiere un enfoque más simple y directo, es posible que desee considerar simplemente verificar cada interfaz una por una y luego llamar al método correspondiente directamente.

Comments are closed.