CODEWITHSUNDEEP
c#dependency-injection
Edward Gallardo
Edward Gallardo

Reputation: 11

What are the benefits of using a dependency resolver may be Ninject than using some conditional statement to resolve dependency

Hello first of all I'm just a newbie programmer, I just discovered how dependency injection pattern works and it is used to make my code more loosely coupled. I don't specifically know how to configure a Ninject to resolve the dependency, is it better to use these plug in?

Currently my approach when resolving dependency is like this.

public class MyClass
{
    IContract _contract = null;

    MyClass()
    { 
    }

    MyClass(IContract contract)
    {
        _contract = contract;
    }

    public void DoSomething()
    {
        IContract concreteImplementation = _contract ?? new ConcreteContract();

        concreteImplementation.MyMethod();
    }
}
public class ConcreteContract : IContract
{

    public void MyMethod()
    {
        //do something;
    }
}
public interface IContract
{
   void MyMethod();
}

Upvotes: 0

Views: 89

Answers (1)

jim tollan
jim tollan

Reputation: 22485

Edward...

I thought I'd add a little detail to my comment. The benefits of DI are as you mention (looser coupling). Also, it allows you to register your contract at both compile and runtime, depending on your requirement. As a result, you can add new implementations without breaking the class that you wish to resolve against.

You'll need a slight refactor to accomplish your goal using Unity. Below is a small self contained example (console app), using your class definitions (and showing an alternative implementation):

public class MyClass
{
    readonly IContract _contract = null;

    // do not include a paramterless ctor
    // thus preventing class being created
    // without a concrete implementation of IContract 
    public MyClass(IContract contract)
    {
        _contract = contract;
    }

    public void DoSomething()
    {
        _contract.MyMethod();
    }
} 

public class ConcreteContract : IContract
{

    public ConcreteContract() { }
    public void MyMethod()
    {
        //do something;
        Debug.Print("Hello from the ConcreteContract class");
    }
}

public class PlasticContract : IContract
{

    public PlasticContract() { }
    public void MyMethod()
    {
        //do something;
        Debug.Print("Hello from the PlasticContract class");
    }
}

public interface IContract
{
    void MyMethod();
}

class Program
{
    // add the nuget package Unity 1st
    // Install-Package Unity
    static void Main(string[] args)
    {
        // Declare a Unity Container -
        // normally done once in the Startup/Bootstrap class
        var unityContainer = new UnityContainer();

        // Register IContract so when dependecy is detected
        // it provides a ConcreteContract instance 
        // you could change this to <IContract, PlasticContract>
        unityContainer.RegisterType<IContract, ConcreteContract>();

        // Instance a MyClass class object through Unity
        var preferredClass = unityContainer.Resolve<MyClass>();
        preferredClass.DoSomething();
    }
}

Hope this gets you to the next stage.

Upvotes: 1

Related Questions