MugenInjection Wiki Rss Feed

Updated Wiki: Home

VVS0205 — Wed, 03 Apr 2013 08:33:40 GMT

Project Description

The MugeniInjection is a lightweight and fast managed IoC (Inversion of Control) and DI (Dependency Injection) with support for constructor, property and method call injection. For more information, see the documentation and examples.
If you have any ideas for future releases write them here.

Supported platforms:

NET 2.0 - 4.5
WinRT
Silverlight 4-5
Windows phone 7.1-8.0
MVC 2-4
WCF

Extensions:

NServiceBus.ObjectBuilder
Interceptors
Xml configuration
Log4Net
NLog2

Updated Wiki: Home

VVS0205 — Sat, 30 Mar 2013 08:23:06 GMT

Project Description

Supported platforms:

NET 2.0 - 4.5
WinRT
Silverlight 4-5
Windows phone 7.1-8.0
MVC 2-4
WCF

Extensions:

NServiceBus.ObjectBuilder
Interceptors
Xml configuration
Log4Net
NLog2

Updated Wiki: Home

VVS0205 — Thu, 14 Mar 2013 17:19:44 GMT

Project Description

Supported platforms:

NET 2.0 - 4.5
WinRT
Silverlight 4-5
Windows phone 7.1-8.0
MVC 2-4
WCF

Extensions:

NServiceBus.ObjectBuilder
Interceptors
Xml configuration
Log4Net
NLog2

Updated Wiki: Documentation

VVS0205 — Thu, 14 Mar 2013 16:53:18 GMT

Documentation in English is available here.
Documentation in Russian is available here.

Updated Wiki: Home

VVS0205 — Sat, 29 Sep 2012 16:57:51 GMT

Project Description

A lightweight and fast managed IoC (Inversion of Control) and DI (Dependency Injection) with support for constructor, property, field, and method call injection. See documentation and example for more detail.

Supported platforms:

NET 2.0 - 4.5.
WinRT
Silverlight 3-5
Windows phone 7-7.1
Supported MVC 2 - 4
Supported WCF
Supported NServiceBus.ObjectBuilder
Supports private protected internal injection in Silverlight(4-5).
Supports interceptors.
Easy integration with libraries for logging(Log4Net, NLog2).

Available in nuget

PM> Install-Package MugenInjection

Updated Wiki: Documentation

VVS0205 — Sun, 12 Aug 2012 12:32:17 GMT

Registrating bindings
Registrating bindings (Extended)
Child container
Settings
Lifecycle scope
Work with parameters.
Custom parameter passing
Activators of objects.
Work with modules
Events
Specified condition for bindings.
Named binding
Select specific constructor.
Priority bindings
WCF
MVC
Performance

Updated Wiki: Registrating bindings (Extended)

VVS0205 — Sun, 12 Aug 2012 12:16:38 GMT

Using Parameters

When you register service you can specify the IInjectionParameter, available parameter types:

ConstructorParameter - represents the value of a constructor argument.
FieldParameter - represents the value of a field parameter.
PropertyParameter - represents the value of a property parameter.
MethodParameter - represents the value of a method parameter.

You can easily extend this list by implementing the interface IInjectionParameter.
This code shows how to add parameters to binding:

injector.Bind<A>().ToSelf()
                .WithConstructorArgument("arg", 1)
                .WithFieldValue("field", "field")
                .WithPropertyValue("property", new C())
                .WithMethodArgument("methodName", "arg", "st")
                .WithParameter(new CustomParameter());

Using Named bindings

Services can be further identified using a service name. Names are not necessarily unique; multiple bindings for a given service may be registered with the same name:

injector.Bind<Alfa>().ToSelf();
injector.Bind<Alfa>().To<Beta>().NamedBinding("Beta");
injector.Bind<Alfa>().To<Bravo>().NamedBinding("Bravo");

var alfa = injector.Get<Alfa>();//Instance of Alfa.
var beta = injector.Get<Alfa>("Beta");//Instance of Beta.
var bravo = injector.Get<Alfa>("Bravo");//Instance of Bravo.

Using a condition for bindings

When you register service you can specify the condition for bindings, available conditions:

