Coverting Liste de Dictionnaire DataTable

Nous sommes actuellement en train de le faire en parcourant chaque valeur de la liste et le dictionnaire:

private DataTable ChangeToDictionary(List<Dictionary<string,int>> list)
       {
           DataTable datatTableReturn = new DataTable();

           if (list.Count() > 0)
           {
               Dictionary<string, int> haeders = list.ElementAt(0);
               foreach (var colHead in haeders)
               {
                   datatTableReturn.Columns.Add(colHead.Key);
               }
           }

           foreach (var row in list)
           {
               DataRow dataRow = datatTableReturn.NewRow();
               foreach (var col in row)
               {

                   dataRow[col.Key] = col.Value;
               }
               datatTableReturn.Rows.Add(dataRow);
           }
           return datatTableReturn;

       }

Mais est-il une meilleure façon? Boucle à travers tant de fois ne se sent pas bien

Comme quoi? Toute autre approche serait éventuellement besoin pour aller au-dessus de toutes vos données.c.q. boucle sur les enregistrements. Je ne vois pas le réel problème que vous rencontrez. Vous n'aimez pas le code ci-dessus?
Cela fonctionne, mais comme dit est, il y a de mieux ,robuste
Pourquoi convertir une DataTable en premier lieu?
Parce que DataTable peut n'est pas là dans Seilverlight et parfois pas sérialisable, tandis que le retour de service
Que voulez-vous atteindre? Plus de vitesse? Réutilisabilité du code? Code de l'élégance? Pour commencer, ne pas utiliser de Count() méthode d'extension sur List<T>. Utilisation Count propriété plutôt.

OriginalL'auteur Simsons | 2013-03-08

.net c#casting datatable

Les réponses ci-dessus ne traitent pas la question de la dictionnaire ayant plus de 1 ligne. Cette solution résout le problème.

static DataTable ToDataTable(List<Dictionary<string, int>> list)
{
DataTable result = new DataTable();
if (list.Count == 0)
return result;
var columnNames = list.SelectMany(dict=>dict.Keys).Distinct();
result.Columns.AddRange(columnNames.Select(c=>new DataColumn(c)).ToArray());
foreach (Dictionary<string,int> item in list)
{
var row = result.NewRow();
foreach (var key in item.Keys)
{
row[key] = item[key];
}
result.Rows.Add(row);
}
return result;
}
static void Main(string[] args)
{
List<Dictionary<string, int>> it = new List<Dictionary<string, int>>();
Dictionary<string, int> dict = new Dictionary<string, int>();
dict.Add("a", 1);
dict.Add("b", 2);
dict.Add("c", 3);
it.Add(dict);
dict = new Dictionary<string, int>();
dict.Add("bob", 34);
dict.Add("tom", 37);
it.Add(dict);
dict = new Dictionary<string, int>();
dict.Add("Yip Yip", 8);
dict.Add("Yap Yap", 9);
it.Add(dict);
DataTable table = ToDictionary(it);
foreach (DataColumn col in table.Columns)
Console.Write("{0}\t", col.ColumnName);
Console.WriteLine();
foreach (DataRow row in table.Rows)
{
foreach (DataColumn column in table.Columns)
Console.Write("{0}\t", row[column].ToString());
Console.WriteLine();
}
Console.ReadLine();
}

Et la sortie ressemble à...

a       b       c       bob     tom     Yip Yip Yap Yap
1       2       3
34      37
8       9

