using System;

using System.Linq;

using StructureMap;

​

/// some interface

public interface IDependency

{

}

​

/// Class implementing some interface

public class DependencyOne : IDependency

{

    public DependencyOne()

    {

        Console.WriteLine("  creating DependencyOne()");

    }

}

​

/// Alternative implementation of some interface

public class DependencyTwo : IDependency

{

    public DependencyTwo()

    {

        Console.WriteLine("  creating DependencyTwo()");

    }

}

​

/// will be used as a Lazy<T>

public class LazyDependency

{

    public LazyDependency()

    {

        Console.WriteLine("  creating LazyDependency()");

    }

}

​

/// will be used as a singleton instance

public class SingletonDependency

{

    public SingletonDependency()

    {

        Console.WriteLine("  creating SingletonDependency()");

    }

}

​

/// Class using dependencies

public class Application

{

    public IDependency Dep { get; set; }

    public Lazy<LazyDependency> LazyDep { get; set; }

    public SingletonDependency SingleDep { get; set; }

    /// specify dependencies in the constructor

    public Application(IDependency dep, Lazy<LazyDependency> lazyDep, SingletonDependency singleDep)

    {

        Console.WriteLine(" creating Application()");

        Dep = dep;

        LazyDep = lazyDep;

        SingleDep = singleDep;

    }

    public void DoThing()

    {

    }

}

​

public class Program

{

    public static void Main()

    {

        // build a container with some registrations

        // there are much nicer and more powerful ways of doing this

        // this is the crudest form

        var container = new Container();

        container.Configure(c => {

            // make DependencyOne resolve for IDepencency

            // and set the lifecycle to be tied to the container scope          

            c.For<IDependency>()

                .Use<DependencyOne>()

                .ContainerScoped();

            // make lazy dependency a singleton

            c.ForConcreteType<LazyDependency>()

                .Configure.Singleton();

​

            // ditto for the singleton

            c.ForConcreteType<SingletonDependency>()

                .Configure.Singleton();

​

            // give the application a transient lifecycle

            // so the demo can showcase other lifecycles

            c.ForConcreteType<Application>()

                .Configure.Transient();

        });

​

        // making a sub-scoped container

        Console.WriteLine("Using scope one");

        using(var scoped = container.CreateChildContainer())

        {

            RunThing(scoped);

            RunThing(scoped);

        }

        // and another one here

        // a new DependencyOne will be created for each scope

        Console.WriteLine("Using scope two");

        using(var scoped = container.CreateChildContainer())

        {

            RunThing(scoped);

            RunThing(scoped);

        }

        // change the registration for the IDependency interface

        Console.WriteLine("Using main scope, changed IDependency type");

        container.Configure(c => {

            c.For<IDependency>().Use<DependencyTwo>().ContainerScoped();

        });

        RunThing(container, true);

        // add multiple dependencies for one type

        Console.WriteLine("Registering multiple instances");

        container.Configure(c => {

            c.For<IDependency>().ClearAll();

            c.For<IDependency>().Add<DependencyOne>();

            c.For<IDependency>().Add<DependencyTwo>();

        });

        Console.WriteLine($"IDependency instances: {container.GetAllInstances<IDependency>().Count()}");

    }

    public static void RunThing(IContainer container, bool useLazy = false)

    {

        var app = container.GetInstance<Application>();

        app.DoThing();

        // show that Lazy<T> is only created after use

        if (useLazy)

            app.LazyDep.Value.GetHashCode();

    }

}