C# Datatable to List (Comment ça marche pour les développeurs)

Dans le domaine de la programmation avec C#, il arrive souvent que l'on ait besoin de convertir un DataTable en une liste. Alors que de nombreux novices se heurtent à cette tâche, ils se heurtent souvent à des réponses qui ne sont tout simplement pas assez complètes. Ce tutoriel vise à combler cette lacune et à fournir un guide clair sur la façon de convertir DataTable en liste en C#.

Qu'est-ce qu'une "table de données" ?

Avant de plonger dans le processus de conversion, il est essentiel de comprendre ce qu'est une DataTable est. En C#, un objet DataTable est une représentation d'une table de base de données en mémoire avec des lignes et des colonnes. Il fait partie de l'espace de noms System.Data.

Pour les besoins de ce tutoriel, utilisons un exemple de Tableau de Données nommé Tableau de Données dt. DataTable dt peut être visualisé comme dans l'exemple de code ci-dessous :

DataTable dt = new DataTable();
dt.Columns.Add("ID", typeof(int));
dt.Columns.Add("Category", typeof(string));
dt.Rows.Add(1, "Electronics");
dt.Rows.Add(2, "Books");

DataTable dt = new DataTable();
dt.Columns.Add("ID", typeof(int));
dt.Columns.Add("Category", typeof(string));
dt.Rows.Add(1, "Electronics");
dt.Rows.Add(2, "Books");

Dim dt As New DataTable()
dt.Columns.Add("ID", GetType(Integer))
dt.Columns.Add("Category", GetType(String))
dt.Rows.Add(1, "Electronics")
dt.Rows.Add(2, "Books")

Commencer avec la conversion

Vous avez donc votre DataTable dt, et vous êtes en train de vous demander comment convertir ce tableau. Ne vous inquiétez pas ; c'est une question qui montre un effort de recherche. Il existe principalement deux méthodes pour convertir DataTable en liste :

1. Utilisation LINQ (Langue Requête intégrée)
2. Utilisation de la boucle classique foreach

Conversion à l'aide de LINQ

La méthode LINQ est un outil puissant de C# qui permet d'interroger des collections de manière déclarative. Voyons comment procéder.

Définissez une méthode comme dans l'exemple de code ci-dessous :

private static void LinqMethod(DataTable dt)
{
    var list = dt.AsEnumerable().Select(row =>
        new 
        {
            ID = row.Field<int>("ID"),
            Category = row.Field<string>("Category")
        }).ToList();
}

private static void LinqMethod(DataTable dt)
{
    var list = dt.AsEnumerable().Select(row =>
        new 
        {
            ID = row.Field<int>("ID"),
            Category = row.Field<string>("Category")
        }).ToList();
}

Private Shared Sub LinqMethod(ByVal dt As DataTable)
	Dim list = dt.AsEnumerable().Select(Function(row) New With {
		Key .ID = row.Field(Of Integer)("ID"),
		Key .Category = row.Field(Of String)("Category")
	}).ToList()
End Sub

Notez l'utilisation de var list, var row, et de linqmethod. Dans le code ci-dessus, la méthode d'extension AsEnumerable() est appelée sur le Tableau de données dt. Cela nous permet d'utiliser LINQ sur chaque ligne DataRow de la DataTable.

Conversion à l'aide de la boucle Foreach

La boucle foreach est la méthode éprouvée pour itérer sur des collections en C#. Cette méthode peut sembler un peu plus longue, mais elle est facile à comprendre et à mettre en œuvre.

Commençons :

private static void ForeachMethod(DataTable dt)
{
    List<Category> list = new List<Category>();
    // Iterates through each row within the data table
    foreach (DataRow row in dt.Rows)
    {
        var category = new Category();
        category.ID = Convert.ToInt32(row ["ID"]);
        category.Name = row ["Category"].ToString();
        list.Add(category);
    }
}

private static void ForeachMethod(DataTable dt)
{
    List<Category> list = new List<Category>();
    // Iterates through each row within the data table
    foreach (DataRow row in dt.Rows)
    {
        var category = new Category();
        category.ID = Convert.ToInt32(row ["ID"]);
        category.Name = row ["Category"].ToString();
        list.Add(category);
    }
}

Private Shared Sub ForeachMethod(ByVal dt As DataTable)
	Dim list As New List(Of Category)()
	' Iterates through each row within the data table
	For Each row As DataRow In dt.Rows
		Dim category As New Category()
		category.ID = Convert.ToInt32(row ("ID"))
		category.Name = row ("Category").ToString()
		list.Add(category)
	Next row
End Sub

Dans le fichier private static void ForeachMethod(), la Table de Données est itérée en utilisant une boucle foreach. Pour chaque ligne datarow, un nouvel objet var category est instancié et ajouté à la var list.

Pour représenter la catégorie, vous aurez besoin d'une classe :

public class Category
{
    public int ID { get; set; }
    public string Name { get; set; }
}

public class Category
{
    public int ID { get; set; }
    public string Name { get; set; }
}

Public Class Category
	Public Property ID() As Integer
	Public Property Name() As String
