Die C# PDF-Bibliothek
using IronPdf;
// Disable local disk access or cross-origin requests
Installation.EnableWebSecurity = true;
// Instantiate Renderer
var renderer = new ChromePdfRenderer();
// Create a PDF from a HTML string using C#
var pdf = renderer.RenderHtmlAsPdf("<h1>Hello World</h1>");
// Export to a file or Stream
pdf.SaveAs("output.pdf");
// Advanced Example with HTML Assets
// Load external html assets: Images, CSS and JavaScript.
// An optional BasePath 'C:\site\assets\' is set as the file location to load assets from
var myAdvancedPdf = renderer.RenderHtmlAsPdf("<img src='icons/iron.png'>", @"C:\site\assets\");
myAdvancedPdf.SaveAs("html-with-assets.pdf");
Install-Package IronPdf
Im Bereich der .NET-Entwicklung ist die effiziente Verwaltung von Abhängigkeiten entscheidend für die Erstellung skalierbarer, wartbarer und testbarer Anwendungen. Injektion von Abhängigkeiten(DI) container spielen eine zentrale Rolle bei der Erreichung dieser Ziele, da sie die Umkehrung der Kontrolle erleichtern(IoC) prinzip. Unter der Fülle der verfügbaren generischen Hosting-Mechanismus-Bibliotheken sticht Autofac als funktionsreiches und erweiterbares Framework für .NET hervor.
In diesem Artikel begeben wir uns auf eine Reise, um Autofac .NET 6 zu erkunden, seine Funktionen und Vorteile zu enträtseln und praktische Beispiele für seine Verwendung zu zeigen. Später in diesem Artikel werden wir IronPDF kennenlernen, eine leistungsstarke PDF-Erzeugungsbibliothek von Iron Software. Wir werden auch einen Anwendungsfall vorstellen, bei dem Autofac.NET und IronPDF zusammen eingesetzt werden.
Autofac ist ein Open-Source-IoC-Container für .NET, der umfassende Unterstützung für Dependency Injection und Komponentenregistrierung in Anwendungen wie Web-APIs bietet. Autofac wurde von Nicholas Blumhardt entwickelt und wird von einer engagierten Community gepflegt. Es bietet eine robuste und flexible Lösung für die Verwaltung von Objektlebensdauern, die Auflösung von Abhängigkeiten und die Komposition von Anwendungskomponenten.
Weitere Informationen darüber, wie Autofac Ihre .NET-Anwendungen verbessert, finden Sie in den Ressourcen vonIronPDF's .NET PDF-Bibliothekdie Übersetzung soll die fortgeschrittenen Funktionen zur PDF-Erzeugung und -Bearbeitung hervorheben. Sie können sich auch mit folgenden Themen befassenIronBarcode's .NET Barcode Bibliothek um praktische Anwendungen von Dependency Injection in der Barcode-Generierung zu sehen.
Weitere Einblicke und praktische Beispiele für den Einsatz von Autofac in realen Szenarien finden Sie unterDie offizielle Seite von IronSoftwarehier finden Sie eine umfassende Suite von Produkten wie IronOCR und IronXL, die sich nahtlos in Autofac integrieren lassen und Ihren .NET-Entwicklungsprozess verbessern.
public class Startup
{
public void ConfigureContainer()
{
var builder = new ContainerBuilder(); // host sub property builder
builder.RegisterInstance(new TaskRepository()).As<ITaskRepository>();
builder.RegisterType<TaskController>();
builder.Register(c => new LogManager(DateTime.Now)).As<ILogger>();
// Scan an assembly for components
builder.RegisterAssemblyTypes(myAssembly).Where(t => t.Name.EndsWith("Repository")).AsImplementedInterfaces();
var container = builder.Build();
}
} public class Startup
{
public void ConfigureContainer()
{
var builder = new ContainerBuilder(); // host sub property builder
builder.RegisterInstance(new TaskRepository()).As<ITaskRepository>();
builder.RegisterType<TaskController>();
builder.Register(c => new LogManager(DateTime.Now)).As<ILogger>();
// Scan an assembly for components
builder.RegisterAssemblyTypes(myAssembly).Where(t => t.Name.EndsWith("Repository")).AsImplementedInterfaces();
var container = builder.Build();
}
} public class TaskController
{
private ITaskRepository _repository;
private ILogger _logger;
public TaskController(ITaskRepository repository, ILogger logger)
{
this._repository = repository;
this._logger = logger;
}
} public class TaskController
{
private ITaskRepository _repository;
private ILogger _logger;
public TaskController(ITaskRepository repository, ILogger logger)
{
this._repository = repository;
this._logger = logger;
}
} public class CarTransportModule : Module
{
public bool ObeySpeedLimit { get; set; }
protected override void Load(ContainerBuilder builder)
{
builder.RegisterType<Car>().As<IVehicle>();
if (ObeySpeedLimit)
builder.RegisterType<SaneDriver>().As<IDriver>();
else
builder.RegisterType<CrazyDriver>().As<IDriver>();
}
} public class CarTransportModule : Module
{
public bool ObeySpeedLimit { get; set; }
protected override void Load(ContainerBuilder builder)
{
builder.RegisterType<Car>().As<IVehicle>();
if (ObeySpeedLimit)
builder.RegisterType<SaneDriver>().As<IDriver>();
else
builder.RegisterType<CrazyDriver>().As<IDriver>();
}
} var builder = new ContainerBuilder();
builder.RegisterType<Listener>().As<IListener>().OnActivated(e => e.Instance.StartListening());
builder.RegisterType<Processor>().OnActivating(e => e.Instance.Initialize());
var container = builder.Build(); var builder = new ContainerBuilder();
builder.RegisterType<Listener>().As<IListener>().OnActivated(e => e.Instance.StartListening());
builder.RegisterType<Processor>().OnActivating(e => e.Instance.Initialize());
var container = builder.Build();Flexible Komponentenregistrierung: Autofac ermöglicht es Entwicklern, Komponenten mit einer Vielzahl von Registrierungstechniken zu registrieren, darunter manuelle Registrierung, Scannen von Baugruppen und attributbasierte Registrierung. Diese Flexibilität ermöglicht eine fein abgestufte Steuerung der Komponenteninstanziierung und -konfiguration.
Lebenszeit-Management: Autofac unterstützt verschiedene Objektlebenszeitbereiche, darunter Singleton, Instanz pro Abhängigkeit, Instanz pro Lebenszeitbereich und Instanz pro Anfrage. Diese granulare Steuerung der Objektlebensdauer gewährleistet eine effiziente Ressourcennutzung und verhindert Speicherlecks in lang laufenden Anwendungen.
Automatische Auflösung von Abhängigkeiten: Autofac löst Abhängigkeiten automatisch auf der Grundlage der registrierten Komponentenregistrierungen und ihrer Abhängigkeiten auf. Diese automatische Verdrahtung vereinfacht die Konfiguration komplexer Objektgraphen und fördert die lose Kopplung zwischen Komponenten.
Modul-Zusammensetzung: Autofac ermöglicht es Entwicklern, Komponentenregistrierungen mithilfe von Modulen zu organisieren und zu kapseln. Module dienen als logische Container für zusammenhängende Registrierungen und erleichtern die Verwaltung und Pflege umfangreicher Anwendungen mit mehreren Komponenten.
Abfangen und AOP: Autofac bietet Unterstützung für Interception und aspektorientierte Programmierung(AOP) durch seine Abfangverlängerung. Mit Interception können Entwickler übergreifende Aspekte wie Protokollierung, Caching und Sicherheit auf Komponenten anwenden, ohne deren Implementierung zu ändern.
Lassen Sie uns einige praktische Beispiele zur Veranschaulichung der Verwendung von Autofac.NET untersuchen:
public class Program
{
public static void Main()
{
// Setting up Autofac container
var builder = new ContainerBuilder();
// Registering types manually
builder.RegisterType<MyService>().As<IMyService>();
// Registering types using assembly scanning
builder.RegisterAssemblyTypes(typeof(MyAssembly).Assembly)
.Where(t => t.Name.EndsWith("Repository"))
.AsImplementedInterfaces();
// Registering modules
builder.RegisterModule(new MyModule());
// Building the container
var container = builder.Build();
// Resolving dependencies
using (var scope = container.BeginLifetimeScope())
{
var service = scope.Resolve<IMyService>();
service.DoSomething();
}
}
}public class Program
{
public static void Main()
{
// Setting up Autofac container
var builder = new ContainerBuilder();
// Registering types manually
builder.RegisterType<MyService>().As<IMyService>();
// Registering types using assembly scanning
builder.RegisterAssemblyTypes(typeof(MyAssembly).Assembly)
.Where(t => t.Name.EndsWith("Repository"))
.AsImplementedInterfaces();
// Registering modules
builder.RegisterModule(new MyModule());
// Building the container
var container = builder.Build();
// Resolving dependencies
using (var scope = container.BeginLifetimeScope())
{
var service = scope.Resolve<IMyService>();
service.DoSomething();
}
}
}In diesem Abschnitt haben wir die praktische Implementierung von Autofac.NET für die Injektion von Abhängigkeiten demonstriert. Von der manuellen Registrierung über das Scannen von Baugruppen bis hin zur modulbasierten Registrierung haben wir gezeigt, welche Flexibilität Autofac bei der Verwaltung von Abhängigkeiten bietet. Durch den Einsatz dieser Techniken können Entwickler den Prozess der Injektion von Abhängigkeiten in ihre Anwendungen optimieren und so die Wartbarkeit und Skalierbarkeit verbessern.
Weitere Informationen darüber, wie die Produkte von Iron Software in Ihre .NET-Anwendungen integriert werden können, um die Funktionalität weiter zu optimieren und zu verbessern, finden Sie auf derIronPDF-Dokumentation wo Sie lernen können, wie man PDF-Dokumente programmatisch erzeugt und bearbeitet, oder besuchen SieWebsite von Iron Software um eine breite Palette von leistungsstarken .NET-Bibliotheken wie IronBarcode zum Lesen und Schreiben von Barcodes und IronOCR für die erweiterte optische Zeichenerkennung zu entdecken.
Einfachheit und Flexibilität: Autofac bietet eine einfache und intuitive API für die Registrierung und Auflösung von Komponenten, wodurch die Injektion von Abhängigkeiten einfach zu implementieren und zu pflegen ist.
Testbarkeit und Wartbarkeit: Durch die Förderung der losen Kopplung und der Umkehrung von Abhängigkeiten verbessert Autofac die Testbarkeit und Wartbarkeit von .NET-Anwendungen und ermöglicht Unit-Tests und Refactoring mit Leichtigkeit.
Leistung und Skalierbarkeit: Autofacs leichtgewichtige und effiziente Laufzeitleistung macht es für Hochleistungsanwendungen und skalierbare Systeme mit großen Objektgraphen geeignet.
Erweiterbarkeit und Anpassung: Die erweiterbare Architektur von Autofac ermöglicht es Entwicklern, das Verhalten von Autofac durch benutzerdefinierte Module, Registrierungsquellen und Middleware-Komponenten zu erweitern und anzupassen, um die unterschiedlichsten Anwendungsanforderungen zu erfüllen.
Autofac wird mit einer MIT-Lizenz ausgeliefert, die sowohl für die Entwicklung als auch für kommerzielle Zwecke frei verwendbar ist.
IronPDF ist eine robuste C# PDF-Bibliothek, die eine umfassende Lösung für die Verwaltung von PDFs in .NET-Projekten bietet. Egal, ob Sie PDF-Dokumente erstellen, bearbeiten, exportieren, sichern, laden oder manipulieren möchten, IronPDF hat die Werkzeuge, die Sie brauchen. Hier sind einige seiner herausragenden Funktionen und Anwendungen:
Plattformübergreifende Unterstützung: IronPDF ist kompatibel mit C#, F# und VB.NET und läuft auf verschiedenen .NET-Versionen, einschließlich .NET Core, .NET Standard und .NET Framework. Es ist auch für Java, Node.js und Python verfügbar.
Um mehr darüber zu erfahren, wie IronPDF PDF-Funktionen in Ihre Projekte integrieren kann, besuchen Sie dieIronPDF Produktseite.
Einen umfassenden Überblick über das Produktangebot von Iron Software, einschließlich IronBarcode, IronOCR und mehr, finden Sie auf der WebsiteIron Software Startseite.
Vorlagen und Einstellungen: Anwenden von Seitenvorlagen, Kopf- und Fußzeilen und Seiteneinstellungen.
Weitere Informationen zu diesen Funktionen und deren Implementierung finden Sie auf der Websiteausführliche Anleitung zur PDF-Erzeugung und -Bearbeitung auf der offiziellen Website von IronPDF.
Priorität: Der Schwerpunkt liegt auf Genauigkeit, Benutzerfreundlichkeit und Geschwindigkeit.
Schauen wir uns nun ein praktisches Beispiel mit diesen beiden Bibliotheken an.
Erstellen wir zunächst eine Visual Studio-Konsolenanwendung
Geben Sie den Namen und den Standort des Projekts an.
Im nächsten Schritt wählen Sie die gewünschte .NET-Version aus und klicken auf Erstellen.
Installieren Sie dann die IronPDF-Bibliothek aus dem NuGet-Paket des Visual Studio Package Manager
Besuchen SieIronPDF-Dokumentation weitere Informationen zur Installation und Nutzung der IronPDF-Bibliothek finden Sie hier.
Installieren Sie Autofac über das NuGet-Paket aus dem Visual Studio Package Manager
Weitere Informationen über Autofac finden Sie auf derAutofac-Dokumentationsseite.
using Autofac;
using CacheManager.Core;
using IronPdf;
using System.Reflection;
namespace IronPdfDemos
{
public class AutoFac
{
public static void Execute()
{
// Instantiate Cache and ChromePdfRenderer
var renderer = new ChromePdfRenderer();
var cache = CacheFactory.Build("ironPdfAutofac", settings =>
{
settings.WithDictionaryHandle();
});
// Prepare HTML content
var content = "<h1>Demonstrate Autofac with IronPDF</h1>";
content += "<p>This is an illustration of using Autofac for dependency injection and IronPDF for generating PDF documents.</p>";
content += "<h2>Setting up Autofac container</h2>";
// Setting up Autofac container
var builder = new ContainerBuilder();
content += "<p>var builder = new ContainerBuilder();</p>";
content += "<h2>Registering types manually</h2>";
// Registering types manually
builder.RegisterType<MyService>().As<IMyService>();
content += "<p>builder.RegisterType<MyService>().As<IMyService();</p>";
content += "<h2>Registering types using assembly scanning</h2>";
// Registering types using assembly scanning
builder.RegisterAssemblyTypes(typeof(AutoFac).Assembly)
.Where(t => t.Name.EndsWith("Repository"))
.AsImplementedInterfaces();
content += "<p>builder.RegisterAssemblyTypes(typeof(AutoFac).Assembly).Where(t => t.Name.EndsWith(\"Repository\")).AsImplementedInterfaces();</p>";
content += "<h2>Registering modules</h2>";
// Registering modules
builder.RegisterModule(new MyModule());
content += "<p>builder.RegisterModule(new MyModule());</p>";
content += "<h2>Building the container</h2>";
// Building the container
var container = builder.Build();
content += "<p>var container = builder.Build();</p>";
content += "<h2>Resolving dependencies</h2>";
// Resolving dependencies
using (var scope = container.BeginLifetimeScope())
{
var service = scope.Resolve<IMyService>();
service.DoSomething();
}
content += "<p>var service = scope.Resolve<IMyService();</p>";
// Create a PDF from the HTML string using C#
var pdf = renderer.RenderHtmlAsPdf(content);
// Export to a file or Stream
pdf.SaveAs("autofac.pdf");
Console.WriteLine("We are done...");
Console.ReadKey();
}
}
internal interface IMyService
{
void DoSomething();
}
internal class MyModule : Module
{
protected override void Load(ContainerBuilder builder)
{
// Register module dependencies here
}
}
internal class MyService : IMyService
{
public void DoSomething()
{
Console.WriteLine("DoSomething");
}
}
}using Autofac;
using CacheManager.Core;
using IronPdf;
using System.Reflection;
namespace IronPdfDemos
{
public class AutoFac
{
public static void Execute()
{
// Instantiate Cache and ChromePdfRenderer
var renderer = new ChromePdfRenderer();
var cache = CacheFactory.Build("ironPdfAutofac", settings =>
{
settings.WithDictionaryHandle();
});
// Prepare HTML content
var content = "<h1>Demonstrate Autofac with IronPDF</h1>";
content += "<p>This is an illustration of using Autofac for dependency injection and IronPDF for generating PDF documents.</p>";
content += "<h2>Setting up Autofac container</h2>";
// Setting up Autofac container
var builder = new ContainerBuilder();
content += "<p>var builder = new ContainerBuilder();</p>";
content += "<h2>Registering types manually</h2>";
// Registering types manually
builder.RegisterType<MyService>().As<IMyService>();
content += "<p>builder.RegisterType<MyService>().As<IMyService();</p>";
content += "<h2>Registering types using assembly scanning</h2>";
// Registering types using assembly scanning
builder.RegisterAssemblyTypes(typeof(AutoFac).Assembly)
.Where(t => t.Name.EndsWith("Repository"))
.AsImplementedInterfaces();
content += "<p>builder.RegisterAssemblyTypes(typeof(AutoFac).Assembly).Where(t => t.Name.EndsWith(\"Repository\")).AsImplementedInterfaces();</p>";
content += "<h2>Registering modules</h2>";
// Registering modules
builder.RegisterModule(new MyModule());
content += "<p>builder.RegisterModule(new MyModule());</p>";
content += "<h2>Building the container</h2>";
// Building the container
var container = builder.Build();
content += "<p>var container = builder.Build();</p>";
content += "<h2>Resolving dependencies</h2>";
// Resolving dependencies
using (var scope = container.BeginLifetimeScope())
{
var service = scope.Resolve<IMyService>();
service.DoSomething();
}
content += "<p>var service = scope.Resolve<IMyService();</p>";
// Create a PDF from the HTML string using C#
var pdf = renderer.RenderHtmlAsPdf(content);
// Export to a file or Stream
pdf.SaveAs("autofac.pdf");
Console.WriteLine("We are done...");
Console.ReadKey();
}
}
internal interface IMyService
{
void DoSomething();
}
internal class MyModule : Module
{
protected override void Load(ContainerBuilder builder)
{
// Register module dependencies here
}
}
internal class MyService : IMyService
{
public void DoSomething()
{
Console.WriteLine("DoSomething");
}
}
}Lassen Sie uns den von Ihnen bereitgestellten Codeschnipsel aufschlüsseln:
ChromePdfRenderer Setup:
ChromePdfRenderer-Instanz zum Rendern von PDFs aus HTML-Inhalten, einer Schlüsselfunktion vonIronPDF.HTML-Inhaltsvorbereitung:
Die Variable "Inhalt" ist eine HTML-Zeichenfolge, die zur Erstellung der PDF-Datei verwendet wird.
<h1>-Tag mit dem Titel "Demonstration von Autofac mit IronPDF".Einrichten des Autofac-Containers:
Der Code erzeugt eine Instanz von ContainerBuilder mit dem Namen builder.
Manuelle Registrierung von Typen:
Sie registriert einen Typ MyService als Implementierung der Schnittstelle IMyService.
Registrierung von Typen mit Hilfe von Assembly Scanning:
Sie durchsucht die Baugruppe, die den Typ "AutoFac" enthält.
Registrierung von Modulen:
Es registriert ein Modul mit dem Namen MeinModul.
Bau des Containers:
Auflösen von Abhängigkeiten:
Innerhalb eines lebenslangen Geltungsbereichs(verwendung(var scope = container.BeginLifetimeScope())`)löst er eine Instanz von "IMyService" auf.
DoSomething wird für den aufgelösten Dienst aufgerufen.PDF-Erstellung:
Aus dem Inhalt wird mit dem ChromePdfRenderer ein PDF erstellt.
IronPDF benötigt einen Lizenzschlüssel. Platzieren Sie den Lizenzschlüssel in der Datei "appSettings.json" wie unten gezeigt.
{
"IronPdf.License.LicenseKey": "The Key Here"
}
Install-Package IronPdf
Keine Kreditkarte erforderlich
Ihr Testschlüssel sollte in der E-Mail sein.
Wenn nicht, kontaktieren Sie bitte
support@ironsoftware.com
Keine Kreditkarte erforderlich
Starten Sie kostenlos
Keine Kreditkarte erforderlich
Testen Sie in der Produktion ohne Wasserzeichen.
Funktioniert überall, wo Sie es benötigen.
Erhalten Sie 30 Tage lang ein voll funktionsfähiges Produkt.
Haben Sie es in wenigen Minuten einsatzbereit.
Vollständiger Zugang zu unserem technischen Support-Team während Ihrer Produkttestphase
Keine Kreditkarte oder Kontoerstellung erforderlich
Ihr Testschlüssel sollte sich in der E-Mail befinden.
Falls nicht, kontaktieren Sie bitte
support@ironsoftware.com
Starten Sie kostenlos
Keine Kreditkarte erforderlich
Testen Sie in der Produktion ohne Wasserzeichen.
Funktioniert überall, wo Sie es benötigen.
Erhalten Sie 30 Tage lang ein voll funktionsfähiges Produkt.
Haben Sie es in wenigen Minuten einsatzbereit.
Vollständiger Zugang zu unserem technischen Support-Team während Ihrer Produkttestphase
Lizenzen ab $749. Haben Sie eine Frage? Kontaktieren Sie uns.
Buchen Sie eine persönliche 30-minütige Demo.
Kein Vertrag, keine Kartendetails, keine Verpflichtungen.
10 .NET API-Produkte für Ihre Bürodokumente
