VERGLEICH

Tall Components gegen IronPDF: Leitfaden für einen technischen Vergleich

Aktualisiert:

Große Komponentenvs IronPDF: .NET PDF Library Comparison Guide

Wenn .NET-Entwickler PDF-Bibliotheken für die Dokumentenerzeugung und -bearbeitung evaluieren, ist das Verständnis der aktuellen Landschaft entscheidend. Große Komponenten(TallPDF, PDFKit) war einst ein anerkannter Anbieter im Bereich der C#-PDF-SDKs, aber erhebliche Änderungen in Bezug auf die Verfügbarkeit und den Support haben die Art und Weise, wie Teams an die PDF-Entwicklung herangehen, verändert. Dieser technische Vergleich untersucht Große Komponentenund IronPDF, um professionellen Entwicklern, Architekten und technischen Entscheidungsträgern zu helfen, die Unterschiede zu verstehen und eine fundierte Wahl für ihre Anforderungen an die PDF-Erzeugung zu treffen.

Große Komponentenverstehen (TallPDF, PDFKit)

Tall Components war in der Vergangenheit ein beliebtes Werkzeug unter Entwicklern, um PDFs programmatisch in C# zu erzeugen und zu bearbeiten. Die Werkzeuge ermöglichen die Erstellung, Bearbeitung und das Rendering von PDF-Dateien und bieten Funktionen für diejenigen, die sich auf XML-basierte Dokumenten-Workflows konzentrieren.

Kritisches Status-Update: Große Komponentenwurde von Apryse übernommen und der Verkauf neuer Produkte wurde eingestellt. Auf der offiziellen Website wird deutlich darauf hingewiesen, dass keine neuen Lizenzen mehr verkauft werden und potenzielle Nutzer aufgefordert werden, stattdessen iText SDK zu verwenden. Die Einstellung neuer Verkäufe macht Große Komponentenzu einer Sackgasse für Entwickler, die sich langfristig an eine PDF-Lösung binden wollen.

Die Bibliothek verwendet einen XML-basierten Ansatz zur Dokumentenerstellung mit einem Abschnitt/Absatz-Modell, das eine manuelle Layout-Verwaltung und Koordinatenpositionierung erfordert.

IronPDFverstehen

IronPDF steht im Gegensatz dazu als aktiv entwickelte Lösung für das PDF-Management. Die Bibliothek verwendet einen modernen HTML/CSS-first-Ansatz, der von einer Chromium-Rendering-Engine unterstützt wird und es Entwicklern ermöglicht, PDF-Dokumente mit vertrauten Webtechnologien zu erstellen.

IronPDF wird über ein einziges NuGet-Paket installiert, das eine unkomplizierte Bereitstellung ermöglicht und GDI+-Abhängigkeitsprobleme vermeidet, die bei anderen PDF-Lösungen zu Komplikationen führen können.

Schlüsselbegrenzungen von Tall Components

Tall Components ist zwar historisch gesehen zuverlässig, stößt aber an einige entscheidende Grenzen:

Produktabkündigung: Mit der Übernahme durch Apryse wurde die Akquisition neuer Benutzer eingestellt. Auf der offiziellen Website wird deutlich darauf hingewiesen, dass keine neuen Lizenzen mehr verkauft werden und potenzielle Nutzer aufgefordert werden, stattdessen iText SDK zu verwenden.

Fehlende HTML-zu-PDF-Unterstützung: Im Gegensatz zu einigen seiner Gegenstücke unterstützt Große Komponentenkeine direkte HTML-zu-PDF-Konvertierung. Entwickler auf Support-Plattformen haben bestätigt, dass Große Komponentenkeine PDF-Erstellung aus HTTP-Antworten oder HTML-Inhalten unterstützt.

Rendering-Probleme: Dokumentierte Probleme zeigen umfangreiche Rendering-Fehler, einschließlich der Darstellung leerer Seiten, fehlender Grafiken, Unzuverlässigkeit bei JPEG-Bildern und falscher Schriftdarstellung. Diese Fehler stellen eine große Hürde für Benutzer dar, die bei der Erstellung von PDF-Dateien Genauigkeit und Präzision wünschen.

Kein Support oder Updates: Da das Produkt nicht mehr weiterentwickelt wird, sind keine Fehlerbehebungen, Sicherheitspatches oder Updates verfügbar. Bekannte Rendering-Fehler wurden vor der Abkündigung nie behoben.