WhenInto - Indicates that the binding should be used only for injections on the specified type. Types that derive from the specified type will not be considered as valid target.
WhenIntoIsAssignable - Indicates that the binding should be used only for injections on the specified type. Types that derive from the specified type are considered as valid targets.
WhenNamespaceEqual - Indicates that the binding should be used only for injections on the specified type when namespace equals.
WhenClassHasAttribute - Indicates that the binding should be used only when the class being injected has an attribute of the specified type.
When - Indicates that the binding should be used only for requests that support the specified condition.

injector.Bind<Alfa>().ToSelf()
                .When(context => context.TypeInto != null && context.TypeInto.FullName.StartsWith("S"));
injector.Bind<Alfa>().ToSelf()
                .WhenInto<Beta>();
injector.Bind<Alfa>().ToSelf()
                .WhenIntoIsAssignable<Alfa>();
injector.Bind<Alfa>().ToSelf()
                .WhenClassHasAttribute<SerializableAttribute>();
injector.Bind<Alfa>().ToSelf()
                .WhenNamespaceEqual("Test");

Set an IActivator

By default, the IActivator for binding is used from configuration of the IInjector, but you can change this. When you register service you can specify the IActivator that will use for create service, available IActivator:

ReflectionActivator - for creating objects using reflection (Available on all platforms).
EmitActivator - for creating objects using emit (Available on all platforms except Windows phone 7).
ExpressionActivator - for creating objects using expression trees (Available on all platforms except Windows phone 7 and NET 2).

You can easily extend this list by implementing the interface IActivator.

injector.Bind<Alfa>().ToSelf().UseEmitActivator();
injector.Bind<Alfa>().ToSelf().UseReflectionActivator();
injector.Bind<Alfa>().ToSelf().UseExpressionActivator();
injector.Bind<Alfa>().ToSelf().UseCustomActivator(new YourCustomActivator());

Set an IConstructorResolver

By default, the IConstructorResolver for binding is used from configuration of the IInjector, but you can change this. When you register service you can specify the IConstructorResolver

injector.Bind<Alfa>().ToSelf().UseCustomConstructorResolver(new CustomConstructorResolver());

Select a special constructor

When you register service you can specify the constructor that will use for create service:

injector.Bind<Alfa>().ToSelf().TakeConstructor<Bravo>();
injector.Bind<Alfa>().ToSelf().TakeConstructor(new Type[] { typeof(Bravo) });

If the constructor is not found you will get an error InvalidBindingException:
The constructor with 'MugenInjectionDocumentation.Bravo' type(s) not found in service MugenInjectionDocumentation.Alfa.

Using a binding priority

When you register service you can specify the binding priority:

injector.Bind<Alfa>().ToSelf().SetStandardPriority();
injector.Bind<Alfa>().To<Beta>().SetLowPriority();
injector.Bind<Alfa>().To<Bravo>().SetNormalPriority();

var bravo = injector.Get<Alfa>();//Instance of Bravo.

Other settings

When you register service you can specify behavior after dispose binding, you can try dispose the object after binding disposed.

injector.Bind<Alfa>().ToSelf().TryDisposeObjects();

Updated Wiki: Registrating bindings

VVS0205 — Sun, 12 Aug 2012 11:38:44 GMT

Registrating bindings

Bindings are registered with IInjectorBinder.
Bindings can be created using lambda expressions, by reflection, by method delegate, or by providing a ready-made instance.
Bindings are created using the Bind method of IInjectorBinder:

public interface IInterface { }
public class Alfa { }
public class Beta : Alfa, IInterface { }
public class Bravo : Beta { }

var injector = new MugenInjector();
injector.Bind<IInterface>().To<Beta>();
injector.Bind<Alfa, Beta>().To<Bravo>();

All registered services are checked and if you are write this code:

injector.Bind(typeof (Bravo)).To(typeof (Alfa));

you are get an error InvalidBindingException:
The service MugenInjectionDocumentation.Bravo not assignable from MugenInjectionDocumentation.Alfa.

Using Reflection

As you can see bindings can creating using Reflection.
Also supported open generic types:

injector.Bind(typeof (IRepository<>)).To(typeof (Repository<>));
injector.Get<IRepository<Alfa>>();

container supported self bindable types, if you are write this code, it will be correct:

var injector = new MugenInjector();
injector.Get<Alfa>();

