Autofac .NET 6 (Geliştiriciler İçin Nasıl Çalışır)

Autofac .NET Anlayışı

Autofac, farklı ortamlardaki istemcilere ve uygulamalara hizmet eden ve bileşenlerin nesne ömürlerini yönetmek, bağımlılıkları çözmek ve uygulama bileşenlerini oluşturmak için kapsamlı destek sağlayan açık kaynaklı bir IoC konteynerdir. İhtiyaç duyulan bileşenleri düzenli bir şekilde entegre eder.

IronPDF'in .NET PDF Kütüphanesi'nin sunduğu kaynakları keşfederek uygulamalarınızda nasıl çalışabileceğiniz hakkında daha fazla bilgi edinin. PDF üretimi ve işleme için gelişmiş özelliklerin önemini vurgular. IronBarcode'un .NET Barkod Kütüphanesi üzerinde derinlemesine çalışma yaparak bağımlılık enjeksiyonunun barkod üretimindeki pratik uygulamalarına göz atabilirsiniz.

Iron Software'in resmi sayfasını ziyaret ederek, gerçek dünya senaryolarında Autofac kullanarak ek bilgiler ve pratik örneklerle etkileşim kurun, burada Autofac ile sorunsuz bir şekilde entegre olan ve .NET geliştirme sürecinizi geliştiren IronOCR ve IronXL gibi kapsamlı bir ürün paketi bulacaksınız.

Autofac Özellikleri

1. Konteyner Oluşturma ve Bileşen Kaydı: Başlangıç sınıfında bileşenleri kaydederek Autofac ile konteynerler oluşturabilirsiniz. Lambdalar, türler veya önceden oluşturulmuş instances kullanarak bileşenleri kaydedebilirsiniz.

   public class Startup
   {
       public void ConfigureContainer()
       {
           var builder = new ContainerBuilder(); // Create a new container builder
           builder.RegisterInstance(new TaskRepository()).As<ITaskRepository>(); // Register an instance for ITaskRepository
           builder.RegisterType<TaskController>(); // Register TaskController type
           builder.Register(c => new LogManager(DateTime.Now)).As<ILogger>(); // Use lambda expression to register ILogger
           // Scan an assembly for components and register them
           builder.RegisterAssemblyTypes(myAssembly).Where(t => t.Name.EndsWith("Repository")).AsImplementedInterfaces();
           var container = builder.Build(); // Build the container
       }
   }

   public class Startup
   {
       public void ConfigureContainer()
       {
           var builder = new ContainerBuilder(); // Create a new container builder
           builder.RegisterInstance(new TaskRepository()).As<ITaskRepository>(); // Register an instance for ITaskRepository
           builder.RegisterType<TaskController>(); // Register TaskController type
           builder.Register(c => new LogManager(DateTime.Now)).As<ILogger>(); // Use lambda expression to register ILogger
           // Scan an assembly for components and register them
           builder.RegisterAssemblyTypes(myAssembly).Where(t => t.Name.EndsWith("Repository")).AsImplementedInterfaces();
           var container = builder.Build(); // Build the container
       }
   }

   Public Class Startup
   	Public Sub ConfigureContainer()
   		Dim builder = New ContainerBuilder() ' Create a new container builder
   		builder.RegisterInstance(New TaskRepository()).As(Of ITaskRepository)() ' Register an instance for ITaskRepository
   		builder.RegisterType(Of TaskController)() ' Register TaskController type
   		builder.Register(Function(c) New LogManager(DateTime.Now)).As(Of ILogger)() ' Use lambda expression to register ILogger
   		' Scan an assembly for components and register them
   		builder.RegisterAssemblyTypes(myAssembly).Where(Function(t) t.Name.EndsWith("Repository")).AsImplementedInterfaces()
   		Dim container = builder.Build() ' Build the container
   	End Sub
   End Class

   $vbLabelText   $csharpLabel

2. Bağımlılıkları İfade Etme: Autofac, kurucu parametrelerini enjekte edebilir, mülk enjeksiyonu ve yöntem enjeksiyonunu ele alabilir.

   public class TaskController
   {
       private ITaskRepository _repository;
       private ILogger _logger;
   
       public TaskController(ITaskRepository repository, ILogger logger)
       {
           _repository = repository; // Assign injected repository to the local variable
           _logger = logger; // Assign injected logger to the local variable
       }
   }

   public class TaskController
   {
       private ITaskRepository _repository;
       private ILogger _logger;
   
       public TaskController(ITaskRepository repository, ILogger logger)
       {
           _repository = repository; // Assign injected repository to the local variable
           _logger = logger; // Assign injected logger to the local variable
       }
   }

   Public Class TaskController
   	Private _repository As ITaskRepository
   	Private _logger As ILogger
   
   	Public Sub New(ByVal repository As ITaskRepository, ByVal logger As ILogger)
   		_repository = repository ' Assign injected repository to the local variable
   		_logger = logger ' Assign injected logger to the local variable
   	End Sub
   End Class

   $vbLabelText   $csharpLabel

