Im Bereich der modernen Softwareentwicklung ist effizientes Datenmanagement entscheidend. Egal, ob Sie eine einfache Anwendung oder ein komplexes Unternehmenssystem entwickeln, der effektive Zugriff, die Manipulation und das Speichern von Daten sind grundlegende Anforderungen. Entity Framework Core (EF Core) in C# ist ein leistungsstarkes 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, erforschen seine Merkmale, Fähigkeiten und Best Practices. Außerdem werfen wir einen Blick auf IronPDF für den Umgang mit PDF-Dokumenten von Iron Software Solutions, um PDF-Dokumente zu lesen, zu schreiben und zu verwalten. Wir werden ein praktisches Beispiel mit beiden Paketen erstellen.
Entity Framework Core ist eine Open-Source-, leichte und erweiterbare Version der beliebten Entity Framework-Datenzugriffstechnologie. Es ist plattformübergreifend ausgelegt und unterstützt verschiedene bestehende Datenbankserveranbieter, einschließlich SQL Server, SQLite, MySQL, PostgreSQL, Azure Cosmos DB und mehr. EF Core ist ein moderner objektrelationaler Mapper und folgt dem ORM-Muster (Objekt-Relationales Mapping), welches es Entwicklern ermöglicht, mit Datenbanken zu arbeiten, indem .NET-Objekte verwendet werden, was das Schreiben umständlicher SQL-Abfragen manuell überflüssig macht.
Modellierung von Entitäten: EF Core ermöglicht es Entwicklern, Datenmodelle mithilfe von Plain Old CLR Objects (POCOs) zu definieren. Diese Entitätsklassen repräsentieren Datenbanktabellen, wobei Eigenschaften den Tabellenspalten zugeordnet sind.
LINQ-Unterstützung: EF Core unterstützt nahtlos LINQ-Abfragen (Language Integrated Query), sodass Entwickler stark typisierte Abfragen gegen den SQL Server oder jede andere Datenbank mit vertrauter C#-Syntax schreiben können. Dies macht das Abfragen von Daten intuitiv und verringert die Wahrscheinlichkeit von Laufzeitfehlern. Auch rohe SQL-Anweisungen können zusammen mit LINQ-Abfragen verwendet werden.
Datenbankmigrationen: Das Verwalten von Änderungen am Datenbankschema kann eine Herausforderung sein, insbesondere in einer Teamumgebung. EF Core vereinfacht diesen Prozess, indem es Datenbankmigrationen bereitstellt, die es Entwicklern ermöglichen, inkrementelle Änderungen am Datenbankschema mit Code-First-Migrationen anzuwenden.
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 verwandte Daten bei Bedarf oder im Voraus geladen werden, je nach Anwendungsfall.
Transaktionsverwaltung: Transaktionen gewährleisten Datenkonsistenz und -integrität während Datenbankoperationen. EF Core erlaubt es Entwicklern, mit Transaktionen explizit zu arbeiten, sodass eine Gruppe von Datenbankoperationen entweder gemeinsam erfolgreich oder fehlschlagen.
Gleichzeitigkeitskontrolle: EF Core bietet integrierte Unterstützung zur Verwaltung von Konkurrenzkonflikten, sodass Entwickler Konflikte erkennen und beheben können, die auftreten können, wenn mehrere Benutzer versuchen, dieselben Daten gleichzeitig zu ändern.
Lassen Sie uns ein einfaches Beispiel für die Verwendung von SQLite mit Entity Framework Core (EF Core) in einer ASP.NET Core-Anwendung erstellen. Hier sind die Schritte:
Erstellen Sie Ihre Anwendung:
Erforderliche Pakete installieren:
Fügen Sie die folgenden NuGet-Pakete zu Ihrem Projekt hinzu:
Erstellen Sie Ihren Datenbankkontext:
Definieren Sie eine Klasse für Ihren Datenbankkontext (z.B. DatabaseContext), die von DbContext erbt.
Im OnConfiguring-Methode, setzen Sie den SQLite-Verbindungsstring:
public class DatabaseContext : DbContext
{
protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
{
optionsBuilder.UseSqlite("Filename=sample.db");
}
}Den Kontext erfassen:
In Ihrer Startup-Klasse, fügen Sie Ihren Kontext zu den Diensten hinzu:
public void ConfigureServices(IServiceCollection services)
{
services.AddEntityFrameworkSqlite().AddDbContext<DatabaseContext>();
}Datenbank beim Start erstellen:
Im Startup-Konstruktor, erstellen Sie Ihre Datenbank:
public Startup(IHostingEnvironment env)
{
using (var client = new DatabaseContext())
{
client.Database.EnsureCreated();
}
}Verwenden Sie SQLite in Ihrer Anwendung:
DatabaseContext, um mit der Datenbank zu interagieren.Denken Sie daran, dass dies ein einfaches Beispiel ist und es andere Möglichkeiten gibt, die Verbindungszeichenfolge zu konfigurieren und EF Core zu verwenden. Fühlen Sie sich frei, fortgeschrittenere Funktionen zu erkunden und dies an Ihre spezifischen Bedürfnisse anzupassen!
DbContext eingeschränkt halten: DbContext-Instanzen in EF Core sind so konzipiert, dass sie kurzlebig sind und typischerweise auf die Lebensdauer einer einzelnen Anfrage in Webanwendungen beschränkt sein sollten.
Verwenden Sie AsNoTracking für Leseoperationen: Bei lesenden Operationen, bei denen nicht erwartet wird, dass Entitäten geändert werden, verwenden Sie die AsNoTracking-Methode, um die Leistung zu verbessern, indem Sie das Änderungsverfolgungssystem umgehen.
Abfragen optimieren: Schreiben Sie effiziente Abfragen, indem Sie geeignete Indizierungs-, Paginierungs- und Filtertechniken verwenden, um die Menge der von der Datenbank abgerufenen Daten zu minimieren.
Vermeidung von N+1-Abfrageproblemen: Achten Sie auf das N+1-Abfrageproblem, bei dem für jedes verbundene Entität in einer Sammlung eine Abfrage ausgeführt wird. Verwenden Sie Eager Loading oder explizites Laden, um verwandte Daten effizient abzurufen.
Leistung überwachen: Überwachen Sie die Leistung von EF Core mithilfe von Tools wie Entity Framework Profiler oder eingehenden Log-Fähigkeiten, um Leistungsengpässe zu identifizieren und anzugehen.
IronPDF ist eine leistungsstarke C# PDF-Bibliothek, die es ermöglicht, PDF-Dokumente in .NET-Projekten zu erstellen, zu bearbeiten und Inhalte daraus zu extrahieren. Hier sind einige wichtige Funktionen:
HTML-zu-PDF-Konvertierung:
Bild- und Inhaltskonvertierung:
Bearbeitung und Manipulation:
Plattformübergreifende Unterstützung:
Erstellen Sie zunächst eine Konsolenanwendung mit Visual Studio wie unten beschrieben.
Projektname bereitstellen.
.NET plattformübergreifende Version bereitstellen.
Microsoft.EntityFrameworkCore-Paket installieren.
Microsoft.EntityFrameworkCore.SqlLite-Paket installieren.
IronPDF-Paket installieren.
Fügen Sie untenstehenden Code zu Program.cs hinzu.
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; }
}
}Einrichten des Renderers und Inhalts:
<h1>) und einer Unterüberschrift (<h2>), um Studenten zur Datenbank hinzuzufügen.Datenbankkontext und Hinzufügen von Studenten:
DatabaseContext-Klasse wird verwendet, um mit der Datenbank zu interagieren.client.Database.EnsureCreated(); stellt sicher, dass die Datenbank und die Tabelle existieren.client.Students.ExecuteDelete(); löscht alle vorhandenen Daten aus der Students-Tabelle.StudentName, DateOfBirth, Height, Weight und Grade.client.SaveChanges(); speichert die Änderungen in der Datenbank.Anzeige der Studenten:
client.Students.ToList(); ab.Rendering to PDF:
ChromePdfRenderer wird instanziiert.renderer.RenderHtmlAsPdf(content) in ein PDF gerendert.
Das IronPDF-Paket erfordert eine Lizenz zum Ausführen und Erstellen des PDFs. Fügen Sie den folgenden Code am Anfang der Anwendung hinzu, bevor das Paket aufgerufen wird.
IronPdf.License.LicenseKey = "IRONPDF-MYLICENSE-KEY";Imports IronPdf
IronPdf.License.LicenseKey = "IRONPDF-MYLICENSE-KEY"Eine Testlizenz ist auf der IronPDF-Lizenzierungsseite verfügbar.
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 Transaktionsverwaltung direkt aus der Box. Indem Sie die Best Practices befolgen und seine leistungsstarken Fähigkeiten nutzen, können Entwickler skalierbare und wartbare Anwendungen mühelos erstellen. Egal, ob Sie ein erfahrener Entwickler sind oder gerade anfangen, EF Core ist ein wertvolles Werkzeug in Ihrem Werkzeugkasten für modernen Datenzugriff in C#-Anwendungen. Andererseits ist IronPDF eine .NET-Bibliothek zur Erstellung, Bearbeitung und Darstellung von PDF-Dokumenten innerhalb Ihrer Anwendungen. Sie können es zusammen mit EF Core verwenden, um HTML-Inhalte (einschließlich Bildern) in eine PDF-Datei umzuwandeln.
Jacob Mellor ist Chief Technology Officer bei Iron Software und ein visionärer Ingenieur, der Pionierarbeit in der C# PDF-Technologie leistet. Als der ursprüngliche Entwickler hinter der Kern-Codebasis von Iron Software hat er die Produktarchitektur des Unternehmens seit seiner Gründung geprägt und es zusammen mit CEO Cameron Rimington in ein Unternehmen mit mehr als 50 Mitarbeitern verwandelt, das die NASA, Tesla und globale Regierungsbehörden beliefert.
IronPDF ist ein Teil der IRONSUITE
10 .NET-API-Produkte für Ihre Bürodokumente
Wenn Ihr PDF wie HTML aussehen soll, schnell.