Using method delegate

MugenInjector can accept a delegate to be used as a service creator:

var injector = new MugenInjector();
injector.Bind<B>().ToMethod(context => new B(context.CallInjector.Get<A>()));

For generic binding the delegate is as follows:

public delegate T MethodBindingDelegate<out T>(IBindingContext bindingContext);

For non-generic binding the delegate is as follows:

public delegate object MethodBindingDelegate(IBindingContext bindingContext);

It takes IBindingContext and returns an instance of service, more about IBindingContext see this.

Using Constant

MugenInjector can accept a ready-made instance as a service creator:

injector.Bind<Alfa>().ToConstant(new Alfa());

Using Expressions (only expression supported platforms)

MugenInjector can accept a lambda expression to be used for creating binding:

var injector = new MugenInjector();
injector.Bind<B>().To(context => new B(context.Resolve<A>()) {C = new C()});

This code is equivalent to:

injector.Bind<B>().ToSelf().TakeConstructor<A>().WithPropertyValue<C>("C", new C());

The expression not used for create service, it's used only for create binding.

Almost all methods described above have different overload.

Updated Wiki: Registrating bindings

VVS0205 — Sun, 12 Aug 2012 11:07:03 GMT

Registrating bindings

public interface IInterface { }
public class Alfa { }
public class Beta : Alfa, IInterface { }
public class Bravo : Beta { }

var injector = new MugenInjector();
injector.Bind<IInterface>().To<Beta>();
injector.Bind<Alfa, Beta>().To<Bravo>();

All registered services are checked and if you are write this code:

injector.Bind(typeof (Bravo)).To(typeof (Alfa));

you are get error InvalidBindingException:
The service MugenInjectionDocumentation.Bravo not assignable from MugenInjectionDocumentation.Alfa.

Using Reflection

As you can see bindings can creating using Reflection.
Also supported open generic types:

injector.Bind(typeof (IRepository<>)).To(typeof (Repository<>));
injector.Get<IRepository<Alfa>>();

container supported self bindable types, if you are write this code, it will be correct:

var injector = new MugenInjector();
injector.Get<Alfa>();

Using method delegate

MugenInjector can accept a delegate to be used as a service creator:

var injector = new MugenInjector();
injector.Bind<B>().ToMethod(context => new B(context.CallInjector.Get<A>()));

For generic binding the delegate is as follows:

public delegate T MethodBindingDelegate<out T>(IBindingContext bindingContext);

For non-generic binding the delegate is as follows:

public delegate object MethodBindingDelegate(IBindingContext bindingContext);

It takes IBindingContext and returns an instance of service, more about IBindingContext see this.

Using Constant

MugenInjector can accept a ready-made instance as a service creator:

injector.Bind<Alfa>().ToConstant(new Alfa());

Using Expressions (only expression supported platforms)

MugenInjector can accept a lambda expression to be used for creating binding:

var injector = new MugenInjector();
injector.Bind<B>().To(context => new B(context.Resolve<A>()) {C = new C()});

This code is equivalent to:

injector.Bind<B>().ToSelf().TakeConstructor<A>().WithPropertyValue<C>("C", new C());

The expression not used for create service, it's used only for create binding.

Almost all methods described above have different overload.

Updated Wiki: Registrating bindings

VVS0205 — Sun, 12 Aug 2012 11:05:03 GMT

public interface IInterface { }
public class Alfa { }
public class Beta : Alfa, IInterface { }
public class Bravo : Beta { }

var injector = new MugenInjector();
injector.Bind<IInterface>().To<Beta>();
injector.Bind<Alfa, Beta>().To<Bravo>();

All registered services are checked and if you are write this code:

injector.Bind(typeof (Bravo)).To(typeof (Alfa));

you are get error InvalidBindingException:
The service MugenInjectionDocumentation.Bravo not assignable from MugenInjectionDocumentation.Alfa.

Using Reflection

As you can see bindings can creating using Reflection.
Also supported open generic types:

injector.Bind(typeof (IRepository<>)).To(typeof (Repository<>));
injector.Get<IRepository<Alfa>>();

container supported self bindable types, if you are write this code, it will be correct:

var injector = new MugenInjector();
injector.Get<Alfa>();