votre sortie ne correspond pas à votre entrée.
(facepalm) oups. vous êtes de droite. J'ai utilisé accidentellement le mauvais itérateur. Édité avec correction.
Ce fut un gain de temps. Bravo!
pour remplir la table de données de Colonnes que vous le cloud aussi utiliser: foreach (KeyValuePair<string,string> entrée en myDictonary) { myTable.Les colonnes.Ajouter(à l'entrée.Key); }

OriginalL'auteur John Kraft

5

De la vitesse, de l'élégance et de la réutilisabilité ne vont pas ensemble. Vous choisissez toujours le plus important, et essayez d'équilibrer les deux autres.

Plus rapidement le code, plus laide qu'elle est.
Plus belle c'est, moins de réutilisables il est.

Voici un exemple de "élégant" solution, mais qui va avec, n'étant pas très lisible.
```
private static DataTable ToDictionary(List<Dictionary<string, int>> list)
{
DataTable result = new DataTable();
if (list.Count == 0)
return result;
result.Columns.AddRange(
list.First().Select(r => new DataColumn(r.Key)).ToArray()
);
list.ForEach(r => result.Rows.Add(r.Select(c => c.Value).Cast<object>().ToArray()));
return result;
}
```
vous parcourez la première ligne de deux fois.
et int est déjà un object
Il n'y a pas de relation fixe entre la performance et la lisibilité. Code rapide peut être un code lisible. La laideur est purement subjectif.
Peut-être que je devrais avoir dit "simple". Vous ne pouvez pas dire que la mise en œuvre du tri rapide est plus simple que la mise en œuvre du tri à bulles.

OriginalL'auteur Nikola Radosavljević

Essayez ceci:

    private DataTable GetDataTableFromDictionaries<T>(List<Dictionary<string, T>> list)
{
DataTable dataTable = new DataTable();
if (list == null || !list.Any()) return dataTable;
foreach (var column in list.First().Select(c => new DataColumn(c.Key, typeof(T))))
{
dataTable.Columns.Add(column);
}
foreach (var row in list.Select(
r =>
{
var dataRow = dataTable.NewRow();
r.ToList().ForEach(c => dataRow.SetField(c.Key, c.Value));
return dataRow;
}))
{
dataTable.Rows.Add(row);
}
return dataTable;
}

OriginalL'auteur Dustin Kingen

Comment au sujet de quelque chose comme le code ci-dessous?

Bon, parce qu'il parcourt chaque ligne exactement une fois. Il devrait être assez rapide, j'ai inclus des exceptions évidentes pour rendre le code plus sûr.

private static DataTable DictionariesToDataTable<T>(
IEnumerable<IDictionary<string, T>> source)
{
if (source == null)
{
return null;
}
var result = new DataTable();
using (var e = source.GetEnumerator())
{
if (!e.MoveNext())
{
return result;
}
if (e.Current.Keys.Length == 0)
{
throw new InvalidOperationException();
}
var length = e.Current.Keys.Length;
result.Columns.AddRange(
e.Current.Keys.Select(k => new DataColumn(k, typeof(T))).ToArray());
do
{
if (e.Current.Values.Length != length)
{
throw new InvalidOperationException();
}
result.Rows.Add(e.Current.Values);
}
while (e.MoveNext());
return result;
}
}

Vous n'êtes pas à l'élimination de l'agent recenseur.
vrai, il fixe.

OriginalL'auteur Jodrell

essayer ma solution, semble très propre pour moi:

private DataTable DictonarysToDataTable(List<Dictionary<string, int>> list) 
{
DataTable table = new DataTable();
foreach (Dictionary<string,string> dict in list)        //for every dictonary in the list ..
{
foreach (KeyValuePair<string,int> entry in dict) //for every entry in every dict
{
if (!myTable.Columns.Contains(entry.Key.ToString()))//if it doesn't exist yet
{
myTable.Columns.Add(entry.Key);                 //add all it's keys as columns to the table
}
}
table.Rows.Add(dict.Values.ToArray());              //add the the Values of every dict in the list as a new row
}
return table;
}

Edit:
Oh Snap, cela ne fonctionne que pour un Dictionnaire .. je ne pense pas qu'il par.
Mais maybie vous pouvez modifier à travailler pour une Liste de Dictionarys ..

OriginalL'auteur philx_x

Donner à ceci un essai s'il vous plaît

        DataTable table = new DataTable();
foreach (IDictionary<string, object> row in DeviceTypeReport)
{
foreach (KeyValuePair<string, object> entry in row)
{
if (!table.Columns.Contains(entry.Key.ToString()))
{
table.Columns.Add(entry.Key);
}
}
table.Rows.Add(row.Values.ToArray());
}

OriginalL'auteur Deathstalker

Vous devez vous connecter pour publier un commentaire.