Introduction

Dans le domaine du développement de logiciels modernes, une gestion efficace des données est cruciale. Qu'il s'agisse d'une simple application ou d'un système d'entreprise complexe, l'accès, la manipulation et l'enregistrement efficaces des données constituent une exigence fondamentale. Entity Framework Core (EF Core) en C# est un outil puissant qui simplifie l'accès aux données en offrant une approche pratique et orientée objet pour travailler avec les bases de données. Dans cet article, nous allons nous plonger dans le monde d'EF Core, en explorant ses fonctionnalités, ses capacités et ses meilleures pratiques. Nous examinerons également IronPDF de IronSoftware pour lire, écrire et gérer des documents PDF. Nous allons créer un exemple pratique avec les deux logiciels.

Comprendre Entity Framework Core

Entity Framework Core est une version open-source, légère et extensible de la célèbre technologie d'accès aux données Entity Framework. Il est conçu pour fonctionner sur plusieurs plates-formes et prend en charge divers fournisseurs de serveurs de bases de données existants, notamment SQL Server, SQLite, MySQL, PostgreSQL, Azure Cosmos DB et bien d'autres encore. EF Core est un mappeur de base de données objet moderne et suit le modèle ORM (Cartographie objet-relationnelle) permettant aux développeurs de travailler avec des bases de données en utilisant des objets .NET, ce qui élimine la nécessité d'écrire manuellement des requêtes SQL fastidieuses.

Principales caractéristiques d'EF Core

1. Modélisation d'entités: EF Core permet aux développeurs de définir des modèles de données à l'aide d'objets CLR classiques (POCOs). Ces classes d'entités représentent des tables de base de données, dont les propriétés correspondent aux colonnes de la table.

2. Prise en charge de LINQ: EF Core prend en charge les requêtes LINQ de manière transparente (Langue Requête intégrée)qui permet aux développeurs d'écrire des requêtes fortement typées contre le serveur SQL ou toute autre base de données en utilisant une syntaxe C# familière. Cela rend l'interrogation des données intuitive et réduit la probabilité d'erreurs d'exécution. En outre, des instructions SQL brutes peuvent être utilisées en même temps que des requêtes LINQ.

3. Les migrations de bases de données: La gestion des changements de schémas de bases de données peut être un défi, en particulier dans un environnement d'équipe. EF Core simplifie ce processus en fournissant des capacités de migration de base de données, permettant aux développeurs d'appliquer des changements incrémentaux au schéma de la base de données en utilisant des migrations de code d'abord.

4. **EF Core supporte à la fois les stratégies de chargement paresseux et de chargement impatient, permettant aux développeurs d'optimiser les performances en chargeant les données connexes à la demande ou en amont, en fonction du cas d'utilisation.

5. **Les transactions assurent la cohérence et l'intégrité des données pendant les opérations de la base de données. EF Core permet aux développeurs de travailler avec des transactions de manière explicite, en s'assurant qu'un groupe d'opérations de base de données réussissent ou échouent ensemble.

6. **EF Core fournit un support intégré pour la gestion des conflits de concurrence, permettant aux développeurs de détecter et de résoudre les conflits qui peuvent survenir lorsque plusieurs utilisateurs tentent de modifier les mêmes données simultanément.

Premiers pas avec EF Core

Créons un exemple basique d'utilisation de SQLite avec Entity Framework Core (EF Core) dans une application ASP.NET Core. Voici la marche à suivre :

1. Créer votre candidature :

   • Commencez par créer une application Console ou ASP.Net.

2. Installer les paquets nécessaires :

   • Ajoutez les paquets NuGet suivants à votre projet :

             * Microsoft.EntityFrameworkCore (version 1.0.0 ou ultérieure)
     
         * Microsoft.EntityFrameworkCore.Sqlite (version 1.0.0 ou ultérieure)