Using method delegate

MugenInjector can accept a delegate to be used as a service creator:

var injector = new MugenInjector();
injector.Bind<B>().ToMethod(context => new B(context.CallInjector.Get<A>()));

For generic binding the delegate is as follows:

public delegate T MethodBindingDelegate<out T>(IBindingContext bindingContext);

For non-generic binding the delegate is as follows:

public delegate object MethodBindingDelegate(IBindingContext bindingContext);

It takes IBindingContext and returns an instance of service, more about IBindingContext see this.

Using Constant

MugenInjector can accept a ready-made instance as a service creator:

injector.Bind<Alfa>().ToConstant(new Alfa());

Using Expressions (only expression supported platforms)

MugenInjector can accept a lambda expression to be used for creating binding:

var injector = new MugenInjector();
injector.Bind<B>().To(context => new B(context.Resolve<A>()) {C = new C()});

This code is equivalent to:

injector.Bind<B>().ToSelf().TakeConstructor<A>().WithPropertyValue<C>("C", new C());

The expression not used for create service, it's used only for create binding.

Almost all methods described above have different overload.

Updated Wiki: Registrating bindings

VVS0205 — Sun, 12 Aug 2012 07:55:05 GMT

Bindings are registered with IInjectorBinder.
Bindings can be created using lambda expressions, by reflection, or by providing a ready-made instance.

Updated Wiki: Mugen Injection

VVS0205 — Sun, 12 Aug 2012 05:32:01 GMT

Updated Wiki: Home

VVS0205 — Thu, 09 Aug 2012 16:23:50 GMT

Supported platforms:

NET 2.0 - 4.5.
WinRT
Silverlight 3-5
Windows phone 7-7.1
Supported MVC 2 - 4
Supported WCF
Supported NServiceBus.ObjectBuilder
Supports private protected internal injection in Silverlight(4-5).
Supports interceptors.
Easy integration with libraries for logging(Log4Net, NLog2).

Available in nuget

PM> Install-Package MugenInjection

Updated Wiki: Home

VVS0205 — Tue, 17 Jul 2012 14:34:46 GMT

Supported platforms:

NET 2.0 - 4.5.
WinRT
Silverlight 3-5
Windows phone 7-7.1
Supported MVC 2 - 4
Supported WCF
Supported NServiceBus.ObjectBuilder
Supports private protected internal injection in Silverlight(4-5).
Supports interceptors.
Easy integration with libraries for logging(Log4Net, NLog2).

Available in nuget

PM> Install-Package MugenInjection

Updated Wiki: Home

VVS0205 — Fri, 29 Jun 2012 04:00:35 GMT

Supported platforms:

NET 2.0 - 4.5.
WinRT
Silverlight 3-5
Windows phone 7-7.1
Supported MVC 2 - 4
Supported WCF
Supported NServiceBus.ObjectBuilder

Available in nuget

PM> Install-Package MugenInjection

Updated Wiki: Home

VVS0205 — Wed, 09 May 2012 15:15:38 GMT

Supported platforms:

NET 2.0 - 4.5.
WinRT
Silverlight 3-5
Windows phone 7-7.1
Supported MVC 2 - 4
Supported WCF
Supported NServiceBus.ObjectBuilder

Available in nuget

PM> Install-Package MugenInjection

Updated Wiki: WCF

VVS0205 — Mon, 07 May 2012 14:35:25 GMT

To use the container in WCF you need to add code to your Global.asax.cs file:

    public class Global : MugenInjectionHttpApplication
    {
        #region Overrides of MugenInjectionHttpApplication

        /// <summary>
        /// Creates the injector that will manage your application.
        /// </summary>
        /// <returns>
        /// The created injector.
        /// </returns>
        protected override IInjector CreateInjector()
        {
            var injector = new MugenInjector();
            injector.Bind<ISimpleInjectedService>()
                .To<SingletonInjectedService>()
                .WhenInto<SingletonService>();

            injector.Bind<ISimpleInjectedService>()
                .To<SimpleInjectedService>()
                .WhenInto<SimpleService>()
                .InOperationRequestScope();

            return injector;
        }

        /// <summary>
        /// Configure current <see cref="T:MugenInjection.Web.MugenInjectionHttpApplication"/>
        /// </summary>
        /// <param name="applicationConfiguration">Configuration instance.</param>
        protected override void Configure(IApplicationConfiguration applicationConfiguration)
        {
            //This is important.
            applicationConfiguration
                .WithWcfConfiguration();

            //You can add your IServiceBehavior and IDispatchMessageInspector
            applicationConfiguration.WithDispatchMessageInspector(new CustomDispatchMessageInspector());
            applicationConfiguration.WithServiceBehavior(new CustomServiceBehavior());

            //You can create custom behavior for release service instance, default used dispose behavior.

            /*applicationConfiguration.WithReleaseInstanceBehavior(new CustomeReleaseInstanceBehavior());*/
        }

        #endregion
    }

