Entity Framework Core (Comment ça fonctionne pour les développeurs)

Comprendre Entity Framework Core

Entity Framework Core est une version open-source, légère et extensible de la populaire technologie d'accès aux données Entity Framework. Il est conçu pour fonctionner multiplateforme, prenant en charge divers fournisseurs de serveurs de base de données existants, y compris SQL Server, SQLite, MySQL, PostgreSQL, Azure Cosmos DB, et plus encore. EF Core est un mappeur d'objets modernes pour base de données et suit le modèle ORM (Object-Relational Mapping), permettant aux développeurs de travailler avec des bases de données en utilisant des objets .NET, ce qui élimine le besoin d'écrire manuellement des requêtes SQL fastidieuses.

Caractéristiques clés d'EF Core

1. Modélisation des entités : EF Core permet aux développeurs de définir des modèles de données en utilisant des objets CLR classiques (POCOs). Ces classes d'entités représentent des tables de base de données, avec des propriétés mappant aux colonnes des tables.

2. Support de LINQ : EF Core prend en charge de manière transparente les requêtes LINQ (Language Integrated Query), permettant aux développeurs d'écrire des requêtes fortement typées contre le SQL Server ou toute autre base de données en utilisant la syntaxe C# familière. Cela rend les requêtes de données intuitives et réduit la probabilité d'erreurs d'exécution. De plus, des instructions SQL brutes peuvent être utilisées conjointement avec des requêtes LINQ.

3. Migrations de base de données : Gérer les changements de schéma de base de données peut être difficile, surtout 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émentiels au schéma de base de données en utilisant des migrations code-first.

4. Chargement lent et chargé de façon anticipée : EF Core prend en charge les stratégies de chargement lent et chargé de façon anticipée, permettant aux développeurs d'optimiser les performances en chargeant les données connexes à la demande ou à l'avance, selon le cas d'utilisation.

5. Gestion des transactions : Les transactions assurent la cohérence et l'intégrité des données lors des opérations de base de données. EF Core permet aux développeurs de travailler explicitement avec des transactions, garantissant qu'un groupe d'opérations de base de données réussit ou échoue ensemble.

6. Contrôle de la concurrence : EF Core offre 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.

Démarrage 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 les étapes :

1. Créez votre application :

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

2. Installez les packages nécessaires :

   • Ajoutez les packages NuGet suivants à votre projet :

     • Microsoft.EntityFrameworkCore (version 1.0.0 ou plus)
     • Microsoft.EntityFrameworkCore.Sqlite (version 1.0.0 ou plus)

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

   • Définissez une classe pour votre contexte de 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

     $vbLabelText   $csharpLabel

4. Enregistrez 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

     $vbLabelText   $csharpLabel

5. Créez 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

     $vbLabelText   $csharpLabel

6. Utilisez SQLite dans votre application :

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

N'oubliez pas que c'est un exemple basique, et qu'il existe d'autres moyens 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 cela à vos besoins spécifiques !

Meilleures pratiques pour le développement EF Core

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

2. Utilisez AsNoTracking pour les opérations en lecture seule : Lors de l'exécution d'opérations en lecture seule où l'on ne s'attend pas à ce que les entités soient modifiées, utilisez la méthode AsNoTracking pour améliorer les performances en contournant le suivi des modifications.

3. Optimiser les requêtes : Écrivez des requêtes efficaces en utilisant des techniques appropriées d'indexation, de pagination et de filtrage pour minimiser la quantité de données récupérées de la base de données.

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

5. Surveillez les performances : Surveillez les performances d'EF Core en utilisant des outils comme Entity Framework Profiler ou les capacités de journalisation intégrées pour identifier et résoudre les goulots d'étranglement des performances.

Introduction à IronPDF

IronPDF est une bibliothèque PDF C# puissante qui vous permet de générer, modifier et extraire le contenu des documents PDF dans des projets .NET. Voici quelques caractéristiques clés :

1. Conversion HTML en PDF :

   • Convertir le contenu HTML, CSS et JavaScript au format PDF.
   • Utilisez le moteur de rendu Chrome pour des PDF pixel-parfaits.
   • Générez des PDFs à partir d'URL, de fichiers HTML ou de chaînes HTML.

2. Conversion d'Images et de Contenu :

   • Convertir des images vers et depuis le PDF.
   • Extraire du texte et des images à partir de PDF existants.
   • Supporte divers formats d'image.

3. Édition et Manipulation :

   • Définir les propriétés, la sécurité et les permissions pour les PDF.
   • Ajouter des signatures numériques.
   • Éditez les métadonnées et l'historique des révisions.

