Passaggio generico e utilizzo, posso eseguire le seguenti operazioni?

Question

Cerco di capire come accedere a un metodo statico entro CallMe<T>() della classe DoSomething. La riflessione è l'unica soluzione qui? Non voglio istanziare un oggetto di tipo MyAction. Inoltre, se lo si fa attraverso la riflessione, esiste un modo per creare il metodo attraverso la riflessione all'interno del metodo CallMe<T>() una sola volta e quindi richiamarlo più volte per eseguire più operazioni sullo stesso metodo "riflesso"? O c'è un modo migliore che attraverso la riflessione? Fondamentalmente voglio creare classi di stile di implementazione del modello come MyAction che definiscono il modo in cui lo byte[] DoThis(string text) svolge il proprio compito. Il AskForSomething() specificherà quindi quale modello viene utilizzato e in base al fatto che lo CallMe<T>() continuerà a funzionare.

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

Definire un'interfaccia con DoThis, hanno MyAction attuarlo, e vincolare il parametro T tipo da un'istanza di esso con where T : IMyInterface

Answer 2

Se il metodo DoThis deve essere statico si può anche cambiare la vostra CallMe metodo per la seguente:

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

Ora si può passare un riferimento a una funzione al CallMe metodo come questo:

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

Sulla base del fatto che "dothis" non deve essere statico è possibile raggiungere questo obiettivo con il seguente: -

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; 
    } 
} 
} 

Non sono sicuro io' d consiglio questo approccio ma funziona! (per esempio se non esiste un costruttore predefinito questo fallirà).