If you’re hosting in IIS, you’ll need to reference this ServiceHostFactory in your .svc file:

<%@ ServiceHost Language="C#" Debug="true" 
    Service="TestMugenInjectorWcf.Service1" 
    CodeBehind="Service1.svc.cs"  
    Factory="MugenInjection.Wcf.MugenInjectionServiceHostFactory" %>

or, if you’re using .Net 4.0 and taking advantage of the new file-less activation, reference the ServiceHostFactory in your web.config like so:

<!-- Using configuration based activation so we don't need to have .svc files -->
<serviceActivations>
<add factory="MugenInjection.Wcf.MugenInjectionServiceHostFactory"
     service="TestMugenInjectorWcf.Service1"
     relativeAddress="Service1.svc" />
</serviceActivations>

In the WCF application is available one additional LifecycleScope, OperationRequestScope. More about LifecycleScope here.

You can add your IServiceBehavior and IDispatchMessageInspector, for this you must add:

  applicationConfiguration.WithDispatchMessageInspector(new CustomDispatchMessageInspector());
  applicationConfiguration.WithServiceBehavior(new CustomServiceBehavior());

Also you can create custom behavior for release service instance, default used dispose behavior:

applicationConfiguration.WithReleaseInstanceBehavior(new CustomReleaseInstanceBehavior());

Updated Wiki: MVC

VVS0205 — Mon, 07 May 2012 14:20:19 GMT

To use the container in MVC you need to add code to your Global.asax.cs file:

public class MvcApplication : MugenInjectionHttpApplication
    {
        public static void RegisterGlobalFilters(GlobalFilterCollection filters)
        {
            filters.Add(new HandleErrorAttribute());
        }

        public static void RegisterRoutes(RouteCollection routes)
        {
            routes.IgnoreRoute("{resource}.axd/{*pathInfo}");

            routes.MapRoute(
                "Default", // Route name
                "{controller}/{action}/{id}", // URL with parameters
                new {controller = "Home", action = "Index", id = UrlParameter.Optional} // Parameter defaults
                );
        }

        #region Overrides of MugenInjectionHttpApplication

        /// <summary>
        /// Called when the application is started.
        /// </summary>
        protected override void OnApplicationStarted()
        {
            AreaRegistration.RegisterAllAreas();
            RegisterGlobalFilters(GlobalFilters.Filters);
            RegisterRoutes(RouteTable.Routes);
        }

        /// <summary>
        /// Creates the injector that will manage your application.
        /// </summary>
        /// <returns>
        /// The created injector.
        /// </returns>
        protected override IInjector CreateInjector()
        {
            var injector = new MugenInjector();
            injector.Bind<IRequestScopeService>()
                .To<RequestScopeService>()
                .InHttpRequestScope();

            injector.Bind<ISessionScopeService>()
                .To<SessionScopeService>()
                .InSessionScope();

            return injector;
        }

        /// <summary>
        /// Configure current <see cref="T:MugenInjection.Web.MugenInjectionHttpApplication"/>
        /// </summary>
        /// <param name="applicationConfiguration">Configuration instance.</param>
        protected override void Configure(IApplicationConfiguration applicationConfiguration)
        {
            //This is important.
            applicationConfiguration
                .WithHttpConfiguration()
                .WithMvcConfiguration();
        }

        #endregion
    }

In the http application is available two additional LifecycleScope, HttpRequestScope and SessionScope. More about LifecycleScope here.

You can also use RoleProvider and MembershipProvider, with custom injections, for this you must add in web.config:

<membership defaultProvider="MugenInjectionMembershipProvider">
      <providers>
        <clear/>
        <add name="MugenInjectionMembershipProvider" type="MugenInjection.Web.Mvc.Providers.MugenInjectionMembershipProvider"  />
      </providers>
</membership>

<roleManager enabled="true" defaultProvider="MugenInjectionRoleProvider">
      <providers>
        <clear/>
        <add name="MugenInjectionRoleProvider" type="MugenInjection.Web.Mvc.Providers.MugenInjectionRoleProvider" />       
      </providers>
 </roleManager>

Then in your code, you must implement to RoleProvider and MembershipProvider:

/// <summary>
/// Creates the injector that will manage your application.
/// </summary>
/// <returns>
/// The created injector.
/// </returns>
protected override IInjector CreateInjector()
{
     var injector = new MugenInjector();
     injector.Bind<IService>().To<CustomService>();

     //Register providers
     injector.WithCustomMembershipProvider<MemberProvider>();
     injector.WithCustomRoleProvider<CustomRoleProvider>();

      return injector;
}

Updated Wiki: Lifecycle scope

VVS0205 — Mon, 07 May 2012 14:19:02 GMT

At this point, the container supports four lifecycle scope, but you can add your own implementation.

SingletonScopeLifecycle - indicates that only a single instance of the binding should be created, and then should be re-used for all subsequent requests.

Example:

var injector = new MugenInjector();
injector.Bind<ITest>().To<Test>().InSingletonScope();

var test = injector.Get<ITest>();
var test1 = injector.Get<ITest>();
if (test == test1)
    Console.WriteLine("Is always true.");

IInjector child = injector.CreateChild();
var test2 = child.Get<ITest>();
if (test == test2)
    Console.WriteLine("And it is also true.");

ThreadScopeLifecycle - indicates that instances activated via the binding should be re-used within the same thread.

Example:

            var injector = new MugenInjector();
            injector.Bind<ITest>().To<Test>().InThreadScope();

            var test = injector.Get<ITest>();
            var test1 = injector.Get<ITest>();
            if (test == test1)
                Console.WriteLine("Is always true.");

            var thread = new Thread(() =>
                                        {
                                            test1 = injector.Get<ITest>();
                                            if (test != test1)
                                                Console.WriteLine("Is always true.");
                                        });
            thread.Start();

            IInjector child = injector.CreateChild();
            var test2 = child.Get<ITest>();
            if (test == test2)
                Console.WriteLine("And it is also true.");

            thread = new Thread(() =>
                                    {
                                        test1 = child.Get<ITest>();
                                        if (test != test1)
                                            Console.WriteLine("And it is also true.");
                                    });
            thread.Start();

TransientScopeLifecycle - indicates that instances activated via the binding should not be re-used, nor have their lifecycle managed.

Example:

            var injector = new MugenInjector();
            injector.Bind<ITest>().To<Test>().InTransientScope();

            var test = injector.Get<ITest>();
            var test1 = injector.Get<ITest>();
            if (test != test1)
                Console.WriteLine("Is always true.");

            IInjector child = injector.CreateChild();
            var test2 = child.Get<ITest>();
            if (test != test2)
                Console.WriteLine("And it is also true.");
            if (test1 != test2)
                Console.WriteLine("And it is also true.");

UnitOfWorkScopeLifecycle - indicates that only a single instance of the binding should be created in each IInjector, and then should be re-used for all subsequent requests.

            var injector = new MugenInjector();
            injector.Bind<ITest>().To<Test>().InUnitOfWorkScope();

            var test = injector.Get<ITest>();
            var test1 = injector.Get<ITest>();
            if (test == test1)
                Console.WriteLine("Is always true.");

            IInjector child = injector.CreateChild();
            var test2 = child.Get<ITest>();
            var test3 = child.Get<ITest>();
            if (test != test2)
                Console.WriteLine("And it is also true.");
            if (test2 == test3)
                Console.WriteLine("And it is also true.");

