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

Autofac .NET'i Anlamak

Autofac, .NET için açık kaynaklı bir IoC konteyneridir ve web API'leri gibi uygulamalarda bağımlılık enjeksiyonu ve bileşen kaydı için kapsamlı destek sağlar. Nicholas Blumhardt tarafından geliştirilen ve adanmış bir topluluk tarafından sürdürülen Autofac, nesne yaşam döngülerinin yönetimi, bağımlılıkların çözülmesi ve uygulama bileşenlerinin kompozisyonu için sağlam ve esnek bir çözüm sunar.

.NET uygulamalarınızı Autofac ile nasıl geliştirebileceğiniz hakkında daha fazla bilgi için, .NET PDF Library tarafından sağlanan IronPDF kaynaklarını keşfetmeyi düşünebilirsiniz; bu kaynaklar, PDF oluşturma ve manipülasyonu için gelişmiş özellikleri vurgular. Başka bir yandan, barkod oluşturma alanında bağımlılık enjeksiyonu uygulamaları görmek için IronBarcode'ın .NET Barkod Kütüphanesine dalabilirsiniz.

IronOCR ve IronXL gibi ürünlerden oluşan ve Autofac ile sorunsuz bir şekilde entegre olan kapsamlı bir ürün yelpazesini bulacağınız IronSoftware'in resmi sayfasına göz atarak gerçek dünya senaryolarında Autofac kullanarak ek bilgiler ve pratik örneklerle etkileşimde bulunun.

Autofac'ın Özellikleri

1. Konteyner Oluşturma ve Bileşen Kaydı: Başlangıç sınıfında bileşenleri kaydederek Autofac ile konteynerler oluşturabilirsiniz. Bileşenleri lambda ifadeleri, türler veya önceden oluşturulmuş örnekler kullanarak 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, yapıcı parametrelerini enjekte edebilir, özellik enjeksiyonunu gerçekleştirebilir ve yöntem enjeksiyonunu yönetebilir.

   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. Kodda karmaşık kayıtları belirtebilir veya dağıtım zamanı davranışını XML kullanarak 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şletme Noktaları: Autofac, bileşen aktivasyonunu veya serbest bırakmayı ö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ştiricilere manuel kayıt, montaj taraması ve atribut tabanlı kayıtlar dahil olmak üzere çeşitli kayıt teknikleri kullanarak bileşen kaydetme imkanı sunar. Bu esneklik, bileşen oluşturma ve yapılandırma üzerinde ince ayar yapılabilmesini sağlar.

2. Yaşam Süresi Yönetimi: Autofac, singleton, bağımlılık başına örnek, yaşam süresi kapsam başına örnek ve istek başına örnek dahil olmak üzere çeşitli nesne yaşam süresi kapsamlarını destekler. Nesne yaşam süreleri üzerinde bu ayrıntılı kontrol, kaynakların verimli kullanılmasını ve uzun süren uygulamalarda bellek sızıntılarını önler.

3. Otomatik Bağımlılık Çözümü: Autofac, kaydedilmiş bileşen kayıtlarına ve bağımlılıklarına dayalı olarak otomatik olarak bağımlılıkları çözer. Bu otomatik bağlantı, karmaşık nesne grafiklerinin yapılandırılmasını basitleştirir ve bileşenler arasında gevşek bağlanmayı teşvik eder.

4. Modül Kompozisyonu: Autofac, geliştiricilerin bileşen kayıtlarını modüller kullanarak organize etmelerine ve kapsüllerine olanak tanır. Modüller, ilişkili kayıtlar için mantıksal konteynerler olarak hizmet eder ve birden fazla bileşeni barındıran büyük ölçekli uygulamaların yönetimini ve sürdürülmesini kolaylaştırır.

5. Yakalama ve AOP: Autofac, yakalama genişletmesi aracılığıyla yakalama ve yönlendirilmiş programlama (AOP) desteği sağlar. Yakalama ile geliştiriciler, bileşenlerin uygulamalarını değiştirmeden günlük kaydı, ön bellekleme ve güvenlik gibi çapraz kesim endişelerini uygulayabilir.

6. ASP.NET Core ve .NET Core Entegrasyonu: Autofac, .NET Core ve ASP.NET Core ile sorunsuz bir şekilde entegre olur ve modern web uygulamalarında ve mikro hizmetlerinde bağımlılık enjeksiyonu için birinci sınıf destek sunar. Yerleşik hizmet sağlayıcı soyutlamasından yararlanır ve .NET ekosistemi ile uyumluluğu ve birlikte çalışabilirliği sağlamak amacıyla.

