La bibliothèque PDF de C#
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
Dans le domaine du développement .NET, la gestion efficace des dépendances est cruciale pour créer des applications évolutives, faciles à maintenir et à tester. Injection de dépendance(DI) les conteneurs jouent un rôle essentiel dans la réalisation de ces objectifs en facilitant l'inversion du contrôle(IoC) principe. Parmi la pléthore de bibliothèques de mécanismes d'hébergement génériques disponibles, Autofac se distingue comme un cadre riche en fonctionnalités et extensible pour .NET.
Dans cet article, nous allons partir à la découverte d'Autofac .NET 6, en décortiquant ses caractéristiques et ses avantages pour présenter des exemples pratiques de son utilisation. Plus loin dans cet article, nous découvrirons IronPDF, une puissante bibliothèque de génération de PDF proposée par Iron Software. Nous présenterons également un cas d'utilisation où Autofac.NET et IronPDF sont utilisés conjointement.
Autofac est un conteneur IoC open-source pour .NET qui offre une prise en charge complète de l'injection de dépendances et de l'enregistrement de composants dans des applications telles que les API web. Développé par Nicholas Blumhardt et maintenu par une communauté dévouée, Autofac offre une solution robuste et flexible pour gérer les durées de vie des objets, résoudre les dépendances et composer des composants d'application.
Pour plus d'informations sur la manière dont Autofac améliore vos applications .NET, pensez à explorer les ressources fournies parLa bibliothèque PDF .NET d'IronPDFla traduction doit rester professionnelle et préserver l'exactitude technique tout en expliquant les caractéristiques et les avantages de ces outils de développement. Vous pouvez également vous plonger dansBibliothèque de codes-barres IronBarcode for .NET pour voir des applications pratiques de l'injection de dépendances dans la génération de codes-barres.
Pour obtenir des informations supplémentaires et des exemples pratiques sur l'utilisation d'Autofac dans des scénarios du monde réel, consultez le site suivantPage officielle d'IronSoftwarela traduction doit rester professionnelle et préserver l'exactitude technique tout en expliquant les caractéristiques et les avantages de ces outils de développement.
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();Enregistrement flexible des composants : Autofac permet aux développeurs d'enregistrer des composants à l'aide de diverses techniques d'enregistrement, notamment l'enregistrement manuel, le balayage d'assemblages et l'enregistrement basé sur les attributs. Cette flexibilité permet de contrôler finement l'instanciation et la configuration des composants.
Gestion de la durée de vie : Autofac prend en charge différentes durées de vie des objets, notamment le singleton, l'instance par dépendance, l'instance par durée de vie et l'instance par demande. Ce contrôle granulaire de la durée de vie des objets garantit une utilisation efficace des ressources et évite les fuites de mémoire dans les applications à long terme.
Résolution automatique des dépendances : Autofac résout automatiquement les dépendances sur la base des enregistrements de composants et de leurs dépendances. Ce câblage automatique simplifie la configuration de graphes d'objets complexes et favorise un couplage lâche entre les composants.
Composition de modules : Autofac permet aux développeurs d'organiser et d'encapsuler les enregistrements de composants à l'aide de modules. Les modules servent de conteneurs logiques pour les enregistrements connexes, ce qui facilite la gestion et la maintenance d'applications à grande échelle comportant plusieurs composants.
Interception et AOP : Autofac prend en charge l'interception et la programmation orientée aspect(AOP) par le biais de son extension d'interception. Grâce à l'interception, les développeurs peuvent appliquer des préoccupations transversales telles que la journalisation, la mise en cache et la sécurité aux composants sans modifier leur mise en œuvre.
Explorons quelques exemples pratiques pour illustrer l'utilisation d'Autofac.NET :
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();
}
}
}Dans cette section, nous avons démontré la mise en œuvre pratique d'Autofac.NET pour l'injection de dépendances. De l'enregistrement manuel à la numérisation de l'assemblage et à l'enregistrement basé sur les modules, nous avons montré la flexibilité qu'offre Autofac dans la gestion des dépendances. En utilisant ces techniques, les développeurs peuvent rationaliser le processus d'injection de dépendances de leur application, améliorant ainsi la maintenabilité et l'évolutivité.
Pour plus d'informations sur la manière dont les produits d'Iron Software peuvent s'intégrer à vos applications .NET afin de rationaliser et d'améliorer les fonctionnalités, explorez le site webDocumentation IronPDF où vous pourrez apprendre à générer et à modifier des documents PDF par programmation, ou visitez le site suivantSite web d'Iron Software pour découvrir un large éventail de bibliothèques .NET puissantes, comme IronBarcode pour la lecture et l'écriture de codes-barres, et IronOCR pour la reconnaissance optique de caractères avancée.
Simplicité et flexibilité : Autofac propose une API simple et intuitive pour l'enregistrement et la résolution des composants, ce qui facilite la mise en œuvre et la maintenance de l'injection de dépendances.
Testabilité et maintenabilité : En favorisant le couplage lâche et l'inversion des dépendances, Autofac améliore la testabilité et la maintenabilité des applications .NET, ce qui facilite les tests unitaires et le remaniement.
Performances et évolutivité : La légèreté et l'efficacité de l'exécution d'Autofac en font un outil adapté aux applications à haute performance et aux systèmes évolutifs comportant de grands graphes d'objets.
Extensibilité et personnalisation : L'architecture extensible d'Autofac permet aux développeurs d'étendre et de personnaliser le comportement d'Autofac par le biais de modules personnalisés, de sources d'enregistrement et de composants intergiciels, afin de répondre aux diverses exigences des applications.
Autofac est livré avec une licence MIT qui est libre d'utilisation pour le développement et à des fins commerciales.
IronPDF est une bibliothèque PDF C# robuste conçue pour fournir une solution complète de gestion des PDF dans les projets .NET. Que vos besoins concernent la création, l'édition, l'exportation, la sécurisation, le chargement ou la manipulation de documents PDF, IronPDF possède les outils dont vous avez besoin. Voici quelques-unes de ses caractéristiques et applications les plus remarquables :
Prise en charge multiplateforme : Compatible avec C#, F# et VB.NET, IronPDF fonctionne sur différentes versions de .NET, notamment .NET Core, .NET Standard et .NET Framework. Il est également disponible pour Java, Node.js et Python.
Pour en savoir plus sur la façon dont IronPDF peut intégrer des fonctionnalités PDF dans vos projets, visitez le site web de l'entreprisePage produit IronPDF.
Pour obtenir un aperçu complet des offres de produits d'Iron Software, notamment IronBarcode, IronOCR, et plus encore, visitez le site Web de l'entreprisePage d'accueil d'Iron Software.
Modèles et paramètres : Appliquer des modèles de page, des en-têtes, des pieds de page et des paramètres de page.
Pour plus d'informations sur ces fonctionnalités et sur la manière de les mettre en œuvre, visitez le site web de la Commission européenneguide détaillé de génération et de manipulation de PDF sur le site officiel d'IronPDF.
Priorité : L'accent est mis sur la précision, la facilité d'utilisation et la rapidité.
Voyons maintenant un exemple pratique avec ces deux bibliothèques.
Tout d'abord, créons une application console Visual Studio
Indiquer le nom et la localisation du projet.
Pour l'étape suivante, sélectionnez la version .NET requise et cliquez sur Créer.
Installez ensuite la bibliothèque IronPDF à partir de NuGet Package dans le Visual Studio Package Manager
VisiterDocumentation IronPDF pour plus d'informations sur l'installation et l'utilisation de la bibliothèque IronPDF.
Installer Autofac à partir d'un paquet NuGet dans le gestionnaire de paquets de Visual Studio
Pour en savoir plus sur Autofac, visitez le sitePage de documentation Autofac.
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");
}
}
}Décortiquons l'extrait de code que vous avez fourni :
ChromePdfRenderer Setup :
ChromePdfRenderer pour le rendu de PDF à partir de contenu HTML, une fonctionnalité clé deIronPDF.Préparation du contenu HTML :
La variable content est une chaîne HTML qui sera utilisée pour générer le PDF.
<h1> dont le titre est "Demonstrate Autofac with IronPDF" (Démonstration d'Autofac avec IronPDF).Mise en place du conteneur Autofac :
Le code crée une instance de ContainerBuilder nommée builder.
Enregistrement manuel des types :
Il enregistre un type MyService en tant qu'implémentation de l'interface IMyService.
Enregistrement des types à l'aide de l'analyse d'assemblage :
Il analyse l'assemblage contenant le type AutoFac.
Enregistrement des modules :
Il enregistre un module appelé MyModule.
Construction du conteneur :
builder.Build() méthode.Résoudre les dépendances :
À l'intérieur d'un champ d'application à vie(utilisation(var scope = container.BeginLifetimeScope()))il résout une instance de IMyService.
DoSomething est appelée sur le service résolu.Génération de PDF :
Un PDF est créé à partir du contenu à l'aide de ChromePdfRenderer.
IronPDF nécessite une clé de licence. Placez la clé de licence dans le fichier appSettings.json comme indiqué ci-dessous.
{
"IronPdf.License.LicenseKey": "The Key Here"
}
Install-Package IronPdf
Aucune carte de crédit n'est requise
Votre clé d'essai devrait se trouver dans l'email.
Si ce n'est pas le cas, veuillez contacter
support@ironsoftware.com
Aucune carte de crédit n'est requise
Commencez GRATUITEMENT
Aucune carte de crédit n'est requise
Testez en production sans filigranes.
Fonctionne là où vous en avez besoin.
Obtenez 30 jours de produit entièrement fonctionnel.
Faites-le fonctionner en quelques minutes.
Accès complet à notre équipe d'ingénieurs pendant la période d'essai du produit
Aucune carte de crédit ou création de compte n'est nécessaire
Votre clé d'essai devrait être dans l'e-mail.
Si ce n'est pas le cas, veuillez contacter
support@ironsoftware.com
Commencez GRATUITEMENT
Aucune carte de crédit n'est requise
Testez en production sans filigranes.
Fonctionne là où vous en avez besoin.
Obtenez 30 jours de produit entièrement fonctionnel.
Faites-le fonctionner en quelques minutes.
Accès complet à notre équipe d'ingénieurs pendant la période d'essai du produit
Licences à partir de 749 $. Vous avez une question ? Contactez-nous.
Réservez une démonstration personnelle de 30 minutes.
Pas de contrat, pas de détails de carte, pas d'engagements.
10 produits .NET API pour vos documents de bureau