Legacy Architecture: Entwickelt für eine andere Ära der .NET-Entwicklung mit XML-basierter Dokumentenerstellung, die für moderne Web-Workflows völlig ungeeignet ist.

Übersicht über den Funktionsvergleich

Feature Große Komponenten IronPDF
Aktueller Verkaufsstatus Eingestellt für neue Verkäufe Aktiv entwickelt und verkauft
HTML-zu-PDF-Unterstützung Nein Ja (HTML5/CSS3 mit Chromium)
Wiedergabetreue Bekannte Bugs und Probleme Bewährte Verlässlichkeit
Installation Komplex, manuell Einfach mit NuGet
Kundenbetreuung Übergang zum iText SDK Aktive Unterstützung und Gemeinschaft
Künftige Benutzerfreundlichkeit End-of-Life Langfristige Rentabilität

HTML zu PDF Konvertierung

Die Fähigkeit, HTML in PDF zu konvertieren, offenbart eine grundlegende Fähigkeitslücke zwischen diesen Bibliotheken.

Komponenten HTML nach PDF

Tall Components bietet keine echte HTML-zu-PDF-Konvertierung. Stattdessen wird ein auf Fragmenten basierender Ansatz verwendet, der HTML als Textinhalt behandelt:

// NuGet: Install-Package TallComponents.PDF.Kit
using TallComponents.PDF.Kit;
using System.IO;

class Program
{
    static void Main()
    {
        // Create a new document
        using (Document document = new Document())
        {
            string html = "<html><body><h1>Hello World</h1><p>This is a PDF from HTML.</p></body></html>";

            // Create HTML fragment
            Fragment fragment = Fragment.FromText(html);

            // Add to document
            Section section = document.Sections.Add();
            section.Fragments.Add(fragment);

            // Save to file
            using (FileStream fs = new FileStream("output.pdf", FileMode.Create))
            {
                document.Write(fs);
            }
        }
    }
}
// NuGet: Install-Package TallComponents.PDF.Kit
using TallComponents.PDF.Kit;
using System.IO;

class Program
{
    static void Main()
    {
        // Create a new document
        using (Document document = new Document())
        {
            string html = "<html><body><h1>Hello World</h1><p>This is a PDF from HTML.</p></body></html>";

            // Create HTML fragment
            Fragment fragment = Fragment.FromText(html);

            // Add to document
            Section section = document.Sections.Add();
            section.Fragments.Add(fragment);

            // Save to file
            using (FileStream fs = new FileStream("output.pdf", FileMode.Create))
            {
                document.Write(fs);
            }
        }
    }
}
IRON VB CONVERTER ERROR developers@ironsoftware.com
$vbLabelText   $csharpLabel

Dieser Ansatz:

  • Verwendet Fragment.FromText(), das HTML nicht semantisch wiedergibt
  • Erfordert manuelle Verwaltung von Abschnitten und Fragmenten
  • Unterstützt kein CSS-Styling oder moderne Web-Layouts
  • Erfordert explizite FileStream-Verwaltung und -Entsorgung

IronPDFHTML zu PDF

IronPDF bietet eine echte HTML-zu-PDF-Konvertierung unter Verwendung der Chromium-Rendering-Engine:

// NuGet: Install-Package IronPdf
using IronPdf;

class Program
{
    static void Main()
    {
        // Create a PDF from HTML string
        var renderer = new ChromePdfRenderer();
        string html = "<html><body><h1>Hello World</h1><p>This is a PDF from HTML.</p></body></html>";

        var pdf = renderer.RenderHtmlAsPdf(html);
        pdf.SaveAs("output.pdf");
    }
}
// NuGet: Install-Package IronPdf
using IronPdf;

class Program
{
    static void Main()
    {
        // Create a PDF from HTML string
        var renderer = new ChromePdfRenderer();
        string html = "<html><body><h1>Hello World</h1><p>This is a PDF from HTML.</p></body></html>";

        var pdf = renderer.RenderHtmlAsPdf(html);
        pdf.SaveAs("output.pdf");
    }
}
IRON VB CONVERTER ERROR developers@ironsoftware.com
$vbLabelText   $csharpLabel

