Dependency Injection Example: Interface Injection

using System;

namespace DependencyInjection
{
    public interface IDependentClass
    {
        void DoSomethingInDependentClass();
    }

    public interface IInjectDependent
    {
        void InjectDependent(IDependentClass dependentClass);
    }

    public class MainClass : IInjectDependent
    {
        IDependentClass dependentClass;

        public void DoSomething()
        {
            dependentClass.DoSomethingInDependentClass();
        }

        #region IInjectDependent Members

        public void InjectDependent(IDependentClass dependentClass)
        {
            this.dependentClass = dependentClass;
        }

        #endregion
    }

    public class DependentClass1 : IDependentClass
    {
        public void DoSomethingInDependentClass()
        {
            Console.WriteLine("Hello from DependentClass1: I can be injected into MainClass");
        }
    }

    public class DependentClass2 : IDependentClass
    {
        public void DoSomethingInDependentClass()
        {
            Console.WriteLine("Hello from DependentClass2: I can be injected as well, just change App.Config");
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            // Get the correct dependency based on configuration file
            IDependentClass dependency = GetCorrectDependency();

            // Create our main class and inject the dependency
            MainClass mainClass = new MainClass();
            ((IInjectDependent)mainClass).InjectDependent(dependency);

            // Use the main class, the method references the dependency
            // so behaviour depends on the configuration file
            mainClass.DoSomething();

            Console.ReadLine();
        }

        /// <summary>
        /// Instantiate and return a class conforming to the IDependentClass interface:
        /// which class gets instantiated depends on the ClassName setting in
        /// the configuration file
        /// </summary>
        /// <returns>Class conforming to the IDependentClass interface</returns>
        static IDependentClass GetCorrectDependency()
        {
            string classToCreate = System.Configuration.ConfigurationManager.AppSettings["ClassName"];
            Type type = System.Type.GetType(classToCreate);
            IDependentClass dependency = (IDependentClass)Activator.CreateInstance(type);
            return dependency;
        }
    }
}
Advertisements

8 thoughts on “Dependency Injection Example: Interface Injection

  1. This is one of the most concise explanation on DI.

    I have read Martin Fowler’s original version. However, it was not easy to grasp. Your version was able to enlighten me on the subject.

  2. I wonder if it is possible to “inject an interface *implementation*” as well. By this I do not mean to generate a new type that implements some interface (which is certainly doable), but to modify an existing (precomiled) type at run-time so it supports an interface?

    I want this in order to enable me to generate data access code dynamically and allow this code to access the private fields of entity classes (read them when saving, write them when loading).

    In other words, I want an entity class to change from something like

    public class Toto : Entity
    {
    int n;
    Toto parent;
    //… non-field members
    }

    at run-time into something like

    public class Toto : Entity, IFieldAccessible
    {
    int n;
    Toto parent;
    //… non-field members
    object[] IFieldAccessible.GetFieldValues()
    {
    return new object[] { n, parent };
    }

    void IFieldAccessible.SetFieldValues(object[] values)
    {
    n = (int)values[0];
    parent = (Toto)values[1];
    }
    }

    I can generate the implementation by using reflection to discover the fields, but I need it to be somehow embedded into the type itself since otherwise I cannot access the fields without using reflection on every instance, which is comparatively slow.

  3. Thanks!. I too searched the whole web for a meaningful explanation but either it was over the head-too abstract or too flimsy in explanation.Again thanks!.

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s