Unity自相关接口注册

Question

An interface depends of same type of interface to complete some certain actions. But when I try to register it with unity I am getting

An unhandled exception of type 'System.StackOverflowException' occurred in Microsoft.Practices.Unity.DLL

I think it falls into a kind of self referencing loop and fills the memory.

Is there something wrong to my approach. How can I resolve it?

I have interface like this;

  public interface IEnvironment
{
    string RootUrl { get; set; }
    string ImagesPath { get; set; }
    IEnvironment DependentEnvironment { get; set; }
}

This is representation of my running code environment such as Localhost, Production, Windows Phone Simulator etc..

I have two classes implementing this right now;

class Localhost : IEnvironment
{
    public string RootUrl { get; set; }
    public string ImagesPath { get; set; }
    public IEnvironment DependentEnvironment { get; set; }

    public Localhost(IEnvironment dependentEnvironment)
    {
        ImagesPath = "images";
        DependentEnvironment = dependentEnvironment;
    }
}

and

public class WindowsPhoneSimulator : IEnvironment
    {
        public string RootUrl { get; set; }
        public string ImagesPath { get; set; }
        public IEnvironment DependentEnvironment { get; set; }
        public WindowsPhoneSimulator(IEnvironment dependentEnvironment)
        {
            ImagesPath = "/Assets/images";
            DependentEnvironment = dependentEnvironment;
        }
    }

so one environment can depend another one? Why? Because for example WindowsPhoneSimulator can make api calls to localhost and when I deploy application I will change injection as ProductionEnvironment. So it should know which environment to call.

The problem begins when I start to resolve my objects like;

    IocContainer.RegisterType<IEnvironment, WindowsPhoneSimulator>();

any suggestions?

Answer 1

You haven't shown how you are registering your types, but presumably you are just registering them with a standard RegisterType method. When you register the second type, it will overwrite the first, so Unity only knows about one of your classes (the one that is registered second). Then it makes sense as to why you get a stack overflow exception, because it is trying to create an instance of say, the WindowsPhoneSimulator class to pass into the WindowsPhoneSimulator class...which obviously it can't do.

Instead you will need to register the types in unity as "named types", then when you want to use one of them, you create a dependency override when resolving the class, to tell Unity which one you want to use.

So, register the types as named types:

container.RegisterType<IEnvironment, Localhost>("Localhost")
container.RegisterType<IEnvironment, WindowsPhoneSimulator>("WindowsPhoneSimulator")

Then when you want to create the type, something like this:

DependencyOverride dep = new DependencyOverride(typeof(IEnvironment)
                        , container.Resolve<IEnvironment>("Localhost"));

IEnvironment obj2 = container.Resolve<IEnvironment>("WindowsPhoneSimulator", dep);

In the above example, you are first resolving the instance of the Localhost class, and then creating the dependencyOverride with that instance, and passing it into the constructor for the WindowsPhoneSimulator class. So, WindowsPhoneSimulator gets passed the instance of Localhost when it is constructed.