Die RenderHtmlAsPdf-Methode konvertiert HTML-Inhalte mit vollständiger CSS3-Unterstützung, JavaScript-Ausführung und genauer Darstellung moderner Web-Layouts. Keine manuelle Abschnittsverwaltung, keine Stream-Verarbeitung - die Chromium-Engine erledigt alles automatisch.

PDF Merging Operations

Das Kombinieren mehrerer PDF-Dokumente zeigt erhebliche Unterschiede in der Komplexität der APIs auf.

Komponenten PDF Merge

Tall Components erfordert die manuelle Iteration und das Klonen von Seiten:

// NuGet: Install-Package TallComponents.PDF.Kit
using TallComponents.PDF.Kit;
using System.IO;

class Program
{
    static void Main()
    {
        // Create output document
        using (Document outputDoc = new Document())
        {
            // Load first PDF
            using (FileStream fs1 = new FileStream("document1.pdf", FileMode.Open))
            using (Document doc1 = new Document(fs1))
            {
                foreach (Page page in doc1.Pages)
                {
                    outputDoc.Pages.Add(page.Clone());
                }
            }

            // Load second PDF
            using (FileStream fs2 = new FileStream("document2.pdf", FileMode.Open))
            using (Document doc2 = new Document(fs2))
            {
                foreach (Page page in doc2.Pages)
                {
                    outputDoc.Pages.Add(page.Clone());
                }
            }

            // Save merged document
            using (FileStream output = new FileStream("merged.pdf", FileMode.Create))
            {
                outputDoc.Write(output);
            }
        }
    }
}
// NuGet: Install-Package TallComponents.PDF.Kit
using TallComponents.PDF.Kit;
using System.IO;

class Program
{
    static void Main()
    {
        // Create output document
        using (Document outputDoc = new Document())
        {
            // Load first PDF
            using (FileStream fs1 = new FileStream("document1.pdf", FileMode.Open))
            using (Document doc1 = new Document(fs1))
            {
                foreach (Page page in doc1.Pages)
                {
                    outputDoc.Pages.Add(page.Clone());
                }
            }

            // Load second PDF
            using (FileStream fs2 = new FileStream("document2.pdf", FileMode.Open))
            using (Document doc2 = new Document(fs2))
            {
                foreach (Page page in doc2.Pages)
                {
                    outputDoc.Pages.Add(page.Clone());
                }
            }

            // Save merged document
            using (FileStream output = new FileStream("merged.pdf", FileMode.Create))
            {
                outputDoc.Write(output);
            }
        }
    }
}
IRON VB CONVERTER ERROR developers@ironsoftware.com
$vbLabelText   $csharpLabel

Dieser Ansatz erfordert:

  • Mehrere verschachtelte using-Anweisungen für jedes Dokument
  • Manuelle Durcharbeitung jeder Seitensammlung
  • Explizite page.Clone()-Aufrufe zum Kopieren von Seiten
  • Getrennte FileStream-Objekte für Eingabe und Ausgabe
  • Komplexes Ressourcenmanagement mit Potenzial für Entsorgungsprobleme

IronPDFPDF Merge

IronPDF bietet eine deklarative Merge-Operation:

// NuGet: Install-Package IronPdf
using IronPdf;

class Program
{
    static void Main()
    {
        // Load PDFs
        var pdf1 = PdfDocument.FromFile("document1.pdf");
        var pdf2 = PdfDocument.FromFile("document2.pdf");

        // Merge PDFs
        var merged = PdfDocument.Merge(pdf1, pdf2);

        // Save merged document
        merged.SaveAs("merged.pdf");
    }
}
// NuGet: Install-Package IronPdf
using IronPdf;

class Program
{
    static void Main()
    {
        // Load PDFs
        var pdf1 = PdfDocument.FromFile("document1.pdf");
        var pdf2 = PdfDocument.FromFile("document2.pdf");

        // Merge PDFs
        var merged = PdfDocument.Merge(pdf1, pdf2);

        // Save merged document
        merged.SaveAs("merged.pdf");
    }
}
IRON VB CONVERTER ERROR developers@ironsoftware.com
$vbLabelText   $csharpLabel

Die Methode PdfDocument.Merge() akzeptiert mehrere Dokumente und gibt ein kombiniertes Ergebnis zurück. Keine Iteration der Seite, kein Klonen, keine Stream-Verwaltung - der Vorgang ist in drei Codezeilen abgeschlossen.