3. Esnek Modül Sistemi: Autofac modülleri, XML yapılandırması ve kod tabanlı kayıtlar arasında bir denge kurar. Karmaşık kayıtları kodda belirleyebilir veya XML kullanarak dağıtım zamanındaki davranışları değiştirebilirsiniz.

   public class CarTransportModule : Module
   {
       public bool ObeySpeedLimit { get; set; }
   
       protected override void Load(ContainerBuilder builder)
       {
           builder.RegisterType<Car>().As<IVehicle>(); // Register Car as IVehicle
           if (ObeySpeedLimit)
               builder.RegisterType<SaneDriver>().As<IDriver>(); // Register SaneDriver if speed limit is to be obeyed
           else
               builder.RegisterType<CrazyDriver>().As<IDriver>(); // Register CrazyDriver otherwise
       }
   }

   public class CarTransportModule : Module
   {
       public bool ObeySpeedLimit { get; set; }
   
       protected override void Load(ContainerBuilder builder)
       {
           builder.RegisterType<Car>().As<IVehicle>(); // Register Car as IVehicle
           if (ObeySpeedLimit)
               builder.RegisterType<SaneDriver>().As<IDriver>(); // Register SaneDriver if speed limit is to be obeyed
           else
               builder.RegisterType<CrazyDriver>().As<IDriver>(); // Register CrazyDriver otherwise
       }
   }

   Public Class CarTransportModule
   	Inherits Module
   
   	Public Property ObeySpeedLimit() As Boolean
   
   	Protected Overrides Sub Load(ByVal builder As ContainerBuilder)
   		builder.RegisterType(Of Car)().As(Of IVehicle)() ' Register Car as IVehicle
   		If ObeySpeedLimit Then
   			builder.RegisterType(Of SaneDriver)().As(Of IDriver)() ' Register SaneDriver if speed limit is to be obeyed
   		Else
   			builder.RegisterType(Of CrazyDriver)().As(Of IDriver)() ' Register CrazyDriver otherwise
   		End If
   	End Sub
   End Class

   $vbLabelText   $csharpLabel

4. Basit Genişleme Noktaları: Autofac, bileşen aktivasyonunu veya serbest bırakılmasını özelleştirmek için aktivasyon olayları sağlar.

   var builder = new ContainerBuilder();
   builder.RegisterType<Listener>().As<IListener>().OnActivated(e => e.Instance.StartListening()); // Setup activation event
   builder.RegisterType<Processor>().OnActivating(e => e.Instance.Initialize()); // Setup activating event
   var container = builder.Build();

   var builder = new ContainerBuilder();
   builder.RegisterType<Listener>().As<IListener>().OnActivated(e => e.Instance.StartListening()); // Setup activation event
   builder.RegisterType<Processor>().OnActivating(e => e.Instance.Initialize()); // Setup activating event
   var container = builder.Build();

   Dim builder = New ContainerBuilder()
   builder.RegisterType(Of Listener)().As(Of IListener)().OnActivated(Function(e) e.Instance.StartListening()) ' Setup activation event
   builder.RegisterType(Of Processor)().OnActivating(Function(e) e.Instance.Initialize()) ' Setup activating event
   Dim container = builder.Build()

   $vbLabelText   $csharpLabel

Autofac.NET'in Temel Özellikleri

1. Esnek Bileşen Kaydı: Autofac, geliştiricilerin çeşitli kayıt tekniklerini kullanarak bileşenleri kaydetmelerine olanak tanır, manuel kayıt, derleme taraması ve başvuruya dayalı kayıt dahil. Bu esneklik, bileşen oluşturma ve yapılandırma üzerinde ayrıntılı bir kontrol sağlar.

2. Ömür Yönetimi: Autofac, tekil, bağımlılık başına instance, ömür kapsamı başına instance ve istek başına instance gibi çeşitli nesne ömür kapsamlarını destekler. Nesne ömrü üzerinde ayrıntılı bu kontrol, kaynakların etkili kullanımını sağlar ve uzun süre çalışan uygulamalarda bellek sızıntılarını önler.

