using System;

using System.Collections.Generic;

using System.Linq;

using System.Reactive.Linq;

using IoC;

public class Program

{   

    internal Program(

        ICat cat,

        IBox<ICat> box,

        IBox<IBox<ICat>> bigBox,

        Func<IBox<ICat>> func,

        Tuple<IBox<ICat>, ICat, IBox<IBox<ICat>>> tuple,

        Lazy<IBox<ICat>> lazy,

        IEnumerable<IBox<ICat>> enumerable,

        IBox<ICat>[] array,

        IList<IBox<ICat>> list,

        ISet<IBox<ICat>> set,

        IObservable<IBox<ICat>> observable,

        IBox<Lazy<Func<IEnumerable<IBox<ICat>>>>> complex)

    {

        Console.WriteLine(cat);

        Console.WriteLine(box);

        Console.WriteLine(bigBox);

        Console.WriteLine("{0} from func", func());

        Console.WriteLine("Tuple of {0}", tuple);

        Console.WriteLine("Lazy of {0}", lazy.Value);

        Console.WriteLine("Enumeration of {0}", enumerable.Single());

        Console.WriteLine("Array of {0}", array.Single());

        Console.WriteLine("List of {0}", list.Single());

        Console.WriteLine("Set of {0}", set.Single());

        Console.WriteLine("Observable of {0}", observable.Single());

        Console.WriteLine("Complex {0}", complex.Content.Value().Single());

    }

​

    public static void Main()

    {

        // Build up Program using Glue

        using (new Glue().BuildUp<Program>()) { }

    }

}

​

// Let's create an abstraction

​

interface IBox<out T> { T Content { get; } }

​

interface ICat { State State { get; } }

​

enum State { Alive, Dead }

​

// Here is our implementation

​

class CardboardBox<T> : IBox<T>

{

    public CardboardBox(T content) { Content = content; }

​

    public T Content { get; private set; }

​

    public override string ToString() { return "[" + Content + "]"; }

}

​

class ShroedingersCat : ICat

{

    // Superposition of the state

    private readonly Lazy<State> _superposition;

​

    public ShroedingersCat(Lazy<State> superposition) { _superposition = superposition; }

​

    // Decoherence of the superposition at the time of observation via an irreversible process

    public State State { get { return _superposition.Value; } }

​

    public override string ToString() { return State + " cat"; }

}

​

// Let's glue all together

​

class Glue : IConfiguration

{

    public IEnumerable<IToken> Apply(IContainer container)

    {

        yield return container

            .Bind<IBox<TT>>().To<CardboardBox<TT>>()

            .Bind<ICat>().To<ShroedingersCat>();

​

        // Models a random subatomic event that may or may not occur

        var indeterminacy = new Random();

        // Quantum superposition

        yield return container.Bind<State>().To(ctx => (State)indeterminacy.Next(2));

    }

}