3. Créer votre contexte de base de données :

   • Définir une classe pour le contexte de la base de données (par exemple, DatabaseContext) qui hérite de DbContext.

   • Dans la méthode OnConfiguring, définissez la chaîne de connexion SQLite :

public class DatabaseContext : DbContext
        {
            protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
            {
                optionsBuilder.UseSqlite("Filename=sample.db");
            }
        }

public class DatabaseContext : DbContext
        {
            protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
            {
                optionsBuilder.UseSqlite("Filename=sample.db");
            }
        }

Public Class DatabaseContext
	Inherits DbContext

			Protected Overrides Sub OnConfiguring(ByVal optionsBuilder As DbContextOptionsBuilder)
				optionsBuilder.UseSqlite("Filename=sample.db")
			End Sub
End Class

4. Enregistrer le contexte :

   • Dans votre classe Startup, ajoutez votre contexte aux services :

public void ConfigureServices(IServiceCollection services)
        {
            services.AddEntityFrameworkSqlite().AddDbContext<DatabaseContext>();
        }

public void ConfigureServices(IServiceCollection services)
        {
            services.AddEntityFrameworkSqlite().AddDbContext<DatabaseContext>();
        }

Public Sub ConfigureServices(ByVal services As IServiceCollection)
			services.AddEntityFrameworkSqlite().AddDbContext(Of DatabaseContext)()
End Sub

5. Créer la base de données au démarrage :

   • Dans le constructeur Startup, créez votre base de données :

public Startup(IHostingEnvironment env)
        {
            using (var client = new DatabaseContext())
            {
                client.Database.EnsureCreated();
            }
        }

public Startup(IHostingEnvironment env)
        {
            using (var client = new DatabaseContext())
            {
                client.Database.EnsureCreated();
            }
        }

'INSTANT VB WARNING: The following constructor is declared outside of its associated class:
'ORIGINAL LINE: public Startup(IHostingEnvironment env)
Public Sub New(ByVal env As IHostingEnvironment)
			Using client = New DatabaseContext()
				client.Database.EnsureCreated()
			End Using
End Sub

6. Utiliser SQLite dans votre application :

   • Vous pouvez désormais utiliser SQLite dans votre application ASP.NET Core grâce à EF Core.
   • Définissez vos modèles et utilisez le DatabaseContext pour interagir avec la base de données.

   N'oubliez pas qu'il s'agit d'un exemple de base et qu'il existe d'autres façons de configurer la chaîne de connexion et d'utiliser EF Core. N'hésitez pas à explorer des fonctionnalités plus avancées et à adapter ce système à vos besoins spécifiques!

Meilleures pratiques pour le développement de EF Core

1. **Les instances de DbContext dans EF Core sont conçues pour être de courte durée et devraient typiquement être limitées à la durée de vie d'une seule requête dans les applications web.

2. Use AsNoTracking for Read-Only Operations: Lorsque vous effectuez des opérations en lecture seule pour lesquelles les entités ne sont pas censées être modifiées, utilisez la méthode AsNoTracking pour améliorer les performances en contournant le suivi des modifications.

3. Optimiser les requêtes: Rédiger des requêtes efficaces en utilisant les techniques d'indexation, de pagination et de filtrage appropriées afin de minimiser la quantité de données extraites de la base de données.

4. Évitez les problèmes de requêtes N+1: Faites attention au problème des requêtes N+1, où une requête est exécutée pour chaque entité apparentée dans une collection. Utilisez le chargement anticipé (eager loading) ou le chargement explicite (explicit loading) pour récupérer efficacement les données connexes.

5. Surveiller les performances: Surveiller les performances d'EF Core à l'aide d'outils tels que Entity Framework Profiler ou les capacités de journalisation intégrées afin d'identifier et d'éliminer les goulots d'étranglement en matière de performances.

Introduction à IronPDF

IronPDF est une puissante bibliothèque PDF C# qui vous permet de générer, d'éditer et d'extraire le contenu de documents PDF dans des projets .NET. En voici les principales caractéristiques :

