Convertir une liste générique ou une table énumérative en une table de données ?

Question

J'ai quelques méthodes qui renvoient différentes listes génériques.

Existe-t-il en .net une classe, une méthode statique ou autre pour convertir une liste en table de données ? La seule chose que je peux imaginer est d'utiliser Reflection pour le faire.

Si j'ai ça :

List<Whatever> whatever = new List<Whatever>();

(Ce code suivant ne fonctionne pas bien sûr, mais j'aimerais avoir la possibilité de :

DataTable dt = (DataTable) whatever;

Answer 1

Voici une belle mise à jour de 2013 utilisant FastMember de NuGet :

IEnumerable<SomeType> data = ...
DataTable table = new DataTable();
using(var reader = ObjectReader.Create(data)) {
    table.Load(reader);
}

Ceci utilise l'API de métaprogrammation de FastMember pour une performance maximale. Si vous voulez le restreindre à des membres particuliers (ou faire respecter l'ordre), vous pouvez également le faire :

IEnumerable<SomeType> data = ...
DataTable table = new DataTable();
using(var reader = ObjectReader.Create(data, "Id", "Name", "Description")) {
    table.Load(reader);
}

L'éditeur Dis / revendicateur : FastMember est un projet de Marc Gravell. C'est de l'or et des mouches pleines !

---

Oui, c'est à peu près l'exact opposé de ce un ; la réflexion suffirait - ou si vous avez besoin de plus rapide, HyperDescriptor dans la version 2.0, ou peut-être Expression en 3.5. En fait, HyperDescriptor devrait être plus que suffisant.

Par exemple :

// remove "this" if not on C# 3.0 / .NET 3.5
public static DataTable ToDataTable<T>(this IList<T> data)
{
    PropertyDescriptorCollection props =
        TypeDescriptor.GetProperties(typeof(T));
    DataTable table = new DataTable();
    for(int i = 0 ; i < props.Count ; i++)
    {
        PropertyDescriptor prop = props[i];
        table.Columns.Add(prop.Name, prop.PropertyType);
    }
    object[] values = new object[props.Count];
    foreach (T item in data)
    {
        for (int i = 0; i < values.Length; i++)
        {
            values[i] = props[i].GetValue(item);
        }
        table.Rows.Add(values);
    }
    return table;        
}

Maintenant, avec une seule ligne, vous pouvez rendre ce processus beaucoup plus rapide que la réflexion (en activant l'option HyperDescriptor pour le type d'objet T ).

---

Modification de la requête de performance ; voici un banc d'essai avec les résultats :

Vanilla 27179
Hyper   6997

Je soupçonne que le goulot d'étranglement s'est déplacé de l'accès aux membres vers DataTable performance... Je doute que vous puissiez améliorer beaucoup cela...

Code :

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Diagnostics;
public class MyData
{
    public int A { get; set; }
    public string B { get; set; }
    public DateTime C { get; set; }
    public decimal D { get; set; }
    public string E { get; set; }
    public int F { get; set; }
}

static class Program
{
    static void RunTest(List<MyData> data, string caption)
    {
        GC.Collect(GC.MaxGeneration, GCCollectionMode.Forced);
        GC.WaitForPendingFinalizers();
        GC.WaitForFullGCComplete();
        Stopwatch watch = Stopwatch.StartNew();
        for (int i = 0; i < 500; i++)
        {
            data.ToDataTable();
        }
        watch.Stop();
        Console.WriteLine(caption + "\t" + watch.ElapsedMilliseconds);
    }
    static void Main()
    {
        List<MyData> foos = new List<MyData>();
        for (int i = 0 ; i < 5000 ; i++ ){
            foos.Add(new MyData
            { // just gibberish...
                A = i,
                B = i.ToString(),
                C = DateTime.Now.AddSeconds(i),
                D = i,
                E = "hello",
                F = i * 2
            });
        }
        RunTest(foos, "Vanilla");
        Hyper.ComponentModel.HyperTypeDescriptionProvider.Add(
            typeof(MyData));
        RunTest(foos, "Hyper");
        Console.ReadLine(); // return to exit        
    }
}

Answer 2

J'ai dû modifier l'exemple de code de Marc Gravell pour gérer les types nullables et les valeurs nulles. J'ai inclus une version fonctionnelle ci-dessous. Merci Marc.

public static DataTable ToDataTable<T>(this IList<T> data)
{
    PropertyDescriptorCollection properties = 
        TypeDescriptor.GetProperties(typeof(T));
    DataTable table = new DataTable();
    foreach (PropertyDescriptor prop in properties)
        table.Columns.Add(prop.Name, Nullable.GetUnderlyingType(prop.PropertyType) ?? prop.PropertyType);
    foreach (T item in data)
    {
        DataRow row = table.NewRow();
        foreach (PropertyDescriptor prop in properties)
             row[prop.Name] = prop.GetValue(item) ?? DBNull.Value;
        table.Rows.Add(row);
    }
    return table;
}

Answer 3

Une petite modification de La réponse de Marc pour qu'il fonctionne avec des types de valeurs comme List<string> à la table de données :

public static DataTable ListToDataTable<T>(IList<T> data)
{
    DataTable table = new DataTable();

    //special handling for value types and string
    if (typeof(T).IsValueType || typeof(T).Equals(typeof(string)))
    {

        DataColumn dc = new DataColumn("Value", typeof(T));
        table.Columns.Add(dc);
        foreach (T item in data)
        {
            DataRow dr = table.NewRow();
            dr[0] = item;
            table.Rows.Add(dr);
        }
    }
    else
    {
        PropertyDescriptorCollection properties = TypeDescriptor.GetProperties(typeof(T));
        foreach (PropertyDescriptor prop in properties)
        {
            table.Columns.Add(prop.Name, Nullable.GetUnderlyingType(prop.PropertyType) ?? prop.PropertyType);
        }
        foreach (T item in data)
        {
            DataRow row = table.NewRow();
            foreach (PropertyDescriptor prop in properties)
            {
                try
                {
                    row[prop.Name] = prop.GetValue(item) ?? DBNull.Value;
                }
                catch (Exception ex)
                {
                    row[prop.Name] = DBNull.Value;
                }
            }
            table.Rows.Add(row);
        }
    }
    return table;
}

Answer 4

Il s'agit d'un simple mélange des solutions. Elle fonctionne avec les types Nullables.

public static DataTable ToDataTable<T>(this IList<T> list)
{
  PropertyDescriptorCollection props = TypeDescriptor.GetProperties(typeof(T));
  DataTable table = new DataTable();
  for (int i = 0; i < props.Count; i++)
  {
    PropertyDescriptor prop = props[i];
    table.Columns.Add(prop.Name, Nullable.GetUnderlyingType(prop.PropertyType) ?? prop.PropertyType);
  }
  object[] values = new object[props.Count];
  foreach (T item in list)
  {
    for (int i = 0; i < values.Length; i++)
      values[i] = props[i].GetValue(item) ?? DBNull.Value;
    table.Rows.Add(values);
  }
  return table;
}

Answer 5

Il n'existe pas de classe de conversion générique intégrée dans la bibliothèque de classes de base du framework .net qui puisse faire cela pour vous.

Mais Voici un site web avec le code pour faire cela en utilisant la réflexion.

Y en voici un autre