Einführung

Im Bereich der modernen Softwareentwicklung ist eine effiziente Datenverwaltung von entscheidender Bedeutung. Unabhängig davon, ob Sie eine einfache Anwendung oder ein komplexes Unternehmenssystem erstellen, ist der effektive Zugriff auf, die Bearbeitung und Speicherung von Daten eine grundlegende Voraussetzung. Entity Framework Kern (EF-Kern) in C# ist ein leistungsfähiges Werkzeug, das den Datenzugriff vereinfacht, indem es einen bequemen und objektorientierten Ansatz für die Arbeit mit Datenbanken bietet. In diesem Artikel tauchen wir in die Welt von EF Core ein und erkunden seine Funktionen, Möglichkeiten und Best Practices. Außerdem werden wir einen Blick werfen auf IronPDF von IronSoftware zum Lesen, Schreiben und Verwalten von PDF-Dokumenten. Wir werden ein praktisches Beispiel mit beiden Paketen erstellen.

Verstehen von Entity Framework Core

Entity Framework Core ist eine quelloffene, leichtgewichtige und erweiterbare Version der beliebten Datenzugriffstechnologie Entity Framework. Sie ist plattformübergreifend konzipiert und unterstützt verschiedene bestehende Datenbankserver-Anbieter wie SQL Server, SQLite, MySQL, PostgreSQL, Azure Cosmos DB und andere. EF Core ist ein moderner Objektdatenbank-Mapper und folgt dem ORM (Objekt-Relationales Mapping) patterns, die es Entwicklern ermöglichen, mit Datenbanken unter Verwendung von .NET-Objekten zu arbeiten, wodurch das manuelle Schreiben mühsamer SQL-Abfragen entfällt.

Hauptmerkmale von EF Core

1. Modeling Entities: EF Core ermöglicht Entwicklern die Definition von Datenmodellen mit Plain Old CLR Objects (POCOs). Diese Entitätsklassen stellen Datenbanktabellen dar, deren Eigenschaften auf Tabellenspalten abgebildet werden.

2. LINQ-Unterstützung: EF Core unterstützt nahtlos LINQ-Abfragen (Sprache Integrierte Abfrage)und ermöglicht es Entwicklern, stark typisierte Abfragen an den SQL Server oder jede andere Datenbank mit der vertrauten C#-Syntax zu schreiben. Dies macht die Abfrage von Daten intuitiv und verringert die Wahrscheinlichkeit von Laufzeitfehlern. Außerdem können rohe SQL-Anweisungen zusammen mit LINQ-Abfragen verwendet werden.

3. Datenbankmigrationen: Die Verwaltung von Datenbankschemaänderungen kann eine Herausforderung sein, insbesondere in einer Teamumgebung. EF Core vereinfacht diesen Prozess durch die Bereitstellung von Datenbankmigrationsfunktionen, die es Entwicklern ermöglichen, schrittweise Änderungen am Datenbankschema mithilfe von Code-First-Migrationen vorzunehmen.

4. Lazy Loading und Eager Loading: EF Core unterstützt sowohl Lazy-Loading- als auch Eager-Loading-Strategien, die es Entwicklern ermöglichen, die Leistung zu optimieren, indem sie verwandte Daten je nach Anwendungsfall bei Bedarf oder im Voraus laden.

5. Transaktionsmanagement: Transaktionen gewährleisten die Datenkonsistenz und -integrität bei Datenbankoperationen. EF Core ermöglicht es Entwicklern, explizit mit Transaktionen zu arbeiten, um sicherzustellen, dass eine Gruppe von Datenbankoperationen entweder gemeinsam erfolgreich ist oder fehlschlägt.

6. **EF Core bietet integrierte Unterstützung für die Verwaltung von Gleichzeitigkeitskonflikten, die es Entwicklern ermöglicht, Konflikte zu erkennen und zu lösen, die entstehen können, wenn mehrere Benutzer gleichzeitig versuchen, dieselben Daten zu ändern.

Erste Schritte mit EF Core

Lassen Sie uns ein grundlegendes Beispiel für die Verwendung von SQLite mit Entity Framework Core erstellen (EF-Kern) in einer ASP.NET Core-Anwendung. Hier sind die Schritte:

