Definición de métodos genéricos

Question

Todo, tengo un método que se utiliza actualmente para invocar DLL de tipo de retorno bool, esto funciona muy bien. Este método es

public static bool InvokeDLL(string strDllName, string strNameSpace, 
          string strClassName, string strMethodName, 
          ref object[] parameters, 
          ref string strInformation, 
          bool bWarnings = false) 
{ 
    try 
    { 
     // Check if user has access to requested .dll. 
     if (!File.Exists(Path.GetFullPath(strDllName))) 
     { 
      strInformation = String.Format("Cannot locate file '{0}'!", 
              Path.GetFullPath(strDllName)); 
      return false; 
     } 
     else 
     { 
      // Execute the method from the requested .dll using reflection. 
      Assembly DLL = Assembly.LoadFrom(Path.GetFullPath(strDllName)); 
      Type classType = DLL.GetType(String.Format("{0}.{1}", 
             strNameSpace, strClassName)); 
      if (classType != null) 
      { 
       object classInstance = Activator.CreateInstance(classType); 
       MethodInfo methodInfo = classType.GetMethod(strMethodName); 
       if (methodInfo != null) 
       { 
        object result = null; 
        result = methodInfo.Invoke(classInstance, new object[] { parameters }); 
        return Convert.ToBoolean(result); 
       } 
      } 

      // Invocation failed fatally. 
      strInformation = String.Format("Could not invoke the requested DLL '{0}'! " + 
              "Please insure that you have specified the namespace, class name " + 
              "method and respective parameters correctly!", 
              Path.GetFullPath(strDllName)); 
      return false; 

     } 
    } 
    catch (Exception eX) 
    { 
     strInformation = String.Format("DLL Error: {0}!", eX.Message); 
     if (bWarnings) 
      Utils.ErrMsg(eX.Message); 
     return false; 
    } 
} 

Ahora, quiero extender este método para que pueda recuperar los valores de retorno desde un archivo DLL de cualquier tipo . Planeé hacer esto usando genéricos, pero de inmediato ingresé en territorio desconocido para mí. ¿Cómo devuelvo T cuando se desconoce en el momento de la compilación? He examinado la reflexión, pero no estoy seguro de cómo se usaría en este caso. Tome el primer cheque en el código anterior

public static T InvokeDLL<T>(string strDllName, string strNameSpace, 
          string strClassName, string strMethodName, 
          ref object[] parameters, ref string strInformation, 
          bool bWarnings = false) 
{ 
    try 
    { 
     // Check if user has access to requested .dll. 
     if (!File.Exists(Path.GetFullPath(strDllName))) 
     { 
      strInformation = String.Format("Cannot locate file '{0}'!", 
              Path.GetFullPath(strDllName)); 
      return "WHAT/HOW??"; 
     ... 

¿Cómo puedo lograr lo que quiero, o tendría que acaba de sobrecargar el método?

Muchas gracias por su ayuda.

Answer 1

Reemplazar

return false; 

por

return default(T); 

y

return Convert.ToBoolean(result); 

por

return (T)result; 

Answer 2

Cuando no tiene un valor real de la DLL, obviamente tiene que crear un valor de alguna parte. La única forma que funciona para todos los tipos posibles T es return default(T), que proporciona el valor predeterminado para ese tipo (es decir, 0 para int, null para cualquier tipo de referencia).

Si coloca restricciones de tipo en el parámetro tipo, puede obtener más opciones, pero a expensas de la genérica.

Answer 3

me gustaría hacer algo como esto:

public static InvokeDLLResult<T> InvokeDLL<T>(string strDllName, string strNameSpace, 
         string strClassName, string strMethodName, 
         ref object[] parameters, 
         ref string strInformation, 
         bool bWarnings = false) 
    { 
     try 
     { 
      // Check if user has access to requested .dll. 
      if (!File.Exists(Path.GetFullPath(strDllName))) 
      { 
       strInformation = String.Format("Cannot locate file '{0}'!", 
                 Path.GetFullPath(strDllName)); 
       return InvokeDLLResult<T>.Failure; 
      } 
      else 
      { 
       // Execute the method from the requested .dll using reflection. 
       Assembly DLL = Assembly.LoadFrom(Path.GetFullPath(strDllName)); 
       Type classType = DLL.GetType(String.Format("{0}.{1}", strNameSpace, strClassName)); 
       if (classType != null) 
       { 
        object classInstance = Activator.CreateInstance(classType); 
        MethodInfo methodInfo = classType.GetMethod(strMethodName); 
        if (methodInfo != null) 
        { 
         object result = null; 
         result = methodInfo.Invoke(classInstance, new object[] { parameters }); 
         return new InvokeDLLResult<T>(true, (T) Convert.ChangeType(result, methodInfo.ReturnType)); 
        } 
       } 

       // Invocation failed fatally. 
       strInformation = String.Format("Could not invoke the requested DLL '{0}'! " + 
                 "Please insure that you have specified the namespace, class name " + 
                 "method and respective parameters correctly!", 
                 Path.GetFullPath(strDllName)); 
       return InvokeDLLResult<T>.Failure; 

      } 
     } 
     catch (Exception eX) 
     { 
      strInformation = String.Format("DLL Error: {0}!", eX.Message); 
      if (bWarnings) 
       Debug.WriteLine(eX.Message); 
      return InvokeDLLResult<T>.Failure; 
     } 
    } 

    public class InvokeDLLResult<T> 
    { 
     public InvokeDLLResult(bool success, T result) 
     { 
      Success = success; 
      Result = result; 
     } 

     public bool Success { get; private set; } 
     public T Result { get; private set; } 

     public static InvokeDLLResult<T> Failure = new InvokeDLLResult<T>(false, default(T)); 
    } 

O, me gustaría escribir un método TryInvokeDLL, usando un parámetro de salida para devolver el resultado.