.net - que - quitar los primeros 3 caracteres de una cadena c#

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

Question

En este momento, tengo un código que se ve así:

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 forma de crear código que use las convenciones de nombres de mi método para simplificar las cosas? Aquí hay un 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

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

Puede hacer delegados de esos informes y llamarlos buscando la Cadena correspondiente 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

De esta forma, puede agregar tantos informes como desee, y su capacidad para reflejarlos, y el impacto de la reflexión, no son un problema.

Answer 2

Podría usar el reflejo para hacer esto, pero para ser honesto, creo que es algo complicado 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 ensamblaje (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 . Vea este artículo de proyecto de código para 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

Puedes usar 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 5

Python (e 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ápido para 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 6

Reflection API le permite obtener un MethodInfo partir de un método, y luego invocar Invoke dinámicamente en él. Pero es excesivo en tu caso.

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

Answer 7

Si entiendo la pregunta correctamente, tendrá que usar Reflection para encontrar el método "show" + reportName y luego invocarlo indirectamente:

Ejemplo a medio cocer:

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

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

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

}

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

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

Answer 8

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

Sigue con la declaración del interruptor, ya que desacopla tu implementación interna (nombres de métodos) desde tu vista externa.

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

Answer 9

Usa la reflexión En el System.Reflection nombres 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 a .Invoke() con la instancia del objeto y cualquier parámetro.

Por ejemplo:

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

Answer 10

Usando 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 hace tiempo, mejor no cambies tu código original ;-)

Answer 11

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

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