1. Erstellen Sie Ihre Bewerbung:

   • Beginnen Sie mit der Erstellung einer Konsolen- oder ASP.Net-Anwendung.

2. Notwendige Pakete installieren:

   • Fügen Sie die folgenden NuGet-Pakete zu Ihrem Projekt hinzu:

             * Microsoft.EntityFrameworkCore (version 1.0.0 oder höher)
     
         * Microsoft.EntityFrameworkCore.Sqlite (version 1.0.0 oder höher)

3. Erstellen Sie Ihren Datenbankkontext:

   • Definieren Sie eine Klasse für Ihren Datenbankkontext (z.B. DatabaseContext) die von DbContext erbt.

   • Legen Sie in der Methode OnConfiguring die SQLite-Verbindungszeichenfolge fest:

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. Register the Context:

   • Fügen Sie in Ihrer Startup-Klasse Ihren Kontext zu den Diensten hinzu:

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. Erstellen Sie die Datenbank beim Start:

   • Erstellen Sie im Startup-Konstruktor Ihre Datenbank:

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. Verwenden Sie SQLite in Ihrer Anwendung:

   • Jetzt können Sie SQLite in Ihrer ASP.NET Core-Anwendung über EF Core verwenden.
   • Definieren Sie Ihre Modelle und verwenden Sie den DatabaseContext, um mit der Datenbank zu interagieren.

   Denken Sie daran, dass dies ein einfaches Beispiel ist und dass es andere Möglichkeiten gibt, den Verbindungsstring zu konfigurieren und EF Core zu verwenden. Fühlen Sie sich frei, erweiterte Funktionen zu erforschen und diese an Ihre spezifischen Bedürfnisse anzupassen!

Best Practices für die EF Core-Entwicklung

1. Keep DbContext Scoped: DbContext-Instanzen in EF Core sind für eine kurze Lebensdauer ausgelegt und sollten typischerweise auf die Lebensdauer einer einzelnen Anfrage in Webanwendungen beschränkt werden.

2. Verwenden Sie AsNoTracking für Nur-Lese-Operationen: Wenn Sie Nur-Lese-Operationen durchführen, bei denen keine Änderungen an Entitäten zu erwarten sind, verwenden Sie die AsNoTracking-Methode, um die Leistung zu verbessern, indem Sie die Änderungsverfolgung umgehen.

3. Optimieren von Abfragen: Schreiben Sie effiziente Abfragen, indem Sie geeignete Indizierungs-, Paginierungs- und Filtertechniken verwenden, um die Menge der aus der Datenbank abgerufenen Daten zu minimieren.

4. Vermeiden Sie N+1-Abfrageprobleme: Achten Sie auf das N+1-Abfrageproblem, bei dem eine Abfrage für jede verwandte Entität in einer Sammlung ausgeführt wird. Verwenden Sie Eager Loading oder Explicit Loading, um Bezugsdaten effizient abzurufen.

5. Leistungsüberwachung: Überwachen Sie die Leistung von EF Core mit Tools wie Entity Framework Profiler oder den integrierten Protokollierungsfunktionen, um Leistungsengpässe zu erkennen und zu beheben.

Einführung in IronPDF

IronPDF ist eine leistungsstarke C#-PDF-Bibliothek, mit der Sie in .NET-Projekten PDF-Dokumente erzeugen, bearbeiten und Inhalte daraus extrahieren können. Hier sind einige der wichtigsten Merkmale:

1. HTML zu PDF Konvertierung:

   • Konvertieren Sie HTML-, CSS- und JavaScript-Inhalte in das PDF-Format.

   • Verwenden Sie die Chrome Rendering Engine für pixelgenaue PDFs.
   • Generieren Sie PDFs aus URLs, HTML-Dateien oder HTML-Strings.

2. Bild- und Inhaltskonvertierung:

   • Konvertieren Sie Bilder in und aus PDF.

   • Extrahieren Sie Text und Bilder aus vorhandenen PDF-Dateien.
   • Unterstützung für verschiedene Bildformate.

3. Bearbeitung und Manipulation:

   • Legen Sie Eigenschaften, Sicherheit und Berechtigungen für PDFs fest.

   • Digitale Signaturen hinzufügen.
   • Bearbeiten Sie die Metadaten und den Revisionsverlauf.

