Crear una llamada a un método en .NET basado en un valor de cadena

Question

En este momento, no tengo código que se ve algo como esto:

Private Sub ShowReport(ByVal reportName As String) 
    Select Case reportName 
     Case "Security" 
      Me.ShowSecurityReport() 
     Case "Configuration" 
      Me.ShowConfigurationReport() 
     Case "RoleUsers" 
      Me.ShowRoleUsersReport() 
     Case Else 
      pnlMessage.Visible = True 
      litMessage.Text = "The report name """ + reportName + """ is invalid." 
    End Select 
End Sub 

¿Hay alguna manera de crear un código que utilizaría mis convenciones de nombres de método para simplificar ¿cosas? Aquí hay algo de pseudocódigo que describe lo que estoy buscando:

Private Sub ShowReport(ByVal reportName As String) 
    Try 
     Call("Show" + reportName + "Report") 
    Catch ex As Exception 
     'method not found 
    End Try 
End Sub 

Answer 1

Type type = GetType(); 
MethodInfo method = type.GetMethod("Show"+reportName+"Report"); 
if (method != null) 
{ 
    method.Invoke(this, null); 
} 

Esto es C#, debe ser lo suficientemente fácil de convertirlo en VB. Si necesita pasar un parámetro al método, se pueden agregar en el segundo argumento a Invocar.

Answer 2

Se podría utilizar la reflexión para hacer esto, pero para ser honesto, creo que complicar las cosas para su escenario particular, es decir, el código y el interruptor() en la misma clase.

Ahora, si ha diseñado la aplicación para tener cada tipo de informe en su propio conjunto (como una arquitectura de complementos/complementos) o en un único ensamblaje externo, puede cargar los ensamblados de informes en un dominio de aplicación y luego usa la reflexión para hacer esto.

Answer 3

Puede usar System.Reflection. Consulte this code project article para obtener más información.

string ModuleName = "TestAssembly.dll"; 
string TypeName = "TestClass"; 
string MethodName = "TestMethod"; 

Assembly myAssembly = Assembly.LoadFrom(ModuleName); 

BindingFlags flags = (BindingFlags.NonPublic | BindingFlags.Public | 
    BindingFlags.Static | BindingFlags.Instance | BindingFlags.DeclaredOnly); 

Module [] myModules = myAssembly.GetModules(); 
foreach (Module Mo in myModules) 
    { 
    if (Mo.Name == ModuleName) 
     { 
     Type[] myTypes = Mo.GetTypes(); 
     foreach (Type Ty in myTypes) 
      { 
      if (Ty.Name == TypeName) 
       { 
       MethodInfo[] myMethodInfo = Ty.GetMethods(flags); 
       foreach(MethodInfo Mi in myMethodInfo) 
        { 
        if (Mi.Name == MethodName) 
         { 
         Object obj = Activator.CreateInstance(Ty); 
         Object response = Mi.Invoke(obj, null); 
         } 
        } 
       } 
      } 
     } 
    } 

Answer 4

Use la reflexión. En el espacio de nombre System.Reflection necesita obtener un objeto MethodInfo para el método que desee, utilizando GetMethod("methodName") en el tipo que contiene el método.

Una vez que tenga el objeto MethodInfo, puede llamar al .Invoke() con la instancia del objeto y los parámetros.

Por ejemplo:

System.Reflection.MethodInfo method = this.GetType().GetMethod("foo"); 
method.Invoke(this, null); 

Answer 5

Reflection API le permite obtener un MethodInfo de un método, y luego llamar al Invoke de forma dinámica. Pero es excesivo en tu caso.

Debería considerar tener un diccionario de delegados indexado por cadenas.

Answer 6

Python (y IronPython) pueden hacer esto con mucha facilidad. Sin embargo, con .Net, necesitas usar la reflexión.

En C#: http://www.dotnetspider.com/resources/4634-Invoke-me-ods-dynamically-using-reflection.aspx

mi puerto rápida a VB.Net:

Private Sub InvokeMethod(instance as object, methodName as string) 
      'Getting the method information using the method info class 
      Dim mi as MethodInfo = instance.GetType().GetMethod(methodName) 

      'invoing the method 
      'null- no parameter for the function [or] we can pass the array of parameters 
      mi.Invoke(instance, Nothing) 
End Sub 

Answer 7

Puede utilizar la reflexión. Aunque personalmente, creo que deberías seguir con la declaración de cambio.

private void ShowReport(string methodName) 
{ 
    Type type = this.GetType(); 
    MethodInfo method = type.GetMethod("Show"+methodName+"Report", BindingFlags.Public) 
    method.Invoke(this, null); 
} 

Lo siento, estoy haciendo C#. Simplemente tradúzcalo a VB.NET.

Answer 8

si entiendo la pregunta correctamente, usted tiene que utilizar la reflexión para encontrar el método "mostrar" + reportName y luego invocar de forma indirecta: ejemplo

a medias:

Case "financial" : 
{ 
    Assembly asm = Assembly.GetExecutingAssembly(); 

    MethodInfo mi = asm.GetType ("thisClassType").GetMethod ("showFinancialReport"); 

    if (mi != null) 
     mi.Invoke (null, new object[] {}); 

} 

Insertar su propia lógica allí para inventar el nombre del método para llamar.

Consulte la documentación de MSDN sobre MethodInfo y Assembly para obtener más información.

Answer 9

El uso de la reflexión:

Type t = this.GetType(); 
try 
{ 
    MethodInfo mi = t.GetMethod(methodName, ...); 

    if (mi != null) 
    { 
     mi.Invoke(this, parameters); 
    } 
} 

Pero estoy de acuerdo con la hace, mejor no cambiar su código original ;-)

Answer 10

Tienes un problema más profundo. Tus cadenas son muy importantes. ¿Quién te está pasando cadenas? puedes hacer que ellos no hagan eso?

Manténgase en la instrucción switch, ya que desacopla su implementación interna (nombres de métodos) de su vista externa.

Supongamos que localizas esto en alemán. ¿Cambiarás el nombre de todos esos métodos?

Answer 11

La solución "Más cercana a su pregunta".

Se podría hacer que los delegados de esos informes, y llamarlos por buscar la cadena coincidente en una tabla hash:

Public Sub New() 
    '... 
    ReportTable.Add("Security", New ReportDelegate(AddressOf ShowSecurityReport)) 
    ReportTable.Add("Config", New ReportDelegate(AddressOf ShowConfigReport)) 
    ReportTable.Add("RoleUsers", New ReportDelegate(AddressOf ShowRoleUsersReport)) 
    '... 
End Sub 

Private Sub ShowSecurityReport() 
    '... 
End Sub 

Private Sub ShowConfigReport() 
    '... 
End Sub 

Private Sub ShowRoleUsersReport() 
    '... 
End Sub 

Private Delegate Sub ReportDelegate() 

Private ReportTable As New Dictionary(Of String, ReportDelegate) 

Private Sub ShowReport(ByVal reportName As String) 
    Dim ReportToRun As ReportDelegate 
    If ReportTable.TryGetValue(reportName, ReportToRun) Then 
     ReportToRun() 
    Else 
     pnlMessage.Visible = True 
     litMessage.Text = "The report name """ + reportName + """ is invalid." 
    End If 
End Sub 

esa manera usted puede añadir tantos informes como desee, y su capacidad para reflejar ellos, y el impacto de la reflexión, no son un problema.