Autofac.NET ile Pratik Örnekler

Autofac.NET kullanımını göstermek için bazı pratik örnekleri keşfedelim:

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'in bağımlılık enjeksiyonu için uygulamalı kullanımını gösterdik. Manuel kayıttan montaj taramasına ve modül tabanlı kayda kadar, Autofac'ın bağımlılıkları yönetmedeki sunduğu esnekliği gösterdik. Bu teknikleri kullanarak, geliştiriciler uygulamalarının bağımlılık enjeksiyonu sürecini kolaylaştırabilir, sürdürmeyi ve ölçeklenebilirliği artırabilirler.

Iron Software ürünlerinin .NET uygulamalarınızla nasıl entegre olacağını ve işlevselliklerini daha fazla optimize edeceğini öğrenmek için IronPDF dokümantasyonunu keşfedin; burada programlı olarak PDF belgelerinin oluşturulması ve düzenlenmesi hakkında bilgi edinilebilir veya bar kodları okuma ve yazma için IronBarcode gibi güçlü .NET kitaplıklarını ve gelişmiş optik karakter tanıma için IronOCR'yi keşfetmek için Iron Software'in web sitesini ziyaret edin.

Autofac.NET Kullanımının Faydaları

1. Basitlik ve Esneklik: Autofac, bileşenleri kaydetmek ve çözmek için basit ve sezgisel bir API sunar, bu sayede bağımlılık enjeksiyonu kolayca uygulanır ve sürdürülebilir hale gelir.

2. Test Edilebilirlik ve Sürdürülebilirlik: Gevşek bağlamayı ve bağımlılık tersine çevirmeyi teşvik ederek, Autofac .NET uygulamalarının test edilebilirliğini ve sürdürülebilirliğini artırır, birim testlerini ve yeniden düzenlemeyi kolaylaştırır.

3. Performans ve Ölçeklenebilirlik: Autofac'ın hafif ve verimli çalışma zamanı performansı, yüksek performanslı uygulamalar ve büyük nesne grafiklerine sahip ölçeklenebilir sistemler için uygun hale getirir.

4. Genişletebilirlik ve Özelleştirme: Autofac'ın genişletilebilir mimarisi, geliştiricilerin özel modüller, kayıt kaynakları ve ara katman bileşenleri aracılığıyla Autofac'ın davranışını uygulama gereksinimlerine göre genişletmesine ve özelleştirmesine olanak tanır.

5. Topluluk ve Destek: Gelişmiş bir geliştirici topluluğu ve kapsamlı dokümantasyon ile Autofac, çerçeveye öğrenme, sorun giderme ve katkı sağlama için mükemmel destek ve kaynaklar sunar.

Iron Software'den IronPDF'yi Tanıtma

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. İhtiyacınız PDF belgeleri oluşturmayı, düzenlemeyi, dışa aktarmayı, güvence altına almayı, yüklemeyi veya manipüle etmeyi içeriyorsa, IronPDF ihtiyaçınız olan araçlara sahiptir. İşte bazı dikkat çekici özellikleri ve uygulamaları:

• IronPDF ile PDF oluşturma hakkında daha fazla bilgi edinin
• IronPDF ile PDF'leri verimli bir şekilde düzenlemeyi keşfedin
• IronPDF'in güvenlik özelliklerini keşfedin
• Daha fazla ayrıntı için Iron Software web sitesini ziyaret edin
• Ayrıntılı kılavuz için IronPDF dokümantasyonuna göz atın

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.

Sonraki adım olarak, gerekli .NET sürümünü seçin ve Oluştur'a tıklayın.

Ardından Visual Studio Paket Yöneticisinden NuGet Paketi aracılığıyla IronPDF kütüphanesini yükleyin

IronPDF kütüphanesini kurma ve kullanma hakkında daha fazla bilgi için IronPDF Dokümantasyonuna göz atın.

Visual Studio Paket Yöneticisinden NuGet Paketi aracılığıyla Autofac'i yükleyin

Autofac hakkında daha fazla bilgi edinmek 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ı gerektirir. Aşağıda gösterildiği gibi appSettings.json dosyasına lisans anahtarını yerleştirin.

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