Wasserzeichen hinzufügen

Das Anbringen von Wasserzeichen in PDFs zeigt den Komplexitätsunterschied bei der Dokumentenmanipulation auf.

Wasserzeichen für große Komponenten

Tall Components erfordert koordinatenbasierte Positionierung und Formverwaltung:

// NuGet: Install-Package TallComponents.PDF.Kit
using TallComponents.PDF.Kit;
using TallComponents.PDF.Layout;
using System.IO;
using System.Drawing;

class Program
{
    static void Main()
    {
        // Load existing PDF
        using (FileStream fs = new FileStream("input.pdf", FileMode.Open))
        using (Document document = new Document(fs))
        {
            // Iterate through pages
            foreach (Page page in document.Pages)
            {
                // Create watermark text
                TextShape watermark = new TextShape();
                watermark.Text = "CONFIDENTIAL";
                watermark.Font = new Font("Arial", 60);
                watermark.PenColor = Color.FromArgb(128, 255, 0, 0);
                watermark.X = 200;
                watermark.Y = 400;
                watermark.Rotate = 45;

                // Add to page
                page.Overlay.Shapes.Add(watermark);
            }

            // Save document
            using (FileStream output = new FileStream("watermarked.pdf", FileMode.Create))
            {
                document.Write(output);
            }
        }
    }
}
// NuGet: Install-Package TallComponents.PDF.Kit
using TallComponents.PDF.Kit;
using TallComponents.PDF.Layout;
using System.IO;
using System.Drawing;

class Program
{
    static void Main()
    {
        // Load existing PDF
        using (FileStream fs = new FileStream("input.pdf", FileMode.Open))
        using (Document document = new Document(fs))
        {
            // Iterate through pages
            foreach (Page page in document.Pages)
            {
                // Create watermark text
                TextShape watermark = new TextShape();
                watermark.Text = "CONFIDENTIAL";
                watermark.Font = new Font("Arial", 60);
                watermark.PenColor = Color.FromArgb(128, 255, 0, 0);
                watermark.X = 200;
                watermark.Y = 400;
                watermark.Rotate = 45;

                // Add to page
                page.Overlay.Shapes.Add(watermark);
            }

            // Save document
            using (FileStream output = new FileStream("watermarked.pdf", FileMode.Create))
            {
                document.Write(output);
            }
        }
    }
}
IRON VB CONVERTER ERROR developers@ironsoftware.com
$vbLabelText   $csharpLabel

Dieser Ansatz erfordert:

  • Manuelle Durchsicht aller Seiten
  • Erstellen von TextShape-Objekten mit expliziter Eigenschaftskonfiguration
  • Koordinatenpositionierung mit X und Y Werten
  • Manuelle Farbkonfiguration mit Color.FromArgb()
  • Hinzufügen von Formen zum Seiten-Overlay
  • Mehrere FileStream-Objekte für Eingabe und Ausgabe

IronPDFWasserzeichen

IronPDF bietet einen deklarativen Stamper-Ansatz:

// NuGet: Install-Package IronPdf
using IronPdf;
using IronPdf.Editing;

class Program
{
    static void Main()
    {
        // Load existing PDF
        var pdf = PdfDocument.FromFile("input.pdf");

        // Create watermark
        var watermark = new TextStamper()
        {
            Text = "CONFIDENTIAL",
            FontSize = 60,
            Opacity = 50,
            Rotation = 45,
            VerticalAlignment = VerticalAlignment.Middle,
            HorizontalAlignment = HorizontalAlignment.Center
        };

        // Apply watermark to all pages
        pdf.ApplyStamp(watermark);

        // Save watermarked PDF
        pdf.SaveAs("watermarked.pdf");
    }
}
// NuGet: Install-Package IronPdf
using IronPdf;
using IronPdf.Editing;

class Program
{
    static void Main()
    {
        // Load existing PDF
        var pdf = PdfDocument.FromFile("input.pdf");

        // Create watermark
        var watermark = new TextStamper()
        {
            Text = "CONFIDENTIAL",
            FontSize = 60,
            Opacity = 50,
            Rotation = 45,
            VerticalAlignment = VerticalAlignment.Middle,
            HorizontalAlignment = HorizontalAlignment.Center
        };

        // Apply watermark to all pages
        pdf.ApplyStamp(watermark);

        // Save watermarked PDF
        pdf.SaveAs("watermarked.pdf");
    }
}
IRON VB CONVERTER ERROR developers@ironsoftware.com
$vbLabelText   $csharpLabel

