Icône de message
Passer au contenu du pied de page
  1. IronPDF
  2. Blog IronPDF
  3. .NET Aide
  4. csharp-groupby
.NET AIDE

C# Groupby (Comment ça fonctionne pour les développeurs)

Curtis Chau
Curtis Chau
Mis à jour:

En C#, la méthode GroupBy est un outil puissant qui organise les éléments d'une source de données en groupes basés sur une clé spécifiée. Cette méthode fait partie de LINQ (Language Integrated Query) et peut être utilisée pour regrouper des éléments par une seule ou plusieurs propriétés, ce qui la rend inestimable pour l'analyse et la manipulation des données. La méthode GroupBy simplifie les opérations complexes de données, permettant une organisation et une récupération efficaces des données basée sur des critères spécifiques. Nous discuterons de GroupBy et de la IronPDF Library dans ce blog.

Noções de base sur GroupBy

L'essence de la méthode GroupBy réside dans sa capacité à catégoriser les éléments d'une collection donnée en groupes selon une clé spécifiée. Cette propriété de clé détermine comment les éléments sont regroupés. Par exemple, vous pouvez regrouper une liste d'étudiants par leur valeur clé d'âge, créant ainsi des groupes d'étudiants du même âge. Chaque groupe est représenté par une valeur clé et une collection d'éléments qui partagent cette clé. La propriété de clé peut être n'importe quel objet, tel qu'une chaîne de caractères, un nombre, ou même un objet anonyme, offrant une flexibilité dans la manière dont les données sont regroupées.

Utilisation de GroupBy avec une syntaxe de méthode

En C#, il existe deux façons d'appliquer la méthode GroupBy : syntaxe de méthode et syntaxe de requête. La syntaxe de méthode utilise des expressions lambda pour définir la clé de regroupement et est une approche directe pour appliquer l'opération GroupBy.

Considérez l'exemple suivant utilisant la syntaxe de méthode pour regrouper une liste d'étudiants par leur âge :

using System;
using System.Collections.Generic;
using System.Linq;

public class Student
{
    public string Name { get; set; }
    public int Age { get; set; }
}

public class Program
{
    public static void Main()
    {
        List<Student> studentList = new List<Student>
        {
            new Student { Name = "Alice", Age = 20 },
            new Student { Name = "Bob", Age = 20 },
            new Student { Name = "Charlie", Age = 21 }
        };

        // Group students by their age using GroupBy
        var groupedResult = studentList.GroupBy(student => student.Age);

        foreach (var group in groupedResult)
        {
            Console.WriteLine($"Age Group: {group.Key}");

            foreach (var student in group)
            {
                Console.WriteLine($"Student Name: {student.Name}");
            }
        }
    }
}
using System;
using System.Collections.Generic;
using System.Linq;

public class Student
{
    public string Name { get; set; }
    public int Age { get; set; }
}

public class Program
{
    public static void Main()
    {
        List<Student> studentList = new List<Student>
        {
            new Student { Name = "Alice", Age = 20 },
            new Student { Name = "Bob", Age = 20 },
            new Student { Name = "Charlie", Age = 21 }
        };

        // Group students by their age using GroupBy
        var groupedResult = studentList.GroupBy(student => student.Age);

        foreach (var group in groupedResult)
        {
            Console.WriteLine($"Age Group: {group.Key}");

            foreach (var student in group)
            {
                Console.WriteLine($"Student Name: {student.Name}");
            }
        }
    }
}
Imports System
Imports System.Collections.Generic
Imports System.Linq

Public Class Student
	Public Property Name() As String
	Public Property Age() As Integer
End Class

