Generische Art und Weise der Weitergabe und Verwendung, kann ich folgendes tun?

Question

Ich versuche herauszufinden, wie ich auf eine statische Methode innerhalb CallMe<T>() der Klasse DoSomething zugreifen kann. Ist Reflexion die einzige Lösung hier? Ich möchte kein Objekt vom Typ MyAction instanziieren. Auch wenn es durch Reflexion getan wird, gibt es eine Möglichkeit, die Methode durch Reflexion innerhalb der Methode CallMe<T>() nur einmal zu erstellen und sie dann mehrmals aufzurufen, um mehrere Operationen mit derselben "reflektierten" Methode auszuführen? Oder gibt es einen besseren Weg als durch Reflexion? Ich möchte im Grunde erstellen Template-Implementierung Stil Klassen wie MyAction, die definieren, wie byte[] DoThis(string text) seine Pflicht erfüllt. Die AskForSomething() wird dann angeben, welche Vorlage verwendet wird und entsprechend wird die CallMe<T>() über ihre Arbeit gehen.

public class AskSomething 
    { 
     public void AskForSomething() 
     { 
      DoSomething doSomething = new DoSomething(); 
      doSomething.CallMe<MyAction>(); 
     } 
    } 

    public class DoSomething 
    { 
     public void CallMe<T>() 
     { 
      Type type = typeof(T); 

      //Question: How can I access 'DoThis(string text)' here? 
      //Most likely by reflection? 
     } 
    } 

    public class MyAction 
    { 
     public static byte[] DoThis(string text) 
     { 
      byte[] ret = new byte[0]; //mock just to denote something is done and out comes a byte array 

      return ret; 
     } 
    } 

Answer 1

definieren eine Schnittstelle mit DoThis haben MyAction es umzusetzen, und beschränken den T Typ-Parameter eine Instanz mit where T : IMyInterface

Answer 2

werden, wenn Ihr DoThis Methode statisch sein muss können Sie auch Ihre CallMe ändern Verfahren auf die folgenden:

public void CallMe(Func<string, byte[]> action) 
{ 
    byte[] result = action("input"); 
} 

Jetzt können Sie einen Verweis auf eine Funktion, um diepassieren kann 10 Verfahren wie folgt aus:

doSomething.CallMe(MyAction.DoThis); 

Answer 3

public class DoSomething 
    { 
    class Cache<T> 
    { 
     public readonly static Func<string, byte[]> action = (Func<string, byte[]>)Delegate.CreateDelegate(typeof(Func<string, byte[]>), typeof(T).GetMethod("DoThis")); 
    } 
    public void CallMe<T>() 
    { 
     Cache<T>.action("text"); 
    } 
    } 

Answer 4

Basierend auf der Tatsache, dass „DoThis“ muss nicht statisch sein Sie dies mit dem folgenden erreichen: -

using System; 

namespace ConsoleApplication3 
{ 
class Program 
{ 
    static void Main(string[] args) 
    { 
     DoSomething doSomething = new DoSomething(); 
     doSomething.CallMe<MyAction>(); 

    } 
} 
public class DoSomething 
{ 
    public void CallMe<T>() where T : IMyAction 
    { 
     IMyAction action = (IMyAction)Activator.CreateInstance(typeof(T)); 

     var result = action.DoThis("value");    
    } 
} 

public interface IMyAction 
{ 
    byte[] DoThis(string text); 
} 

public class MyAction : IMyAction 
{ 
    public byte[] DoThis(string text) 
    { 
     byte[] ret = new byte[0]; //mock just to denote something is done and out comes a byte array 

     return ret; 
    } 
} 
} 

nicht sicher, ob ich‘ Ich empfehle diesen Ansatz, aber es funktioniert! (Wenn zum Beispiel kein Standardkonstruktor vorhanden ist, wird dies fehlschlagen).