Now a days I am experimenting with various IoC containers and trying to implement POC and sharing with the community. This article assumes a basic understanding of de-coupled architecture and the concept of Inversion of Control. In our previous article we talked about Unity and Ninject, you can read them here.

We know that IoC stands for Inversion of Control and it's a way to implement more independent components and to make the work easy, there are many IoC containers in the market, Autofac is one of them. In this article we will try to implement a simple example of dependency injection using Autofac. First of all create one Console application to implement the sample example and provide a reference of Autofac from the NuGet Package Manager. Here is the package.

package

Once you provide a reference, you will find the following reference in the references section of the application.
reference

We are now ready to implement the IoC container using autofac. Have a look at the following example. At first we have implemented two interfaces and it's corresponding concrete class.
  1. using System;
  2. using System.Collections.Generic;
  3. using System.Linq;
  4. using System.Text;
  5. using Autofac;
  7. public interface IMobileServive
  8. {
  9. void Execute();
  10. }
  11. public class SMSService : IMobileServive
  12. {
  13. public void Execute()
  14. {
  15. Console.WriteLine("SMS service executing.");
  16. }
  17. }
  19. public interface IMailService
  20. {
  21. void Execute();
  22. }
  24. public class EmailService : IMailService
  25. {
  26. public void Execute()
  27. {
  28. Console.WriteLine("Email service Executing.");
  29. }
  30. }
  32. public class NotificationSender
  33. {
  34. public IMobileServive ObjMobileSerivce = null;
  35. public IMailService ObjMailService = null;
  37. //injection through constructor
  38. public NotificationSender(IMobileServive tmpService)
  39. {
  40. ObjMobileSerivce = tmpService;
  41. }
  42. //Injection through property
  43. public IMailService SetMailService
  44. {
  45. set { ObjMailService = value; }
  46. }
  47. public void SendNotification()
  48. {
  49. ObjMobileSerivce.Execute();
  50. ObjMailService.Execute();
  51. }
  52. }
  54. namespace Client
  55. {
  56. class Program
  57. {
  58. static void Main(string[] args)
  59. {
  60. var builder = new ContainerBuilder();
  61. builder.RegisterType<SMSService>().As<IMobileServive>();
  62. builder.RegisterType<EmailService>().As<IMailService>();
  63. var container = builder.Build();
  65. container.Resolve<IMobileServive>().Execute();
  66. container.Resolve<IMailService>().Execute();
  67. Console.ReadLine();
  68. }
  69. }
  70. }

We have then implemented a NotificationSender class that is dependent on both MobileService and MailService.

We have injected a dependency of both classes through constructor and property. Have a look at the Main() function where we have created a repository of all dependency types and building the repository. Once we run the application we will see the following result.

result

Conclusion

There are many IoC containers available in the market and Autofac is one of them. All the containers have some pros and cons and none of them are perfect, so the choice is yours.