3. Otomatik Bağımlılık Çözme: Autofac, kayıtlı bileşenler ve bağımlılıkları temel alarak bağımlılıkları otomatik olarak çözer. Bu otomatik bağlama, karmaşık nesne grafiklerinin yapılandırılmasını basitleştirir ve bileşenler arasında gevşek bağlamayı teşvik eder.

4. Modül Kompozisyonu: Autofac, geliştiricilerin modüller kullanarak bileşen kayıtlarını organize ve kapsüllemelerine izin verir. Modüller, ilgili kayıtlar için mantıksal konteynerler olarak hizmet eder, çok sayıda bileşene sahip büyük ölçekli uygulamaları yönetmeyi ve sürdürmeyi kolaylaştırır.

5. Önleme ve AOP: Autofac, önleme uzantısı aracılığıyla önleme ve aspect-oriented programming (AOP) için destek sağlar. Kesişimle beraber geliştiriciler, bileşenlerin uygulamalarını değiştirmeden, günlük kaydı, önbellekleme ve güvenlik gibi kesitli kaygıları uygulayabilir.

6. ASP.NET Core ve .NET Core Entegrasyonu: Autofac, .NET Core ve ASP.NET Core ile sorunsuzca bütünleşir ve modern web uygulamaları ve mikroservisler için birinci sınıf bağımlılık enjeksiyonu desteği sağlar. Bu, .NET ekosistemi ile uyumluluğu ve birlikte çalışabilirliği sağlamak için yerleşik hizmet sağlayıcı abstarksiyonunu kullanır.

Autofac.NET ile Pratik Örnekler

Autofac.NET kullanımını açıklamak için bazı pratik örnekler inceleyelim:

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();
        }
    }
}

Public Class Program
	Public Shared Sub Main()
		' Setting up Autofac container
		Dim builder = New ContainerBuilder()

		' Registering types manually
		builder.RegisterType(Of MyService)().As(Of IMyService)()

		' Registering types using assembly scanning
		builder.RegisterAssemblyTypes(GetType(MyAssembly).Assembly).Where(Function(t) t.Name.EndsWith("Repository")).AsImplementedInterfaces()

		' Registering modules
		builder.RegisterModule(New MyModule())

		' Building the container
		Dim container = builder.Build()

		' Resolving dependencies
		Using scope = container.BeginLifetimeScope()
			Dim service = scope.Resolve(Of IMyService)()
			service.DoSomething()
		End Using
	End Sub
End Class

Bu bölümde, Autofac.NET'i bağımlılık enjeksiyonu için pratik olarak nasıl uygulayacağımızı gösterdik. Manuel kayıttan, montaj taramasına ve modül tabanlı kayıta kadar, Autofac'in bağımlılıkları yönetmede sunduğu esnekliği gösterdik. Bu teknikleri kullanarak geliştiriciler, uygulamalarının bağımlılık enjeksiyon sürecini düzene sokabilirler, bu da daha iyi bakıma uygunluk ve ölçeklenebilirlik sağlar.

Iron Software ürünlerinin .NET uygulamalarınıza nasıl entegre olup işlevselliği daha da düzene sokabileceğini öğrenmek için, IronPDF dokümantasyonunu inceleyin. PDF belgelerini programlı bir şekilde nasıl oluşturacağınızı ve düzenleyeceğinizi öğrenebilir veya bar kodları okuyup yazmada kullanılan IronBarcode ve gelişmiş optik karakter tanımada işlev gören IronOCR gibi güçlü .NET kütüphanelerini keşfetmek için Iron Software web sitesini ziyaret edin.

Autofac.NET Kullanmanın Faydaları

1. Basitlik ve Esneklik: Autofac, bileşenleri kaydetmek ve çözmek için basit ve sezgisel bir API sunar, bu da bağımlılık enjeksiyonunun uygulanmasını ve bakımını kolaylaştırır.

2. Test Edilebilirlik ve Bakım: Gevşek bağlamayı ve bağımlılık tersini teşvik ederek, Autofac, birim testi ve yeniden yapılandırmayı kolaylaştırarak .NET uygulamalarının test edilebilirliğini ve bakımını artırır.

3. Performans ve Ölçeklenebilirlik: Autofac'ın hafif ve verimli çalıştırma performansı, yüksek performanslı uygulamalar ve büyük nesne grafikleriyle ölçeklenebilir sistemler için uygundur.

4. Genişletilebilirlik ve Özelleştirme: Autofac'ın genişletilebilir mimarisi, geliştiricilere Autofac'ın davranışını özel modüller, kayıt kaynakları ve ara katman bileşenleri ile genişletme ve özelleştirme imkanı tanır. Bu, farklı uygulama gerekliliklerine hizmet eder.