End Class

Approfondissement des techniques de conversion avancées

Après avoir maîtrisé les bases de la conversion d'un DataTable en liste en C#, il existe plusieurs techniques et considérations avancées qui permettent d'optimiser ce processus et de l'adapter à des scénarios plus complexes. Approfondissons certaines de ces techniques.

L'une des limites des méthodes décrites précédemment est qu'elles sont spécifiques à notre classe Category. Et si vous pouviez écrire une méthode pour convertir n'importe quelle Table de données en une liste d'objets génériques ?

Utiliser Reflection pour convertir DataTable en liste

La réflexion est un outil puissant en C# qui vous permet d'inspecter les métadonnées des types au moment de l'exécution. Exploitons sa puissance

private static List<T> ConvertDataTableToList<T>(DataTable dt) where T : new()
{
    List<T> list = new List<T>();
    foreach (DataRow row in dt.Rows)
    {
        T obj = new T();
        foreach (DataColumn col in dt.Columns)
        {
            var prop = obj.GetType().GetProperty(col.ColumnName);
            if (prop != null && row [col] != DBNull.Value)
                prop.SetValue(obj, row [col]);
        }
        list.Add(obj);
    }
    return list;
}

private static List<T> ConvertDataTableToList<T>(DataTable dt) where T : new()
{
    List<T> list = new List<T>();
    foreach (DataRow row in dt.Rows)
    {
        T obj = new T();
        foreach (DataColumn col in dt.Columns)
        {
            var prop = obj.GetType().GetProperty(col.ColumnName);
            if (prop != null && row [col] != DBNull.Value)
                prop.SetValue(obj, row [col]);
        }
        list.Add(obj);
    }
    return list;
}

Private Shared Function ConvertDataTableToList(Of T As New)(ByVal dt As DataTable) As List(Of T)
	Dim list As New List(Of T)()
	For Each row As DataRow In dt.Rows
		Dim obj As New T()
		For Each col As DataColumn In dt.Columns
			Dim prop = obj.GetType().GetProperty(col.ColumnName)
			If prop IsNot Nothing AndAlso row (col) IsNot DBNull.Value Then
				prop.SetValue(obj, row (col))
			End If
		Next col
		list.Add(obj)
	Next row
	Return list
End Function

Cette méthode private static utilise la réflexion, en itérant sur chaque DataRow row et chaque colonne du DataTable dt. Pour chaque colonne, il recherche une propriété correspondante (var prop) dans l'objet générique et fixe sa valeur. Cette approche permet d'obtenir une méthode hautement réutilisable qui peut convertir n'importe quel DataTable en une liste d'objets génériques.

Utilisation

Pour utiliser le code ci-dessus, il suffit d'appeler la méthode en spécifiant le type :

List<Category> categories = ConvertDataTableToList<Category>(dt);

List<Category> categories = ConvertDataTableToList<Category>(dt);

Dim categories As List(Of Category) = ConvertDataTableToList(Of Category)(dt)

Avec cette méthode, vous n'êtes plus limité à la conversion de tableaux de données spécifiques en types d'objets spécifiques. Au contraire, vous disposez d'un outil polyvalent capable de gérer une grande variété de scénarios de données.

Considérations sur les performances

Bien que la méthode de réflexion soit puissante, il convient de noter qu'elle peut être plus lente, en particulier avec des tableaux de données volumineux. Il est toujours essentiel de mesurer les performances et de les mettre en balance avec les avantages de la réutilisation et de la maintenabilité du code.

Iron Suite Toolkit pour les développeurs .NET

Bien que nous nous soyons penchés sur les subtilités de la conversion de DataTable en listes en C#, il arrive parfois que des outils externes simplifient notre processus de développement, en particulier lorsqu'il s'agit d'opérations plus complexes. C'est là que Iron Suite entre en jeu.

Iron Suite est une suite complète d'outils conçus pour faciliter la vie des développeurs .NET. Des opérations PDF aux manipulations Excel en passant par la reconnaissance optique de caractères (OCR) et la lecture de codes-barres, Iron Suite offre une myriade de possibilités. Décortiquons les composants d'Iron Suite et voyons comment ils peuvent compléter nos opérations DataTable.

IronPDF : La centrale PDF

Lorsqu'il s'agit de travailler avec des PDF en C#, IronPDF change la donne. Imaginez que vous ayez converti votre DataTable en une liste et que vous deviez ensuite générer un rapport PDF à partir de cette liste. IronPDF peut créer, modifier et extraire sans effort des données de documents PDF, rationalisant ainsi le processus de traduction de vos informations dérivées de tables de données en rapports d'aspect professionnel.

La principale caractéristique d'IronPDF est son HTML vers PDF en veillant à ce que les mises en page et les styles soient préservés. Il génère des PDF à partir de contenus web, qui conviennent pour les rapports, les factures et la documentation. Vous pouvez convertir des fichiers HTML, des URL et des chaînes HTML en fichiers PDF sans effort.