Public Class Program
	Public Shared Sub Main()
		Dim studentList As New List(Of Student) From {
			New Student With {
				.Name = "Alice",
				.Age = 20
			},
			New Student With {
				.Name = "Bob",
				.Age = 20
			},
			New Student With {
				.Name = "Charlie",
				.Age = 21
			}
		}

		' Group students by their age using GroupBy
		Dim groupedResult = studentList.GroupBy(Function(student) student.Age)

		For Each group In groupedResult
			Console.WriteLine($"Age Group: {group.Key}")

			For Each student In group
				Console.WriteLine($"Student Name: {student.Name}")
			Next student
		Next group
	End Sub
End Class
$vbLabelText   $csharpLabel

C# GroupBy (Comment cela fonctionne pour les développeurs) : Figure 1 - Sortie de la console de l'exemple de code précédent

La méthode GroupBy de LINQ utilise une expression lambda pour regrouper les étudiants par leur valeur clé d'âge. group.Key représente le groupe d'âge, et la boucle foreach interne itère sur chaque étudiant au sein d'un groupe, imprimant leurs noms.

Utiliser GroupBy avec une syntaxe de requête

La syntaxe de requête offre une manière plus expressive de réaliser des opérations de regroupement, ressemblant aux requêtes de type SQL. Elle est particulièrement utile lorsque l'on traite des transformations de données complexes et des critères de regroupement multiples. Voici comment vous pouvez réaliser une fonctionnalité similaire à l'exemple précédent en utilisant une syntaxe de requête :

using System;
using System.Collections.Generic;
using System.Linq;

public static class Program
{
    public static void Main()
    {
        List<Student> studentList = new List<Student>
        {
            new Student { Name = "Alice", Age = 20 },
            new Student { Name = "Bob", Age = 20 },
            new Student { Name = "Charlie", Age = 21 }
        };

        // Group students by their age using query syntax
        var groupedResult = from student in studentList
                            group student by student.Age into ageGroup
                            select new { Age = ageGroup.Key, Students = ageGroup };

        foreach (var group in groupedResult)
        {
            Console.WriteLine($"Age Group: {group.Age}");

            foreach (var student in group.Students)
            {
                Console.WriteLine($"Student Name: {student.Name}");
            }
        }
    }
}
using System;
using System.Collections.Generic;
using System.Linq;

public static class Program
{
    public static void Main()
    {
        List<Student> studentList = new List<Student>
        {
            new Student { Name = "Alice", Age = 20 },
            new Student { Name = "Bob", Age = 20 },
            new Student { Name = "Charlie", Age = 21 }
        };

        // Group students by their age using query syntax
        var groupedResult = from student in studentList
                            group student by student.Age into ageGroup
                            select new { Age = ageGroup.Key, Students = ageGroup };

        foreach (var group in groupedResult)
        {
            Console.WriteLine($"Age Group: {group.Age}");

            foreach (var student in group.Students)
            {
                Console.WriteLine($"Student Name: {student.Name}");
            }
        }
    }
}
Imports System
Imports System.Collections.Generic
Imports System.Linq

Public Module Program
	Public Sub Main()
		Dim studentList As New List(Of Student) From {
			New Student With {
				.Name = "Alice",
				.Age = 20
			},
			New Student With {
				.Name = "Bob",
				.Age = 20
			},
			New Student With {
				.Name = "Charlie",
				.Age = 21
			}
		}

		' Group students by their age using query syntax
		Dim groupedResult = From student In studentList
			Group student By student.Age Into ageGroup = Group
			Select New With {
				Key .Age = Age,
				Key .Students = ageGroup
			}

		For Each group In groupedResult
			Console.WriteLine($"Age Group: {group.Age}")

			For Each student In group.Students
				Console.WriteLine($"Student Name: {student.Name}")
			Next student
		Next group
	End Sub
End Module
$vbLabelText   $csharpLabel

Dans cet extrait, la syntaxe de requête regroupe les étudiants par âge, similaire à la syntaxe de méthode mais avec une syntaxe différente que certains trouvent plus lisible.

Regroupement par plusieurs clés et propriétés