5. Topluluk ve Destek: Aktif bir geliştirici topluluğu ve kapsamlı dokümanları ile Autofac, çerçeveye öğrenme, sorun giderme ve katkıda bulunma konusunda mükemmel destek ve kaynaklar sağlar.

Iron Software'den IronPDF Tanıtımı

IronPDF, .NET projelerinde PDF'leri yönetmek için kapsamlı bir çözüm sağlamak üzere tasarlanmış sağlam bir C# PDF kütüphanesidir. İhtiyaçlarınız PDF belgeleri oluşturma, düzenleme, dışa aktarma, güvenli hale getirme, yükleme veya manipüle etme içerdiğinde, IronPDF ihtiyacınız olan araçları sağlar. İşte bazı önemli özellikleri ve uygulamaları:

• IronPDF ile PDF oluşturmayı öğrenin
• IronPDF ile PDF'leri verimli bir şekilde nasıl düzenleyeceğinizi keşfedin
• IronPDF'ün güvenlik özelliklerini inceleyin
• Daha fazla bilgi için Iron Software web sitesini ziyaret edin
• Detaylı rehberlik için IronPDF dokümantasyonunu kontrol edin

Autofac.NET ve IronPDF Kullanarak PDF Belgesi Oluşturma

Öncelikle bir Visual Studio konsol uygulaması oluşturalım.

Proje adını ve konumunu sağlayın.

Bir sonraki adım için gerekli .NET sürümünü seçin ve Oluştur'a tıklayın.

Daha sonra Visual Studio Paket Yöneticisi'nden IronPDF kütüphanesini NuGet Paketi'nden yükleyin.

IronPDF kütüphanesini yükleme ve kullanma hakkında daha fazla bilgi için IronPDF Dokümantasyonunu ziyaret edin.

Visual Studio Paket Yöneticisi'nden NuGet Paketi'nden Autofac'ı yükleyin.

Autofac hakkında daha fazla bilgi için Autofac Dokümantasyon Sayfasını ziyaret edin.

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");
        }
    }
}

Imports Autofac
Imports CacheManager.Core
Imports IronPdf
Imports System.Reflection

Namespace IronPdfDemos
	Public Class AutoFac
		Public Shared Sub Execute()
			' Instantiate Cache and ChromePdfRenderer
			Dim renderer = New ChromePdfRenderer()
			Dim cache = CacheFactory.Build("ironPdfAutofac", Sub(settings)
				settings.WithDictionaryHandle()
			End Sub)

			' Prepare HTML content
			Dim 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
			Dim builder = New ContainerBuilder()
			content &= "<p>var builder = new ContainerBuilder();</p>"

			content &= "<h2>Registering types manually</h2>"
			' Registering types manually
			builder.RegisterType(Of MyService)().As(Of IMyService)()
			content &= "<p>builder.RegisterType<MyService>().As<IMyService();</p>"

			content &= "<h2>Registering types using assembly scanning</h2>"
			' Registering types using assembly scanning
			builder.RegisterAssemblyTypes(GetType(AutoFac).Assembly).Where(Function(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
			Dim container = builder.Build()
			content &= "<p>var container = builder.Build();</p>"

			content &= "<h2>Resolving dependencies</h2>"
			' Resolving dependencies
			Using scope = container.BeginLifetimeScope()
				Dim service = scope.Resolve(Of IMyService)()
				service.DoSomething()
			End Using
			content &= "<p>var service = scope.Resolve<IMyService();</p>"

			' Create a PDF from the HTML string using C#
			Dim pdf = renderer.RenderHtmlAsPdf(content)
			' Export to a file or Stream
			pdf.SaveAs("autofac.pdf")
			Console.WriteLine("We are done...")
			Console.ReadKey()
		End Sub
	End Class

	Friend Interface IMyService
		Sub DoSomething()
	End Interface

	Friend Class MyModule
		Inherits Module

		Protected Overrides Sub Load(ByVal builder As ContainerBuilder)
			' Register module dependencies here
		End Sub
	End Class

	Friend Class MyService
		Implements IMyService

		Public Sub DoSomething() Implements IMyService.DoSomething
			Console.WriteLine("DoSomething")
		End Sub
	End Class
End Namespace

IronPDF Lisansı

IronPDF bir lisans anahtarına ihtiyaç duyar. Aşağıda gösterildiği gibi appSettings.json dosyasına lisans anahtarını yerleştirin.

{
  "IronPdf.License.LicenseKey": "The Key Here"
}