4. Support Multiplateforme :

   • Fonctionne avec .NET Core (8, 7, 6, 5, et 3.1+), .NET Standard (2.0+), et .NET Framework (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 ainsi qu'EF Core

Pour commencer, créez une application Console en utilisant Visual Studio comme ci-dessous.

Fournir le nom du projet.

Fournir la version multiplateforme .NET.

Installer le package Microsoft.EntityFrameworkCore.

Installer le package Microsoft.EntityFrameworkCore.SqlLite.

Installer le package IronPDF.

Ajoutez le code ci-dessous à Program.cs.

using IronPdf;
using Microsoft.EntityFrameworkCore;
using System;
using System.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();

            // Start with initial HTML content
            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 if it doesn't exist
                client.Students.ExecuteDelete(); // Ensure the table is clean

                // Define students
                var students = new[]
                {
                    new Student { StudentName = "Bill", DateOfBirth = new DateTime(1990, 12, 01), Height = 5.45M, Weight = 56, Grade = 10 },
                    new Student { StudentName = "Mike", DateOfBirth = new DateTime(1992, 12, 06), Height = 4.45M, Weight = 34, Grade = 8 },
                    new Student { StudentName = "Peter", DateOfBirth = new DateTime(1990, 12, 03), Height = 5.0M, Weight = 50, Grade = 10 },
                    new Student { StudentName = "Bob", DateOfBirth = new DateTime(1990, 12, 09), Height = 4.56M, Weight = 56, Grade = 10 },
                    new Student { StudentName = "Harry", DateOfBirth = new DateTime(1990, 12, 21), Height = 5.6M, Weight = 56, Grade = 10 },
                    new Student { StudentName = "Charle", DateOfBirth = new DateTime(1993, 12, 11), Height = 5.5M, Weight = 56, Grade = 7 }
                };

                // Add students to database
                client.Students.AddRange(students);
                client.SaveChanges();

                // Add students info to HTML content
                foreach (var student in students)
                {
                    content = AddStudent(content, student);
                }
            }

            content += "<h2>Display Students in Database</h2>";

            // Display Students in Database
            using (var client = new DatabaseContext())
            {
                Console.WriteLine($"Displaying Students in Database:");
                var students = client.Students.ToList();

                foreach (var student in students)
                {
                    Console.WriteLine($"Name= {student.StudentName}, ID={student.StudentID}, Grade={student.Grade}, Weight={student.Weight}, Height={student.Height}");
                    content = AddStudent(content, student);
                }
            }           

            // Render HTML content to PDF
            var pdf = renderer.RenderHtmlAsPdf(content);

            // Export to a file or stream
            pdf.SaveAs("AwesomeEfCoreAndIronPdf.pdf");
        }

        // Helper method to add student info as HTML content
        private static string AddStudent(string content, Student student)
        {
            content += $"<p>Name = {student.StudentName}, ID={student.StudentID}, Grade={student.Grade}, Weight={student.Weight}, Height={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 IronPdf;
using Microsoft.EntityFrameworkCore;
using System;
using System.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();

            // Start with initial HTML content
            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 if it doesn't exist
                client.Students.ExecuteDelete(); // Ensure the table is clean

                // Define students
                var students = new[]
                {
                    new Student { StudentName = "Bill", DateOfBirth = new DateTime(1990, 12, 01), Height = 5.45M, Weight = 56, Grade = 10 },
                    new Student { StudentName = "Mike", DateOfBirth = new DateTime(1992, 12, 06), Height = 4.45M, Weight = 34, Grade = 8 },
                    new Student { StudentName = "Peter", DateOfBirth = new DateTime(1990, 12, 03), Height = 5.0M, Weight = 50, Grade = 10 },
                    new Student { StudentName = "Bob", DateOfBirth = new DateTime(1990, 12, 09), Height = 4.56M, Weight = 56, Grade = 10 },
                    new Student { StudentName = "Harry", DateOfBirth = new DateTime(1990, 12, 21), Height = 5.6M, Weight = 56, Grade = 10 },
                    new Student { StudentName = "Charle", DateOfBirth = new DateTime(1993, 12, 11), Height = 5.5M, Weight = 56, Grade = 7 }
                };

                // Add students to database
                client.Students.AddRange(students);
                client.SaveChanges();

                // Add students info to HTML content
                foreach (var student in students)
                {
                    content = AddStudent(content, student);
                }
            }

            content += "<h2>Display Students in Database</h2>";

            // Display Students in Database
            using (var client = new DatabaseContext())
            {
                Console.WriteLine($"Displaying Students in Database:");
                var students = client.Students.ToList();

                foreach (var student in students)
                {
                    Console.WriteLine($"Name= {student.StudentName}, ID={student.StudentID}, Grade={student.Grade}, Weight={student.Weight}, Height={student.Height}");
                    content = AddStudent(content, student);
                }
            }           

            // Render HTML content to PDF
            var pdf = renderer.RenderHtmlAsPdf(content);

            // Export to a file or stream
            pdf.SaveAs("AwesomeEfCoreAndIronPdf.pdf");
        }

        // Helper method to add student info as HTML content
        private static string AddStudent(string content, Student student)
        {
            content += $"<p>Name = {student.StudentName}, ID={student.StudentID}, Grade={student.Grade}, Weight={student.Weight}, Height={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; }
    }
}