An example of the creation and use of ScopeLifecycle. We will create WeakReferenceScopeLifecycle.

    public class WeakReferenceScopeLifecycle : ScopeLifecycleBase
    {
        #region Fields

        private WeakReference _weakReference;

        #endregion
        
        #region Overrides of ScopeLifecycleBase

        /// <summary>
        /// Get object from current scope.
        /// </summary>
        /// <returns/>
        public override object GetObjectFromScope()
        {
            if (_weakReference == null || !_weakReference.IsAlive)
            {
                object service = this.ResolveCurrentService();
                _weakReference = new WeakReference(service);
                return service;
            }
            return _weakReference.Target;
        }

        #endregion
    }

//Somewhere in code
var injector = new MugenInjector();
injector.Bind<Test>().ToSelf().InScope(new WeakReferenceScopeLifecycle());

Scopes only for HTTP application:

HttpRequestScope - indicates that instances activated via the binding should be re-used within the same HTTP request, for scope used HttpContext.

SessionScope - indicates that instances activated via the binding should be re-used within the same HTTP session, for scope used HttpSessionState.

OperationRequestScope - indicates that instances activated via the binding should be re-used within the same OperationContext request, for scope used OperationContext, used for WCF.

Updated Wiki: MVC

VVS0205 — Mon, 07 May 2012 14:12:17 GMT

To use the container in MVC you need to add code to your Global.asax.cs file:

public class MvcApplication : MugenInjectionHttpApplication
    {
        public static void RegisterGlobalFilters(GlobalFilterCollection filters)
        {
            filters.Add(new HandleErrorAttribute());
        }

        public static void RegisterRoutes(RouteCollection routes)
        {
            routes.IgnoreRoute("{resource}.axd/{*pathInfo}");

            routes.MapRoute(
                "Default", // Route name
                "{controller}/{action}/{id}", // URL with parameters
                new {controller = "Home", action = "Index", id = UrlParameter.Optional} // Parameter defaults
                );
        }

        #region Overrides of MugenInjectionHttpApplication

        /// <summary>
        /// Called when the application is started.
        /// </summary>
        protected override void OnApplicationStarted()
        {
            AreaRegistration.RegisterAllAreas();
            RegisterGlobalFilters(GlobalFilters.Filters);
            RegisterRoutes(RouteTable.Routes);
        }

        /// <summary>
        /// Creates the injector that will manage your application.
        /// </summary>
        /// <returns>
        /// The created injector.
        /// </returns>
        protected override IInjector CreateInjector()
        {
            var injector = new MugenInjector();
            injector.Bind<IRequestScopeService>()
                .To<RequestScopeService>()
                .InHttpRequestScope();

            injector.Bind<ISessionScopeService>()
                .To<SessionScopeService>()
                .InSessionScope();

            return injector;
        }

        /// <summary>
        /// Configure current <see cref="T:MugenInjection.Web.MugenInjectionHttpApplication"/>
        /// </summary>
        /// <param name="applicationConfiguration">Configuration instance.</param>
        protected override void Configure(IApplicationConfiguration applicationConfiguration)
        {
            //This is important.
            applicationConfiguration
                .WithHttpConfiguration()
                .WithMvcConfiguration();
        }

        #endregion
    }

In the http application is available two additional LifecycleScope, HttpRequestScope and SessionScope. More about LifecycleScope here.

You can also use RoleProvider and MembershipProvider, with custom injections, for this you must add in web.config:

<membership defaultProvider="MugenInjectionMembershipProvider">
      <providers>
        <clear/>
        <add name="MugenInjectionMembershipProvider" type="MugenInjection.Web.Mvc.Providers.MugenInjectionMembershipProvider"  />
      </providers>
</membership>

<roleManager enabled="true" defaultProvider="MugenInjectionRoleProvider">
      <providers>
        <clear/>
        <add name="MugenInjectionRoleProvider" type="MugenInjection.Web.Mvc.Providers.MugenInjectionRoleProvider" />       
      </providers>
 </roleManager>

Then in your code, you must implement to RoleProvider and MembershipProvider:

/// <summary>
/// Creates the injector that will manage your application.
/// </summary>
/// <returns>
/// The created injector.
/// </returns>
protected override IInjector CreateInjector()
{
     var injector = new MugenInjector();
     injector.Bind<IService>().To<CustomService>();

     //Register providers
     injector.WithCustomMembershipProvider<MemberProvider>();
     injector.WithCustomRoleProvider<CustomRoleProvider>();

      return injector;
}