1. Conversion HTML en PDF :

   • Convertissez du contenu HTML, CSS et JavaScript au format PDF.

   • Utilisez le moteur de rendu Chrome pour obtenir des PDF au pixel près.
   • Générer des PDF à partir d'URL, de fichiers HTML ou de chaînes HTML.

2. Conversion d'images et de contenus :

   • Convertissez des images depuis et vers des PDF.

   • Extraction de texte et d'images à partir de PDF existants.
   • Prise en charge de différents formats d'image.

3. Édition et manipulation :

   • Définir les propriétés, la sécurité et les autorisations pour les PDF.

   • Ajouter des signatures numériques.
   • Modifier les métadonnées et l'historique des révisions.

4. Support multiplateforme :

   • Fonctionne avec .NET Core (8, 7, 6, 5 et 3.1+), Standard .NET (2.0+)et le Framework .NET (4.6.2+).

   • Compatible avec Windows, Linux et macOS.
   • Disponible sur NuGet pour une installation facile.

Générer un document PDF en utilisant IronPDF avec EF Core

Pour commencer, créez une application Console à l'aide de Visual Studio, comme indiqué ci-dessous.

Fournir le nom du projet.

Fournir une version multiplateforme de .NET.

Installer le paquet Microsoft.EntityFrameworkCore.

Installer le paquet Microsoft.EntityFrameworkCore.SqlLite.

Installez le paquet IronPDF.

Ajoutez le code ci-dessous au fichier Program.cs.

using Microsoft.EntityFrameworkCore;
using System.Xml.Linq;
namespace CodeSample
{
    public class Program
    {
        public static void Main()
        {
            Console.WriteLine("-------------Demo EF core and IronPDF--------------");
            // Disable local disk access or cross-origin requests
            Installation.EnableWebSecurity = true;
            // Instantiate Renderer
            var renderer = new ChromePdfRenderer();
            var content = "<h1>Demo EF core and IronPDF</h1>";
            content += "<h2>Add Students</h2>";
            // Add Students to Database
            using (var client = new DatabaseContext())
            {
                client.Database.EnsureCreated(); // create table
                client.Students.ExecuteDelete(); // ensure clean table
                var stud1 = new Student { StudentName = "Bill", DateOfBirth = new DateTime(1990, 12, 01), Height = 5.45M, Weight = 56, Grade = 10 };
                content = AddStudent(content, stud1);
                var stud2 = new Student { StudentName = "Mike", DateOfBirth = new DateTime(1992, 12, 06), Height = 4.45M, Weight = 34, Grade = 8 };
                content = AddStudent(content, stud2);
                var stud3 = new Student { StudentName = "Peter", DateOfBirth = new DateTime(1990, 12, 03), Height = 5.0M, Weight = 50, Grade = 10 };
                content = AddStudent(content, stud3);
                var stud4 = new Student { StudentName = "Bob", DateOfBirth = new DateTime(1990, 12, 09), Height = 4.56M, Weight = 56, Grade = 10 };
                content = AddStudent(content, stud4);
                var stud5 = new Student { StudentName = "Harry", DateOfBirth = new DateTime(1990, 12, 21), Height = 5.6M, Weight = 56, Grade = 10 };
                content = AddStudent(content, stud5);
                var stud6 = new Student { StudentName = "Charle", DateOfBirth = new DateTime(1993, 12, 11), Height = 5.5M, Weight = 56, Grade = 7 };
                content = AddStudent(content, stud6);
                client.Students.Add(stud1);
                client.Students.Add(stud2);
                client.Students.Add(stud3);
                client.Students.Add(stud4);
                client.Students.Add(stud5);
                client.Students.Add(stud6);
                client.SaveChanges();
            }
            content += "<h2>Display Students in Database</h2>";
            // Display Students in Database
            using (var client = new DatabaseContext())
            {
                Console.WriteLine($"Display Stduents in Database");
                var students = client.Students.ToList();
                foreach (var student in students)
                {
                    Console.WriteLine($"Name= {student.StudentName},ID={student.StudentID},G={student.Grade},W={student.Weight},H={student.Height}");
                    content = AddStudent(content, student);
                }
            }           
            var pdf = renderer.RenderHtmlAsPdf(content);
            // Export to a file or Stream
            pdf.SaveAs("AwesomeEfCoreAndIronPdf.pdf");
        }
        private static string AddStudent(string content, Student student)
        {
            content += $"<p>Name = {student.StudentName},ID={student.StudentID},G={student.Grade},W={student.Weight},H={student.Height}</p>";
            return content;
        }
    }
    public class DatabaseContext : DbContext
    {
        public DbSet<Student> Students { get; set; }
        protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
        {
            optionsBuilder.UseSqlite("Filename=IronPdfDemo.db");
        }        
    }
    public class Student
    {
        public int StudentID { get; set; }
        public string StudentName { get; set; }
        public DateTime? DateOfBirth { get; set; }
        public decimal Height { get; set; }
        public float Weight { get; set; }
        public int Grade { get; set; }
    }
}