Une utilisation plus avancée de la méthode GroupBy implique le regroupement de données par plusieurs clés ou propriétés. Cette technique permet une analyse de données plus détaillée et une catégorisation basée sur plusieurs valeurs. En utilisant des objets anonymes ou des tuples, vous pouvez regrouper des éléments en fonction d'une combinaison de propriétés, offrant une structure de données plus riche pour vos applications.

Exemple : Regroupement d'étudiants par nom et âge

Considérez un scénario où vous devez regrouper les étudiants non seulement par leur valeur clé d'âge mais aussi par leur nom, pour identifier les étudiants ayant le même nom et les mêmes valeurs clé d'âge dans une liste. Cela peut être accompli en regroupant par un type anonyme contenant à la fois le nom et l'âge.

using System;
using System.Collections.Generic;
using System.Linq;

public static class Program
{
    public static void Main()
    {
        List<Student> studentList = new List<Student>
        {
            new Student { Name = "Alice", Age = 20 },
            new Student { Name = "Alice", Age = 21 },
            new Student { Name = "Bob", Age = 20 },
            new Student { Name = "Charlie", Age = 21 }
        };

        // Group students by both Name and Age using an anonymous type as the key
        var groupedResult = studentList.GroupBy(student => new { student.Name, student.Age });

        foreach (var group in groupedResult)
        {
            Console.WriteLine($"Group Key: Name = {group.Key.Name}, Age = {group.Key.Age}");

            foreach (var student in group)
            {
                Console.WriteLine($"Student Name: {student.Name}, Age: {student.Age}");
            }
        }
    }
}
using System;
using System.Collections.Generic;
using System.Linq;

public static class Program
{
    public static void Main()
    {
        List<Student> studentList = new List<Student>
        {
            new Student { Name = "Alice", Age = 20 },
            new Student { Name = "Alice", Age = 21 },
            new Student { Name = "Bob", Age = 20 },
            new Student { Name = "Charlie", Age = 21 }
        };

        // Group students by both Name and Age using an anonymous type as the key
        var groupedResult = studentList.GroupBy(student => new { student.Name, student.Age });

        foreach (var group in groupedResult)
        {
            Console.WriteLine($"Group Key: Name = {group.Key.Name}, Age = {group.Key.Age}");

            foreach (var student in group)
            {
                Console.WriteLine($"Student Name: {student.Name}, Age: {student.Age}");
            }
        }
    }
}
Imports System
Imports System.Collections.Generic
Imports System.Linq

Public Module Program
	Public Sub Main()
		Dim studentList As New List(Of Student) From {
			New Student With {
				.Name = "Alice",
				.Age = 20
			},
			New Student With {
				.Name = "Alice",
				.Age = 21
			},
			New Student With {
				.Name = "Bob",
				.Age = 20
			},
			New Student With {
				.Name = "Charlie",
				.Age = 21
			}
		}

		' Group students by both Name and Age using an anonymous type as the key
		Dim groupedResult = studentList.GroupBy(Function(student) New With {
			Key student.Name,
			Key student.Age
		})

		For Each group In groupedResult
			Console.WriteLine($"Group Key: Name = {group.Key.Name}, Age = {group.Key.Age}")

			For Each student In group
				Console.WriteLine($"Student Name: {student.Name}, Age: {student.Age}")
			Next student
		Next group
	End Sub
End Module
$vbLabelText   $csharpLabel

Dans cet exemple, les étudiants sont regroupés par nom et âge en utilisant un type anonyme comme clé. Cela résulte en des groupes où chaque combinaison unique de nom et d'âge est représentée comme un groupe distinct, démontrant la flexibilité de GroupBy pour des scénarios de regroupement complexes.

Informations supplémentaires sur GroupBy

Utilisation avancée de GroupBy

