classe fabbrica ritorno un'interfaccia generica

Question

Ho pochi concreta che utilizza il seguente tipo di interfaccia

interface IActivity<T> 
{ 
    bool Process(T inputInfo); 
} 

classi di cemento sono come i seguenti

class ReportActivityManager :IActivity<DataTable> 
{ 
    public bool Process(DataTable inputInfo) 
    { 
     // Some coding here 
    } 
} 

class AnalyzerActivityManager :IActivity<string[]> 
{ 
    public bool Process(string[] inputInfo) 
    { 
     // Some coding here 
    } 
} 

Ora come faccio a scrivere la classe di fabbrica che Retuns un'interfaccia generica una cosa come IActivity.

class Factory 
{ 
    public IActivity<T> Get(string module) 
    { 
     // ... How can i code here 
    } 
} 

Grazie

Answer 1

Si dovrebbe creare metodo generico, altrimenti il ​​compilatore non saprà tipo di T nel valore di ritorno. Quando si avrà T si sarà in grado di creare l'attività in base al tipo di T:

class Factory 
{ 
    public IActivity<T> GetActivity<T>() 
    { 
     Type type = typeof(T); 
     if (type == typeof(DataTable)) 
      return (IActivity<T>)new ReportActivityManager(); 
     // etc 
    } 
} 

Usage:

IActivity<DataTable> activity = factory.GetActivity<DataTable>(); 

Answer 2

Spesso questo è implementato come in lazyberezovsky's answer. In C++ è possibile utilizzare la specializzazione del modello per ottenere errori del compilatore quando si tenta di creare un tipo che la fabbrica non gestisce.

Non puoi farlo in C# ma puoi avvicinarti. Anche se il codice potrebbe sembrare un po 'sorprendente, a sua volta potrebbe essere un problema.

public static class Factory { 
    public static IActivity<someType> Get(this someType self){ 
      //stuff specific to someType 
    } 

    public static IActivity<someOtherType> Get(someOtherType self){ 
      //stuff specific to someOtherType 
    } 

    public static T Creator<T>(){ 
     return null; 
    } 

} 

L'utilizzo sarebbe allora

IActivity<someType> act = Factory.Creator<someType>().Get(); 

ovviamente questo funziona solo se è possibile passare un tipo concreto. Se devi passare un parametro di tipo le cose si complicano.