using Microsoft.EntityFrameworkCore;
using System.Xml.Linq;
namespace CodeSample
{
    public class Program
    {
        public static void Main()
        {
            Console.WriteLine("-------------Demo EF core and IronPDF--------------");
            // Disable local disk access or cross-origin requests
            Installation.EnableWebSecurity = true;
            // Instantiate Renderer
            var renderer = new ChromePdfRenderer();
            var content = "<h1>Demo EF core and IronPDF</h1>";
            content += "<h2>Add Students</h2>";
            // Add Students to Database
            using (var client = new DatabaseContext())
            {
                client.Database.EnsureCreated(); // create table
                client.Students.ExecuteDelete(); // ensure clean table
                var stud1 = new Student { StudentName = "Bill", DateOfBirth = new DateTime(1990, 12, 01), Height = 5.45M, Weight = 56, Grade = 10 };
                content = AddStudent(content, stud1);
                var stud2 = new Student { StudentName = "Mike", DateOfBirth = new DateTime(1992, 12, 06), Height = 4.45M, Weight = 34, Grade = 8 };
                content = AddStudent(content, stud2);
                var stud3 = new Student { StudentName = "Peter", DateOfBirth = new DateTime(1990, 12, 03), Height = 5.0M, Weight = 50, Grade = 10 };
                content = AddStudent(content, stud3);
                var stud4 = new Student { StudentName = "Bob", DateOfBirth = new DateTime(1990, 12, 09), Height = 4.56M, Weight = 56, Grade = 10 };
                content = AddStudent(content, stud4);
                var stud5 = new Student { StudentName = "Harry", DateOfBirth = new DateTime(1990, 12, 21), Height = 5.6M, Weight = 56, Grade = 10 };
                content = AddStudent(content, stud5);
                var stud6 = new Student { StudentName = "Charle", DateOfBirth = new DateTime(1993, 12, 11), Height = 5.5M, Weight = 56, Grade = 7 };
                content = AddStudent(content, stud6);
                client.Students.Add(stud1);
                client.Students.Add(stud2);
                client.Students.Add(stud3);
                client.Students.Add(stud4);
                client.Students.Add(stud5);
                client.Students.Add(stud6);
                client.SaveChanges();
            }
            content += "<h2>Display Students in Database</h2>";
            // Display Students in Database
            using (var client = new DatabaseContext())
            {
                Console.WriteLine($"Display Stduents in Database");
                var students = client.Students.ToList();
                foreach (var student in students)
                {
                    Console.WriteLine($"Name= {student.StudentName},ID={student.StudentID},G={student.Grade},W={student.Weight},H={student.Height}");
                    content = AddStudent(content, student);
                }
            }           
            var pdf = renderer.RenderHtmlAsPdf(content);
            // Export to a file or Stream
            pdf.SaveAs("AwesomeEfCoreAndIronPdf.pdf");
        }
        private static string AddStudent(string content, Student student)
        {
            content += $"<p>Name = {student.StudentName},ID={student.StudentID},G={student.Grade},W={student.Weight},H={student.Height}</p>";
            return content;
        }
    }
    public class DatabaseContext : DbContext
    {
        public DbSet<Student> Students { get; set; }
        protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
        {
            optionsBuilder.UseSqlite("Filename=IronPdfDemo.db");
        }        
    }
    public class Student
    {
        public int StudentID { get; set; }
        public string StudentName { get; set; }
        public DateTime? DateOfBirth { get; set; }
        public decimal Height { get; set; }
        public float Weight { get; set; }
        public int Grade { get; set; }
    }
}