GroupBy devient encore plus puissant lorsque vous devez regrouper par plusieurs valeurs clé ou lorsque vous souhaitez effectuer des opérations supplémentaires sur les données regroupées, telles que le comptage, le filtrage ou le tri. Vous pouvez y parvenir en combinant GroupBy avec d'autres méthodes LINQ ou en utilisant des types anonymes pour regrouper par plusieurs propriétés.

Exécution différée dans GroupBy

Il est important de noter que GroupBy utilise une exécution différée, traitant les éléments lorsqu'ils sont itérés selon une clé donnée. Cela signifie que l'opération de regroupement n'est pas exécutée immédiatement lorsque la méthode GroupBy est appelée. Au lieu de cela, l'exécution est différée jusqu'à ce que les données regroupées soient itérées, comme dans une boucle foreach. Ce comportement est efficace car il permet des optimisations et des modifications supplémentaires des requêtes avant que les données ne soient finalement traitées.

Présentation de IronPDF aux projets C

C# GroupBy (Comment cela fonctionne pour les développeurs) : Figure 2 - Page web IronPDF

IronPDF est une bibliothèque complète pour C# qui permet aux développeurs de créer, manipuler et convertir des documents PDF au sein d'applications .NET. Cet outil puissant offre un large éventail de fonctionnalités, allant de la génération de PDFs à partir de HTML à l'édition de fichiers PDF existants et bien plus encore. IronPDF simplifie l'intégration des capacités PDF dans vos applications, ce qui en fait un atout précieux pour tout projet nécessitant une manipulation de PDF.

La fonctionnalité clé de IronPDF est sa conversion de HTML en PDF, garantissant que les mises en page et les styles sont préservés. Il génère des PDFs à partir de contenus web, ce qui le rend idéal pour les rapports, les factures et la documentation. Les fichiers HTML, les URLs et les chaînes HTML peuvent être convertis en PDFs sans problème.

using IronPdf;