Die Klasse TextStamper verwendet semantische Ausrichtungseigenschaften anstelle von Koordinatenpositionierung. ApplyStamp() wird automatisch auf alle Seiten angewendet, ohne dass eine manuelle Iteration erforderlich ist. Die Deckkraft wird als Prozentsatz und nicht als Alphakanalberechnung angegeben.

API-Mapping-Referenz

Teams, die eine Migration von Große KomponentenzuIronPDFevaluieren, können sich auf diese äquivalenten Konzepte beziehen:

Große Komponenten IronPDF Notizen
Dokument ChromePdfRenderer Renderer erstellen
Abschnitt Automatisch Abschnitte aus der HTML-Struktur
TextParagraph HTML-Textelemente <p>, <h1>, <div>, usw.
BildParagraph <img> tag HTML-Bilder
TableParagraph HTML <table> Standard-HTML-Tabellen
Schriftart CSS font-family Unterstützte Webfonts
document.Write() pdf.SaveAs() In Datei speichern
document.Write(stream) pdf.BinaryData oder pdf.Stream Stream-Ausgabe
Page.Canvas HTML/CSS-Rendering Kein manuelles Canvas erforderlich
XmlDocument.Generate() RenderHtmlAsPdf() HTML ersetzt XML
PdfKit.Merger.Merge() PdfDocument.Merge() PDFs zusammenführen
Dokument.Sicherheit pdf.SecuritySettings PDF-Sicherheit
Seiten-Layout RenderingOptions Einstellungen der Seite

Umfassender Funktionsvergleich

Feature Große Komponenten IronPDF
Status DISCONTINUED Aktiv
Unterstützung Keine Voll
Aktualisierungen Keine Regelmäßig
Inhaltserstellung
HTML zu PDF Nein Vollständiges Chromium
URL zu PDF Nein Ja
CSS-Unterstützung Nein Vollständig CSS3
JavaScript Nein Vollständiger ES2024
XML-Vorlagen Ja Nicht erforderlich
PDF-Betrieb
PDFs zusammenführen Ja Ja
PDFs teilen Ja Ja
Wasserzeichen Handbuch Eingebaut
Kopf-/Fußzeilen XML-basiert HTML/CSS
Sicherheit
Passwortschutz Ja Ja
Digitale Signaturen Ja Ja
Verschlüsselung Ja Ja
PDF/A Beschränkt Ja
Bekannte Probleme
Leere Seiten Dokumentierter Fehler Keine
Fehlende Grafiken Dokumentierter Fehler Keine
Schriftart-Probleme Dokumentierter Fehler Keine
Entwicklung
Lernkurve Hoch (XML) Niedrig (HTML)
Dokumentation Veraltet Umfangreiche
Gemeinschaft Keine Aktiv

Bekannte Fehler in Tall Components

Diese Probleme wurden vor der Einstellung des Projekts nie behoben:

  • Fehler mit leeren Seiten: Zufällig erscheinende leere Seiten in generierten PDFs
  • Verschwindende Grafiken: Bilder und Formen werden unter bestimmten Bedingungen nicht gerendert
  • Fehlender Text: Textabschnitte, die zufällig in der Ausgabe ausgelassen wurden
  • Unkorrekte Schriftartwiedergabe: Falsche Schriftarten oder verstümmelte Zeichen
  • Speicherlecks: Nicht ordnungsgemäß entsorgte Dokumentobjekte

IronPDF hat keines dieser Probleme - es verwendet eine bewährte Chromium-Rendering-Engine.

Wenn Teams die Migration von Großkomponenten in Betracht ziehen

Mehrere Faktoren machen den Umstieg von Große Komponenteneher obligatorisch als optional:

Produktabkündigung bedeutet, dass keine neuen Lizenzen mehr verfügbar sind. Bestehende Benutzer werden auf das iText SDK umgeleitet, wodurch die Gefahr besteht, dass sie durch eine andere, teure Alternative an den Hersteller gebunden werden.

