Conversione di diversi elenchi di oggetti in un DataTable tramite FastMember

Question

Ho scritto un metodo che converte un elenco generico in un DataTable utilizzando FastMember da NuGet.

Questo è il mio codice:

public DataTable ConvertGenericListToDataTable(List<CustomObject> inputList) 
{ 
    var dt = new DataTable(); 
    using (var reader = ObjectReader.Create(inputList)) 
    { 
     dt.Load(reader); 
    } 
    return dt; 
} 


var customObject = new List<CustomObject>(); 
var dt = ListToDataTable.ConvertGenericListToDataTable(customObject); 

che funziona bene. Customobject è un oggetto personalizzato che ho creato, ho diversi elenchi diversi che voglio passare al mio metodo: List<CustomobjectA> o List<CustomobjectB> e così via. Non è un grosso problema scrivere un metodo per ogni tipo di elenco che voglio convertire in un DataTable, ma questo potrebbe finire ripetendo sempre le stesse linee di codice, questo è qualcosa che ovviamente voglio evitare

Ho provato a modificare il tipo del parametro su List<object> e List<dynamic>. Quindi il mio codice non verrà compilato perché: "La migliore corrispondenza overloadmethod per ConvertGenericListToDataTable presenta alcuni argomenti non validi".

Esiste un modo per passare un elenco di oggetti come parametro senza definire il tipo esatto dell'oggetto?

Answer 1

Crea un interfacefor 'CustomObject', che definisce i metodi e le proprietà che devono essere parte di una classe che implementa l'interfaccia 'CustomObject'. Quindi assicurati che 'CustomObjectA' e 'CustomObjectB' ereditino l'interfaccia 'CustomObject', esegui tutte le implementazioni richieste in 'CustomObjectA' e 'CustomObjectB'.

Per rendere il metodo 'ConvertGenericListToDataTable' accettabile per qualsiasi 'CustomObject', è sufficiente accettare la classe che implementa l'interfaccia 'CustomObject'.

In questo modo si assicura che gli oggetti forniti nell'elenco abbiano i metodi e le proprietà eccezionali.

avrei potuto ottenuto la sintassi sbagliata, ma qualcosa di simile:

interface ICustomObject 
{ 
    public string RequiredProperty { get; } 

    public void RequiredMethod(); 
} 

public class CustomObjectA : ICustomObject 
{ 
    public string RequiredProperty 
    { 
     get 
     { 
      return "I'm CustomObjectA"; 
     } 
    } 

    public void RequiredMethod() 
    { 
     // do anything 
    } 
} 

public class CustomObjectB : ICustomObject 
{ 
    public string RequiredProperty 
    { 
     get 
     { 
      return "I'm CustomObjectB"; 
     } 
    } 

    public void RequiredMethod() 
    { 
     // do anything 
    } 
} 

public void AcceptsAllCustomObjects(List<ICustomObject> Cookies) 
{ 
    Console.WriteLine(Cookies[0].RequiredProperty); 
} 

Answer 2

si dovrebbe rendere CustomobjectA o CustomObjectB ereditare una classe CustomObject astratta che verrebbe utilizzata come parametro di input, proprio come si faceva nel metodo.

Answer 3

Che dire di avere un metodo generico ConvertGenericListToDataTable?

public DataTable ConvertGenericListToDataTable<T>(List<T> inputList) 
{ 
} 

Answer 4

Ho provato questo e ha funzionato

public static DataTable ConvertGenericListToDataTable<T>(this List<T> inputList) 
{ 
    var dt = new DataTable(); 
    using (var reader = ObjectReader.Create(inputList)) 
    { 
     dt.Load(reader); 
    } 
    return dt; 
}