class Program
{
    static void Main(string[] args)
    {
        var renderer = new ChromePdfRenderer();

        // 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");

        // 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");

        // 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();

        // 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");

        // 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");

        // 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()

		' 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")

		' 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")

		' 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
$vbLabelText   $csharpLabel

Génération de rapports PDF à partir de données regroupées

Étendons nos exemples précédents de regroupement des étudiants par valeur clé d'âge. Après avoir regroupé les étudiants, nous utiliserons IronPDF pour générer un rapport PDF qui liste ces groupes ainsi que les noms des étudiants dans chaque groupe.

using IronPdf;
using System;
using System.Collections.Generic;
using System.Linq;

public class Student
{
    public string Name { get; set; }
    public int Age { get; set; }
}

public class Program
{
    public static void Main()
    {
        // Initialize IronPDF license if applicable
        IronPdf.License.LicenseKey = "License";

        List<Student> studentList = new List<Student>
        {
            new Student { Name = "Alice", Age = 20 },
            new Student { Name = "Bob", Age = 20 },
            new Student { Name = "Charlie", Age = 21 },
            new Student { Name = "David", Age = 21 }
        };

        // Group students by their age
        var groupedResult = studentList.GroupBy(student => student.Age);

        // Create HTML content for the PDF report
        var htmlContent = "<h1>Student Report</h1>";

        foreach (var group in groupedResult)
        {
            htmlContent += $"<h2>Age Group: {group.Key}</h2><ul>";

            foreach (var student in group)
            {
                htmlContent += $"<li>{student.Name}</li>";
            }

            htmlContent += "</ul>";
        }

        // Initialize IronPDF renderer and generate PDF
        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderHtmlAsPdf(htmlContent);

        // Specify path to save the PDF file
        var outputPath = "StudentReport.pdf";
        pdf.SaveAs(outputPath);

        Console.WriteLine($"PDF report generated at {outputPath}");
    }
}
using IronPdf;
using System;
using System.Collections.Generic;
using System.Linq;

public class Student
{
    public string Name { get; set; }
    public int Age { get; set; }
}

public class Program
{
    public static void Main()
    {
        // Initialize IronPDF license if applicable
        IronPdf.License.LicenseKey = "License";

        List<Student> studentList = new List<Student>
        {
            new Student { Name = "Alice", Age = 20 },
            new Student { Name = "Bob", Age = 20 },
            new Student { Name = "Charlie", Age = 21 },
            new Student { Name = "David", Age = 21 }
        };

        // Group students by their age
        var groupedResult = studentList.GroupBy(student => student.Age);

        // Create HTML content for the PDF report
        var htmlContent = "<h1>Student Report</h1>";

        foreach (var group in groupedResult)
        {
            htmlContent += $"<h2>Age Group: {group.Key}</h2><ul>";

            foreach (var student in group)
            {
                htmlContent += $"<li>{student.Name}</li>";
            }

            htmlContent += "</ul>";
        }

        // Initialize IronPDF renderer and generate PDF
        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderHtmlAsPdf(htmlContent);

        // Specify path to save the PDF file
        var outputPath = "StudentReport.pdf";
        pdf.SaveAs(outputPath);

        Console.WriteLine($"PDF report generated at {outputPath}");
    }
}
Imports IronPdf
Imports System
Imports System.Collections.Generic
Imports System.Linq

Public Class Student
	Public Property Name() As String
	Public Property Age() As Integer
End Class

Public Class Program
	Public Shared Sub Main()
		' Initialize IronPDF license if applicable
		IronPdf.License.LicenseKey = "License"

		Dim studentList As New List(Of Student) From {
			New Student With {
				.Name = "Alice",
				.Age = 20
			},
			New Student With {
				.Name = "Bob",
				.Age = 20
			},
			New Student With {
				.Name = "Charlie",
				.Age = 21
			},
			New Student With {
				.Name = "David",
				.Age = 21
			}
		}

		' Group students by their age
		Dim groupedResult = studentList.GroupBy(Function(student) student.Age)

		' Create HTML content for the PDF report
		Dim htmlContent = "<h1>Student Report</h1>"

		For Each group In groupedResult
			htmlContent &= $"<h2>Age Group: {group.Key}</h2><ul>"

			For Each student In group
				htmlContent &= $"<li>{student.Name}</li>"
			Next student

			htmlContent &= "</ul>"
		Next group

		' Initialize IronPDF renderer and generate PDF
		Dim renderer = New ChromePdfRenderer()
		Dim pdf = renderer.RenderHtmlAsPdf(htmlContent)

		' Specify path to save the PDF file
		Dim outputPath = "StudentReport.pdf"
		pdf.SaveAs(outputPath)

		Console.WriteLine($"PDF report generated at {outputPath}")
	End Sub
End Class
$vbLabelText   $csharpLabel

Dans cet exemple, nous commençons par regrouper les étudiants par âge en utilisant la méthode GroupBy. Ensuite, nous construisons une chaîne HTML, que la méthode renvoie, qui formate ces données regroupées dans un rapport, avec des en-têtes pour chaque groupe d'âge et des listes de noms d'étudiants sous chaque groupe. La classe ChromePdfRenderer de IronPDF est ensuite utilisée pour convertir cette chaîne HTML en un document PDF. Le PDF résultant est enregistré dans un fichier, fournissant un rapport proprement formaté des étudiants regroupés par âge.

Sortie

Voici le PDF de sortie généré par le IronPDF :

C# GroupBy (Comment cela fonctionne pour les développeurs) : Figure 3 - PDF de sortie de l'exemple de code précédent

Conclusion

C# GroupBy (Comment cela fonctionne pour les développeurs) : Figure 4 - Plan de licence IronPDF

La méthode GroupBy en C# est un outil polyvalent et puissant pour regrouper des données sur la base de clés spécifiées. Que vous préfériez la syntaxe de méthode avec des expressions lambda ou la syntaxe de requête plus déclarative, GroupBy vous permet d'organiser des structures de données complexes de manière gérable et lisible. En maîtrisant GroupBy et d'autres méthodes LINQ, vous pouvez considérablement améliorer votre capacité à manipuler et analyser les données dans vos applications C#.

IronPDF propose une version d'essai gratuite pour ceux qui souhaitent explorer ses fonctionnalités avant de s'engager dans un achat. Pour ceux qui sont prêts à l'intégrer à leurs projets, la licence commence à $799, ce qui en fait un investissement rentable pour des manipulations et des générations de PDF de qualité professionnelle dans les applications C#.

Questions Fréquemment Posées

Qu'est-ce que la méthode GroupBy en C# ?

En C#, la méthode GroupBy est une fonctionnalité LINQ qui organise les éléments d'une source de données en groupes basés sur une clé spécifiée, simplifiant l'analyse et la manipulation des données.

Comment fonctionne la méthode GroupBy avec la syntaxe de méthode en C# ?

En utilisant la syntaxe de méthode avec des expressions lambda, la méthode GroupBy regroupe les éléments par une clé spécifiée. Par exemple, vous pouvez regrouper une liste d'étudiants par âge, créant ainsi des groupes d'étudiants d'âges similaires.

Peut-on utiliser la syntaxe de requête avec la méthode GroupBy ?

Oui, la syntaxe de requête peut être utilisée avec la méthode GroupBy, offrant une manière plus proche du SQL et expressive pour effectuer des opérations de regroupement, spécialement pour les transformations de données complexes.

Comment pouvez-vous regrouper des données avec plusieurs clés en utilisant GroupBy ?

Vous pouvez regrouper des données par plusieurs clés en utilisant des objets anonymes ou des tuples, permettant une analyse plus détaillée des données basée sur des combinaisons de propriétés.

Qu'est-ce que l'exécution différée dans le contexte de GroupBy ?

L'exécution différée signifie que l'opération GroupBy n'est pas exécutée immédiatement lorsqu'elle est appelée. Elle est traitée lorsque les données groupées sont itérées, autorisant les optimisations de requête.

Comment pouvez-vous générer des rapports PDF à partir de données groupées en utilisant C# ?

Vous pouvez utiliser IronPDF pour convertir des chaînes HTML, qui formatent les données groupées en rapports, en documents PDF. Cela permet de générer facilement des rapports PDF soigneusement formatés à partir de données groupées avec GroupBy.

Quelles sont quelques techniques de regroupement avancées en C# ?

Les techniques de regroupement avancées en C# impliquent l'utilisation d'objets anonymes ou de tuples pour regrouper les données par plusieurs clés ou propriétés, améliorant la capacité à effectuer une analyse complexe des données.

Comment IronPDF peut-il aider à la gestion de PDF de qualité professionnelle dans les applications .NET ?

IronPDF fournit aux développeurs C# des outils pour créer et manipuler des documents PDF, y compris générer des rapports PDF à partir de contenu HTML. Cela aide à gérer efficacement des PDF de qualité professionnelle dans les applications .NET.

Comment pouvez-vous convertir HTML en PDF en C# ?

Vous pouvez utiliser la méthode RenderHtmlAsPdf d'IronPDF pour convertir des chaînes HTML en PDFs. Vous pouvez également convertir des fichiers HTML en PDFs en utilisant RenderHtmlFileAsPdf.

Curtis Chau
Curtis Chau
  Discutez maintenant avec l'équipe d'ingénierie
Rédacteur technique

Curtis Chau détient un baccalauréat en informatique (Université de Carleton) et se spécialise dans le développement front-end avec expertise en Node.js, TypeScript, JavaScript et React. Passionné par la création d'interfaces utilisateur intuitives et esthétiquement plaisantes, Curtis aime travailler avec des frameworks modernes ...

Lire la suite

Articles connexes

Essai de 30 jours → Produit complet. Pas de limites. Pas de carte. Démarrer l'essai gratuit