IRON VB CONVERTER ERROR developers@ironsoftware.com

Explication du code

1. Configuration du moteur de rendu et du contenu:

   • Le code commence par créer une chaîne de contenu HTML. Il commence par un titre

     et ajoute un sous-titre

     pour l'ajout d'étudiants dans la base de données.

   • L'objectif semble être de générer un document PDF à l'aide d'IronPDF, qui contiendra des informations sur les étudiants.

2. Contexte de la base de données et ajout d'étudiants:

   • La classe DatabaseContext est utilisée pour interagir avec la base de données.

     * client.Database.EnsureCreated(); s'assure que la table de la base de données existe.
     
     * client.Students.ExecuteDelete(); efface toutes les données existantes dans le tableau des étudiants.

   • Un nouvel étudiant (étalon1) est créé avec des propriétés telles que le nom de l'élève, sa date de naissance, sa taille, son poids et son niveau scolaire.

     * client.Students.Add(étalon1); ajoute cet étudiant à la base de données.

     • client.SaveChanges(); enregistre les modifications dans la base de données.

3. Affichage des étudiants:

   • Le code affiche ensuite les élèves dans la base de données.

   • Il récupère tous les étudiants en utilisant client.Students.ToList();.

   • Pour chaque élève, il imprime son nom, sa carte d'identité, sa classe, son poids et sa taille.
   • En outre, la fonction AddStudent est appelée (non montré dans cet extrait).

4. Rendu au format PDF:

   • Le ChromePdfRenderer est instancié.

   • Le contenu HTML est transformé en PDF à l'aide de renderer.RenderHtmlAsPdf(contenu).
   • Enfin, le PDF est enregistré sous le nom de "AwesomeEfCoreAndIronPdf.pdf".

Sortie

PDF (EN ANGLAIS)

Licences d'IronPDF

Le paquet IronPDF nécessite une licence pour fonctionner et générer le PDF. Ajoutez le code ci-dessous au début de l'application avant l'accès au paquet.

IronPdf.License.LicenseKey = "IRONPDF-MYLICENSE-KEY";

IronPdf.License.LicenseKey = "IRONPDF-MYLICENSE-KEY";

IRON VB CONVERTER ERROR developers@ironsoftware.com

Une licence d'essai est disponible ici.

Conclusion

Entity Framework Core en C# offre un moyen robuste et intuitif d'interagir avec les bases de données, en proposant des fonctionnalités telles que la prise en charge de LINQ, les migrations de bases de données et la gestion des transactions. En suivant les meilleures pratiques et en tirant parti de ses puissantes capacités, les développeurs peuvent facilement créer des applications évolutives et faciles à maintenir. Que vous soyez un développeur chevronné ou que vous débutiez, EF Core est un outil précieux à avoir dans sa boîte à outils pour un accès moderne aux données dans les applications C#. D'autre part, IronPDF est une bibliothèque .NET pour la création, la manipulation et le rendu de documents PDF dans vos applications. Vous pouvez l'utiliser avec EF Core pour convertir du contenu HTML (y compris les images) dans un fichier PDF.