using IronPdf;
class Program
{
    static void Main(string[] args)
    {
        var renderer = new ChromePdfRenderer();
        // 1. Convert HTML String to PDF
        var htmlContent = "<h1>Hello, IronPDF!</h1><p>This is a PDF from an HTML string.</p>";
        var pdfFromHtmlString = renderer.RenderHtmlAsPdf(htmlContent);
        pdfFromHtmlString.SaveAs("HTMLStringToPDF.pdf");
        // 2. Convert HTML File to PDF
        var htmlFilePath = "path_to_your_html_file.html"; // Specify the path to your HTML file
        var pdfFromHtmlFile = renderer.RenderHtmlFileAsPdf(htmlFilePath);
        pdfFromHtmlFile.SaveAs("HTMLFileToPDF.pdf");
        // 3. Convert URL to PDF
        var url = "http://ironpdf.com"; // Specify the URL
        var pdfFromUrl = renderer.RenderUrlAsPdf(url);
        pdfFromUrl.SaveAs("URLToPDF.pdf");
    }
}

using IronPdf;
class Program
{
    static void Main(string[] args)
    {
        var renderer = new ChromePdfRenderer();
        // 1. Convert HTML String to PDF
        var htmlContent = "<h1>Hello, IronPDF!</h1><p>This is a PDF from an HTML string.</p>";
        var pdfFromHtmlString = renderer.RenderHtmlAsPdf(htmlContent);
        pdfFromHtmlString.SaveAs("HTMLStringToPDF.pdf");
        // 2. Convert HTML File to PDF
        var htmlFilePath = "path_to_your_html_file.html"; // Specify the path to your HTML file
        var pdfFromHtmlFile = renderer.RenderHtmlFileAsPdf(htmlFilePath);
        pdfFromHtmlFile.SaveAs("HTMLFileToPDF.pdf");
        // 3. Convert URL to PDF
        var url = "http://ironpdf.com"; // Specify the URL
        var pdfFromUrl = renderer.RenderUrlAsPdf(url);
        pdfFromUrl.SaveAs("URLToPDF.pdf");
    }
}

Imports IronPdf
Friend Class Program
	Shared Sub Main(ByVal args() As String)
		Dim renderer = New ChromePdfRenderer()
		' 1. Convert HTML String to PDF
		Dim htmlContent = "<h1>Hello, IronPDF!</h1><p>This is a PDF from an HTML string.</p>"
		Dim pdfFromHtmlString = renderer.RenderHtmlAsPdf(htmlContent)
		pdfFromHtmlString.SaveAs("HTMLStringToPDF.pdf")
		' 2. Convert HTML File to PDF
		Dim htmlFilePath = "path_to_your_html_file.html" ' Specify the path to your HTML file
		Dim pdfFromHtmlFile = renderer.RenderHtmlFileAsPdf(htmlFilePath)
		pdfFromHtmlFile.SaveAs("HTMLFileToPDF.pdf")
		' 3. Convert URL to PDF
		Dim url = "http://ironpdf.com" ' Specify the URL
		Dim pdfFromUrl = renderer.RenderUrlAsPdf(url)
		pdfFromUrl.SaveAs("URLToPDF.pdf")
	End Sub
End Class

IronXL : Exceller dans les opérations Excel

Si votre conversion DataTable vous amène à effectuer des tâches liées à Excel, IronXL est l'outil à utiliser. Ce produit permet de lire, d'éditer et de créer des feuilles de calcul Excel en toute transparence. Avec la conversion des tableaux de données en listes, l'exportation de vos données vers un format Excel devient incroyablement simple avec IronXL.

IronOCR : Rendre le texte reconnaissable

Il peut arriver que votre DataTable se compose de données basées sur des images, ou que vous ayez besoin d'extraire du texte à partir d'images. C'est ici que IronOCR brille. Il permet aux développeurs .NET de lire du texte à partir d'images, ce qui en fait un outil complémentaire si vos opérations de conversion DataTable impliquent des images contenant des informations textuelles.

IronBarcode : Lire entre les lignes

Enfin, IronBarcode est l'outil de référence pour toutes les opérations de code-barres dans vos applications. Supposons que votre DataTable ou la liste en laquelle vous l'avez convertie consiste en des informations sur des produits avec des codes-barres. Dans ce cas, IronBarcode fournit un mécanisme efficace pour lire et générer des codes-barres, comblant ainsi le fossé entre les données brutes du produit et les informations scannables du code-barres.

Conclusion

Bien que les méthodes manuelles de manipulation et de conversion de DataTable soient essentielles pour tout développeur C#, l'intégration d'outils puissants tels que ceux fournis par Iron Suite peut améliorer de façon exponentielle votre productivité et vos capacités. Il est intéressant de noter que chaque licence de produit commence à partir de $749, et ce qui est encore plus attrayant, c'est que chaque produit offre une essai gratuit. Si vous envisagez d'investir dans ces outils, une offre alléchante vous est proposée : vous pouvez acquérir l'ensemble de l'Iron Suite pour le prix de deux produits seulement. L'adoption de ces solutions complètes peut sans aucun doute améliorer la qualité et l'efficacité de vos efforts de développement .NET.