4. Plattformübergreifende Unterstützung:

   • Arbeitet mit .NET Core (8, 7, 6, 5 und 3.1+), .NET-Standard (2.0+)und .NET-Framework (4.6.2+).

   • Kompatibel mit Windows, Linux und macOS.
   • Verfügbar über NuGet für eine einfache Installation.

Erzeugen von PDF-Dokumenten mit IronPDF zusammen mit EF Core

Erstellen Sie zunächst eine Konsolenanwendung mit Visual Studio (siehe unten).

Geben Sie den Projektnamen an.

Bereitstellung einer plattformübergreifenden .NET-Version.

Installieren Sie das Paket Microsoft.EntityFrameworkCore.

Installieren Sie das Paket Microsoft.EntityFrameworkCore.SqlLite.

Installieren Sie das IronPDF-Paket.

Fügen Sie den folgenden Code zu Program.cs hinzu.

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

Code Erläuterung

1. Einrichten des Renderers und der Inhalte:

   • Der Code beginnt mit der Erstellung eines HTML-Inhaltsstrings. Sie beginnt mit einer Überschrift

     und fügt eine Unterüberschrift

     für das Hinzufügen von Schülern zur Datenbank hinzu.

   • Das Ziel scheint die Erstellung eines PDF-Dokuments mit IronPDF zu sein, das Informationen über die Schüler enthält.

2. Datenbankkontext und Hinzufügen von Schülern:

   • Die Klasse DatabaseContext wird für die Interaktion mit der Datenbank verwendet.

     * client.Database.EnsureCreated(); stellt sicher, dass die Datenbanktabelle existiert.
     
     * client.Students.ExecuteDelete(); löscht alle vorhandenen Daten in der Tabelle Schüler.

   • Ein neuer Student (bolzen1) wird mit Eigenschaften wie Schülername, Geburtsdatum, Größe, Gewicht und Note erstellt.

     * client.Students.Add(bolzen1); nimmt diesen Schüler in die Datenbank auf.

     • client.SaveChanges(); speichert die Änderungen in der Datenbank.

3. Anzeigende Schüler:

   • Der Code zeigt dann die Schüler in der Datenbank an.

   • Er ruft alle Schüler mit client.Students.ToList ab();.

   • Für jeden Schüler werden der Name, die ID, die Klasse, das Gewicht und die Größe ausgedruckt.
   • Zusätzlich wird die Funktion AddStudent aufgerufen (in diesem Ausschnitt nicht gezeigt).

4. Rendering in PDF:

   • Der ChromePdfRenderer wird instanziiert.

   • Der HTML-Inhalt wird mit renderer.RenderHtmlAsPdf in ein PDF-Dokument umgewandelt(inhalt).
   • Schließlich wird die PDF-Datei als "AwesomeEfCoreAndIronPdf.pdf" gespeichert.

Ausgabe

PDF

IronPDF-Lizenzierung

Das IronPDF-Paket erfordert eine Lizenz zum Ausführen und Erzeugen der PDF-Datei. Fügen Sie den folgenden Code am Anfang der Anwendung ein, bevor auf das Paket zugegriffen wird.

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

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

IRON VB CONVERTER ERROR developers@ironsoftware.com

Testlizenz ist verfügbar hier.

Schlussfolgerung

Entity Framework Core in C# bietet eine robuste und intuitive Möglichkeit, mit Datenbanken zu interagieren, und bietet Funktionen wie LINQ-Unterstützung, Datenbankmigrationen und Transaktionsmanagement von Haus aus. Durch die Einhaltung bewährter Verfahren und die Nutzung seiner leistungsstarken Funktionen können Entwickler problemlos skalierbare und wartbare Anwendungen erstellen. Egal, ob Sie ein erfahrener Entwickler sind oder gerade erst anfangen, EF Core ist ein wertvolles Werkzeug für den modernen Datenzugriff in C#-Anwendungen. IronPDF hingegen ist eine .NET-Bibliothek zur Erstellung, Bearbeitung und Wiedergabe von PDF-Dokumenten in Ihren Anwendungen. Sie können es zusammen mit EF Core verwenden, um HTML-Inhalte zu konvertieren (einschließlich Bilder) in eine PDF-Datei.