Keine Support-Verfügbarkeit lässt Teams ohne Bugfixes, Sicherheits-Patches oder Updates zurück. Der Einsatz von nicht unterstützter Software mit bekannten Rendering-Fehlern stellt ein Betriebsrisiko dar.

Bekannte Rendering-Fehler wie leere Seiten, fehlende Grafiken und Probleme mit der Schriftart wurden vor der Einstellung nie behoben. Diese dokumentierten Probleme wirken sich auf die Produktionssicherheit aus.

Keine HTML-Unterstützung schränkt Große Komponentenauf die XML-basierte Dokumentenerstellung ein, was für moderne webbasierte PDF-Generierungsworkflows, die HTML5 und CSS3 nutzen, völlig ungeeignet ist.

die Legacy-Architektur, die für eine andere Ära der .NET-Entwicklung entwickelt wurde, verursacht technische Schulden für Teams, die im Jahr 2026 auf moderne Frameworks wie .NET 10 und C# 14 setzen.

Installationsvergleich

Installationgroßer Komponenten

# Multiple packages may be needed
dotnet add package TallComponents.PDF.Kit
dotnet add package TallComponents.PDF.Layout
dotnet add package TallComponents.PDF.Layout.Drawing
# Multiple packages may be needed
dotnet add package TallComponents.PDF.Kit
dotnet add package TallComponents.PDF.Layout
dotnet add package TallComponents.PDF.Layout.Drawing
SHELL

Mehrere Namespaces erforderlich:

using TallComponents.PDF.Kit;
using TallComponents.PDF.Layout;
using TallComponents.PDF.Layout.Drawing;
using TallComponents.PDF.Layout.Paragraphs;
using TallComponents.PDF.Kit;
using TallComponents.PDF.Layout;
using TallComponents.PDF.Layout.Drawing;
using TallComponents.PDF.Layout.Paragraphs;
IRON VB CONVERTER ERROR developers@ironsoftware.com
$vbLabelText   $csharpLabel

IronPDF-Installation

# Single package
dotnet add package IronPdf
# Single package
dotnet add package IronPdf
SHELL

Einzelner Namensraum:

using IronPdf;
using IronPdf;
Imports IronPdf
$vbLabelText   $csharpLabel

IronPDF bietet auch spezielle Erweiterungspakete für bestimmte Frameworks an:

  • Blazor Server: Install-Package IronPdf.Extensions.Blazor
  • MAUI: Install-Package IronPdf.Extensions.Maui
  • MVC Framework: Install-Package IronPdf.Extensions.Mvc.Framework

Abschluss

Tall Components undIronPDFnehmen in der Landschaft der .NET-PDF-Bibliotheken grundlegend unterschiedliche Positionen ein. Große Komponentenwar zu seiner Zeit eine solide Wahl, aber der Erwerb und die Einstellung neuer Lizenzen hat zu einer End-of-Life-Situation geführt. Die dokumentierten Rendering-Fehler, die fehlende HTML-zu-PDF-Unterstützung und die fehlende fortlaufende Wartung machen es ungeeignet für neue Entwicklungen oder langfristige Verpflichtungen.

Für Teams, die derzeit Große Komponentenverwenden, ist die Migration nicht optional, sondern obligatorisch. Die Abkündigung des Produkts in Verbindung mit bekannten Fehlern und fehlendem Support schafft ein inakzeptables Betriebsrisiko. Die Weiterleitung zu iText SDK stellt eine Anbieterbindung mit einer anderen, potenziell teuren Alternative dar.

IronPDF bietet eine moderne, aktiv entwickelte Alternative mit echter HTML5/CSS3-Unterstützung auf Chromium-Basis, kontinuierlichen Updates und Support, einfacher NuGet-Installation und bewährter Rendering-Zuverlässigkeit. Für Teams, die eine moderne .NET-Entwicklung mit webbasierten Workflows zur Dokumentenerstellung anstreben, entspricht der HTML-first-Ansatz vonIronPDFden aktuellen Entwicklungspraktiken und beseitigt gleichzeitig die bekannten Fehler und Einschränkungen, die Große Komponentenplagten.

Eine Anleitung zur Implementierung finden Sie im IronPDF HTML-zu-PDF-Tutorial und in der Dokumentation, die PDF-Erzeugungsmuster für moderne .NET-Anwendungen abdeckt.