C# Generics Instantiation

Question

Tutti, ho un metodo che restituisce una lista. Questo metodo viene utilizzato per restituire i parametri di SQL StoredProcedures, Views e Functions in base al nome. Quello che voglio fare è creare una lista di oggetti e restituire questa lista al chiamante. Il metodo è al di sotto

private List<T> GetInputParameters<T>(string spFunViewName) 
{ 
    string strSql = String.Format(
     "SELECT PARAMETER_NAME, DATA_TYPE FROM INFORMATION_SCHEMA.PARAMETERS " + 
     "WHERE SPECIFIC_NAME = '{0}' AND PARAMETER_MODE = 'IN';", 
     spFunViewName); 
    List<string[]> paramInfoList = new List<string[]>(); 
    DataTable paramDt = Utilities.DTFromDB(conn, "InputParmaters", strSql); 
    if (paramDt != null) 
    { 
     Converter<DataRow, string[]> rowConverter = 
      new Converter<DataRow, string[]>(Utilities.RowColConvert); 
     paramInfoList = Utilities.ConvertRowsToList<string[]>(paramDt, rowConverter); 
    } 
    else 
     return null; 

    // Build the input parameter list. 
    List<T> paramList = new List<T>(); 
    foreach (string[] paramInfo in paramInfoList) 
    { 
     T t = new T(paramInfo[NAME], paramInfo[TYPE], Convert.ToInt32(paramInfo[CHARMAXLEN])); 
     columnList.Add(column); 
    } 
    return columnList; 
} 

ho chiaramente posso non un'istanza di T via new e passare al costruttore, ma dovrebbe essere chiaro ciò che sto cercando di fare. C'è un modo per fare ciò che voglio senza tre metodi aggiuntivi?

Nota. Il problema principale è che il numero di parametri che sto passando a T può essere due o tre.

Grazie per il vostro tempo.

Edit: I struct s che uso sono i seguenti

public struct Database 
{ 
    public string name { get; set; } 
    public string filename { get; set; } 
    public List<Table> tables { get; set; } 
    public List<StoredProcedure> sps { get; set; } 
    public List<Function> funcs { get; set; } 
    public List<View> views { get; set; } 
    public Database(string name, string filename) 
    { 
     this.name = name; 
     this.filename = filename; 
    } 
} 

protected internal struct StoredProcedure 
{ 
    public string name { get; set; } 
    public List<string[]> parameters { get; set; } 
    public StoredProcedure(string name, List<string[]> parameters) 
    { 
     this.name = name; 
     this.parameters = parameters; 
    } 
} 

protected internal struct Function 
{ 
    public string name { get; set; } 
    public string output { get; set; } 
    public List<string[]> parameters { get; set; } 
    public Function(string name, string output, List<string[]> parameters) 
    { 
     this.name = name; 
     this.output = output; 
     this.parameters = parameters; 
    } 
} 

protected internal struct View 
{ 
    public string name {get; set;} 
    public List<string[]> parameters { get; set; } 
    public View(string name, List<string[]> parameters) 
    { 
     this.name = name; 
     this.parameters = parameters; 
    } 
} 

Answer 1

Utilizzare la classe Activator per creare T e passare i parametri.

Type type = typeof(T); 
var result = (T)Activator.CreateInstance(type, new object[] { yourParameters }); 

in uso nel proprio frammento di codice:

T t = Activator.CreateInstance(type, colInfo[NAME], colInfo[TYPE], Convert.ToInt32(colInfo[CHARMAXLEN])); 

Answer 2

Non sono né Appoggiare una né sminuire questa tecnica, ma è possibile utilizzare:

(T) Activator.CreateInstance(typeof(T), colInfo[TYPE], Convert.ToInt32(colInfo[CHARMAXLEN])); 

Penso che avrei preferito separata metodi di fabbrica.

Answer 3

Si potrebbe utilizzare Lista < DbParameter>

Che è un po 'più evidente.

Answer 4

Si potrebbe provare questo:

var constructor = typeof(T).GetConstructor(typeof(string), typeof(string), typeof(int)); 
constructor.Invoke(colInfo[NAME], colInfo[TYPE], Convert.ToInt32(colInfo[CHARMAXLEN])); 

Answer 5

È possibile utilizzare Activator.CreateInstance() come altri citati o passare un delegato Func<string, string, int, T> evitare il sovraccarico riflessione.

List<T> GetInputParameters<T>(string spFunViewName, Func<string, string, int, T> itemCreator) 
{ 

    .... 
    List<T> paramList = new List<T>();  
    foreach (string[] paramInfo in paramInfoList)  
    {   
     T t = itemCreator(paramInfo[NAME], paramInfo[TYPE], 
      Convert.ToInt32(paramInfo[CHARMAXLEN]));   
     paramList.Add(t);  
    }  

    return columnList;  
} 

Answer 6

È possibile creare parametri generici di database (e le connessioni e comandi, ecc) con ADO.NET DbProviderFactories.

Lo spazio dei nomi System.Data.Common fornisce le classi per la creazione di istanze DbProviderFactory di lavorare con fonti di dati specifici. Quando si crea un'istanza DbProviderFactory e si passano le informazioni su il provider di dati, DbProviderFactory può determinare l'oggetto di connessione fortemente digitato, , restituito in base alle informazioni fornite da .

Nel codice, è possibile creare un DbProviderFactory e quindi chiamare CreateParameter().

string providerName = ConfigurationManager.ConnectionStrings["YourConnectionString"].ProviderName; 
DbProviderFactory factory = DbProviderFactories.GetFactory(providerName); 
DbParameter parameter = factory.CreateParameter(); 

Answer 7

io chiaramente non posso instansiate T via nuova e passare al costruttore

Come scritto, no; tuttavia, è possibile se si vincola il vostro parametro del tipo di accettare solo i tipi con i costruttori:

private List<T> GetInputParameters<T>(string spFunViewName) where T : new() 
{ 
    // your code here 
} 

Nell'esempio di cui sopra si sarebbe in grado di dire:

T myItem = new T(); 

Nel tuo caso specifico, sembra che ti aspetti che ognuno dei tipi generici condivida qualcosa in comune. Si consideri inoltre vincolare il tipo di interfaccia:

private List<T> GetInputParameters<T>(string spFunViewName) where T : new(), ISomeInterface 
{ 
    // your code here 
} 

che permetterebbe di, dopo aver un'istanza obiettate, applicare i valori di tutte le proprietà sull'interfaccia:

T myItem = new T(); 

myItem.SomeProperty = somevalue; 
myItem.AnotherProperty = anothervalue; 

Per ulteriori informazioni, check out Constraints on Type Parameters (C# Programming Guide) su MSDN per maggiori informazioni sui vincoli di tipo generico.