Location via proxy:   [ UP ]  
[Report a bug]   [Manage cookies]                
Scribd Logo
Upload

Welcome to Scribd!

  • 15 views

    Dependency Injection

    Uploaded by

    xabcde112
    Dependency injection (DI) is a design pattern that reduces tight coupling between classes by supplying dependencies from external sources rather than creating them internally. DI allows code to be more maintainable and reusable by making classes independent of their concrete dependencies. There are different ways to implement DI, including constructor injection where dependencies are passed via a class's constructor, property injection where dependencies are set via properties, and method injection where dependencies are passed to specific methods. DI improves code quality by enabling loose coupling, increasing testability, and facilitating maintenance through abstraction of dependencies.

    Copyright:

    © All Rights Reserved
    Download as DOCX, PDF, TXT or read online from Scribd

    Dependency Injection

    Uploaded by

    xabcde112
    15 views4 pages
    Dependency injection (DI) is a design pattern that reduces tight coupling between classes by supplying dependencies from external sources rather than creating them internally. DI allows code to be more maintainable and reusable by making classes independent of their concrete dependencies. There are different ways to implement DI, including constructor injection where dependencies are passed via a class's constructor, property injection where dependencies are set via properties, and method injection where dependencies are passed to specific methods. DI improves code quality by enabling loose coupling, increasing testability, and facilitating maintenance through abstraction of dependencies.

    Original Description:

    Dependency Injection

    Copyright

    © © All Rights Reserved

    Available Formats

    DOCX, PDF, TXT or read online from Scribd

    Did you find this document useful?

    Is this content inappropriate?

    Dependency injection (DI) is a design pattern that reduces tight coupling between classes by supplying dependencies from external sources rather than creating them internally. DI allows code to be more maintainable and reusable by making classes independent of their concrete dependencies. There are different ways to implement DI, including constructor injection where dependencies are passed via a class's constructor, property injection where dependencies are set via properties, and method injection where dependencies are passed to specific methods. DI improves code quality by enabling loose coupling, increasing testability, and facilitating maintenance through abstraction of dependencies.

    Copyright:

    © All Rights Reserved
    Download as DOCX, PDF, TXT or read online from Scribd
    Download as docx, pdf, or txt
    15 views4 pages

    Dependency Injection

    Uploaded by

    xabcde112
    Dependency injection (DI) is a design pattern that reduces tight coupling between classes by supplying dependencies from external sources rather than creating them internally. DI allows code to be more maintainable and reusable by making classes independent of their concrete dependencies. There are different ways to implement DI, including constructor injection where dependencies are passed via a class's constructor, property injection where dependencies are set via properties, and method injection where dependencies are passed to specific methods. DI improves code quality by enabling loose coupling, increasing testability, and facilitating maintenance through abstraction of dependencies.

    Copyright:

    © All Rights Reserved
    Download as DOCX, PDF, TXT or read online from Scribd
    Download as docx, pdf, or txt
    of 4

    Dependency Injection (DI) is a software design pattern that allows us to develop loosely

    coupled code. DI is a great way to reduce tight coupling between software components.
    DI also enables us to better manage future changes and other complexity in our
    software. The purpose of DI is to make code maintainable.
    The Dependency Injection pattern uses a builder object to initialize objects and provide
    the required dependencies to the object means it allows you to "inject" a dependency
    from outside the class.

    For example, Suppose your Client class needs to use two service classes, then the best
    you can do is to make your Client class aware of abstraction i.e. IService interface
    rather than implementation i.e. Service1 and Service2 classes. In this way, you can
    change the implementation of the IService interface at any time (and for how many
    times you want) without changing the client class code.

    We can modify this code by following the Dependency Injection implementation ways.
    We have the following different ways to implement DI :

    Constructor Injection
    1. This is a widely used way to implement DI.
    2. Dependency Injection is done by supplying the DEPENDENCY through the class’s
    constructor when creating the instance of that class.
    3. Injected component can be used anywhere within the class.
    4. Recommended to use when the injected dependency, you are using across the class
    methods.
    5. It addresses the most common scenario where a class requires one or more
    dependencies.
    1. public interface IService {
    2. void Serve();
    3. }
    4. public class Service1 : IService {
    5. public void Serve() { Console.WriteLine("Service1 Called"); }
    6. }
    7. public class Service2 : IService {
    8. public void Serve() { Console.WriteLine("Service2 Called"); }
    9. }
    10. public class Client {
    11. private IService _service;
    12. public Client(IService service) {
    13. this._service = service;
    14. }
    15. public ServeMethod() { this._service.Serve(); }
    16. }
    1. class Program
    2. {
    3. static void Main(string[] args)
    4. {
    5. //creating object
    6. Service1 s1 = new Service1();
    7. //passing dependency
    8. Client c1 = new Client(s1);
    9. //TO DO:
    10.
    11. Service2 s2 = new Service2();
    12. //passing dependency
    13. c1 = new Client(s2);
    14. //TO DO:
    15. }
    16. }
    The Injection happens in the constructor, bypassing the Service that implements the
    IService Interface. The dependencies are assembled by a "Builder" and Builder
    responsibilities are as follows:
    1. Knowing the types of each IService
    2. According to the request, feed the abstract IService to the Client

    Property/Setter Injection
    1. Recommended using when a class has optional dependencies, or where the
    implementations may need to be swapped.
    2. Different logger implementations could be used in this way.
    3. Does not require the creation of a new object or modifying the existing one.
    Without changing the object state, it could work.
    1. public interface IService {
    2. void Serve();
    3. }
    4. public class Service1 : IService {
    5. public void Serve() { Console.WriteLine("Service1 Called"); }
    6. }
    7. public class Service2 : IService {
    8. public void Serve() { Console.WriteLine("Service2 Called"); }
    9. }
    10. public class Client {
    11. private IService _service;
    12. public IService Service {
    13. set { this._service = value; }
    14. }
    15. public ServeMethod() { this._service.Serve(); }
    16. }
    1. class Program
    2. {
    3. static void Main(string[] args)
    4. {
    5. //creating object
    6. Service1 s1 = new Service1();
    7.
    8. Client client = new Client();
    9. client.Service = s1; //passing dependency
    10. //TO DO:
    11.
    12. Service2 s2 = new Service2();
    13. client.Service = s2; //passing dependency
    14. //TO DO:
    15. }
    16. }

    Method Injection
    1. Inject the dependency into a single method and generally for the use of that
    method.
    2. It could be useful, where the whole class does not need the dependency, only one
    method having that dependency.
    3. This is the way is rarely used.
    1. public interface IService {
    2. void Serve();
    3. }
    4. public class Service1 : IService {
    5. public void Serve() { Console.WriteLine("Service1 Called"); }
    6. }
    7. public class Service2 : IService {
    8. public void Serve() { Console.WriteLine("Service2 Called"); }
    9. }
    10. public class Client {
    11. private IService _service;
    12. public void Start(IService service) {
    13. service.Serve();
    14. }
    15. }
    1. class Program
    2. {
    3. static void Main(string[] args)
    4. {
    5. //creating object
    6. Service1 s1 = new Service1();
    7.
    8. Client client = new Client();
    9. client.Start(s1); //passing dependency
    10. //TO DO:
    11.
    12. Service2 s2 = new Service2();
    13. client.Start(s2); //passing dependency
    14. }
    15. }

    Advantages of Dependency Injection


    1. Reduces class coupling
    2. Increases code reusability
    3. Improves code maintainability
    4. Make unit testing possible

    You might also like