Imports IronPdf
Imports Microsoft.EntityFrameworkCore
Imports System
Imports System.Linq

Namespace CodeSample
	Public Class Program
		Public Shared Sub Main()
			Console.WriteLine("-------------Demo EF core and IronPDF--------------")

			' Disable local disk access or cross-origin requests
			Installation.EnableWebSecurity = True

			' Instantiate Renderer
			Dim renderer = New ChromePdfRenderer()

			' Start with initial HTML content
			Dim content = "<h1>Demo EF core and IronPDF</h1>"
			content &= "<h2>Add Students</h2>"

			' Add Students to Database
			Using client = New DatabaseContext()
				client.Database.EnsureCreated() ' Create table if it doesn't exist
				client.Students.ExecuteDelete() ' Ensure the table is clean

				' Define students
				Dim students = {
					New Student With {
						.StudentName = "Bill",
						.DateOfBirth = New DateTime(1990, 12, 01),
						.Height = 5.45D,
						.Weight = 56,
						.Grade = 10
					},
					New Student With {
						.StudentName = "Mike",
						.DateOfBirth = New DateTime(1992, 12, 06),
						.Height = 4.45D,
						.Weight = 34,
						.Grade = 8
					},
					New Student With {
						.StudentName = "Peter",
						.DateOfBirth = New DateTime(1990, 12, 03),
						.Height = 5.0D,
						.Weight = 50,
						.Grade = 10
					},
					New Student With {
						.StudentName = "Bob",
						.DateOfBirth = New DateTime(1990, 12, 09),
						.Height = 4.56D,
						.Weight = 56,
						.Grade = 10
					},
					New Student With {
						.StudentName = "Harry",
						.DateOfBirth = New DateTime(1990, 12, 21),
						.Height = 5.6D,
						.Weight = 56,
						.Grade = 10
					},
					New Student With {
						.StudentName = "Charle",
						.DateOfBirth = New DateTime(1993, 12, 11),
						.Height = 5.5D,
						.Weight = 56,
						.Grade = 7
					}
				}

				' Add students to database
				client.Students.AddRange(students)
				client.SaveChanges()

				' Add students info to HTML content
				For Each student In students
					content = AddStudent(content, student)
				Next student
			End Using

			content &= "<h2>Display Students in Database</h2>"

			' Display Students in Database
			Using client = New DatabaseContext()
				Console.WriteLine($"Displaying Students in Database:")
				Dim students = client.Students.ToList()

				For Each student In students
					Console.WriteLine($"Name= {student.StudentName}, ID={student.StudentID}, Grade={student.Grade}, Weight={student.Weight}, Height={student.Height}")
					content = AddStudent(content, student)
				Next student
			End Using

			' Render HTML content to PDF
			Dim pdf = renderer.RenderHtmlAsPdf(content)

			' Export to a file or stream
			pdf.SaveAs("AwesomeEfCoreAndIronPdf.pdf")
		End Sub

		' Helper method to add student info as HTML content
		Private Shared Function AddStudent(ByVal content As String, ByVal student As Student) As String
			content &= $"<p>Name = {student.StudentName}, ID={student.StudentID}, Grade={student.Grade}, Weight={student.Weight}, Height={student.Height}</p>"
			Return content
		End Function
	End Class

	Public Class DatabaseContext
		Inherits DbContext

		Public Property Students() As DbSet(Of Student)

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

	Public Class Student
		Public Property StudentID() As Integer
		Public Property StudentName() As String
		Public Property DateOfBirth() As DateTime?
		Public Property Height() As Decimal
		Public Property Weight() As Single
		Public Property Grade() As Integer
	End Class
End Namespace

Sortie

Licences IronPDF

Le package 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 que le paquet ne soit accédé.

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 sur la Page de licences IronPDF.

Conclusion

Entity Framework Core en C# offre un moyen robuste et intuitif d'interagir avec les bases de données, offrant des fonctionnalités comme le support de LINQ, les migrations de base de données et la gestion des transactions prêtes à l'emploi. En suivant les meilleures pratiques et en tirant parti de ses puissantes capacités, les développeurs peuvent construire des applications évolutives et maintenables facilement. Que vous soyez un développeur chevronné ou que vous soyez juste en train de commencer, EF Core est un outil précieux à avoir dans votre boîte à outils pour l'accès moderne aux données dans les applications C#. D'autre part, IronPDF est une bibliothèque .NET pour créer, manipuler, et rendre des documents PDF dans vos applications. Vous pouvez l'utiliser avec EF Core pour convertir du contenu HTML (y compris des images) en un fichier PDF.