• There is no global 'scope' context
• Registrations will only be resolved from the ILifetimeScope returned by BeginLifetimeScope.

using (ILifetimeScope parentScope = CreateContainer())
{
    using (ILifetimeScope childScope1 = parentScope.BeginLifetimeScope(b => 
               b.RegisterType<MyType>().SingleInstance()))
    using (ILifetimeScope childScope2 = parentScope.BeginLifetimeScope(b => 
               b.RegisterType<MyType>().SingleInstance()))
    {
        MyType result1 = childScope1.Resolve<MyType>();
        MyType result2 = childScope2.Resolve<MyType>();
 
        result1.ShouldNotReferTo(result2);
    }
}

[Test]
public void InstancePerDependency_NewInstanceCreatedEveryTime()
{
    using (ILifetimeScope scope = CreateContainer(builder => 
           builder.RegisterType<MyType>()))
    {
        MyType instance1 = scope.Resolve<MyType>();
        MyType instance2 = scope.Resolve<MyType>();
 
        instance1.ShouldNotReferTo(instance2);
    }
}

[Test]
public void SingleInstance_IsScopedToWhereRegistrationOccurs()
{
    using (ILifetimeScope outerScope = CreateContainer(b => b.RegisterType<MyType>()))
    {
        using (ILifetimeScope middleScope = outerScope.BeginLifetimeScope(b => 
                   b.RegisterType<MyType>().SingleInstance()))
        {
            using (ILifetimeScope innerScope = middleScope.BeginLifetimeScope())
            {
                MyType outerResult = outerScope.Resolve<MyType>();
                MyType innerResult = innerScope.Resolve<MyType>();
                MyType middleResult = middleScope.Resolve<MyType>();
 
                outerResult.ShouldNotReferTo(middleResult);
                innerResult.ShouldReferTo(middleResult);
            }
        }
    }
}

[Test]
public void InstancePerLifetimeScope_OneInstancePerScope()
{
    using (ILifetimeScope outerScope = CreateContainer(b => 
              b.RegisterType<MyType>().InstancePerLifetimeScope()))
    {
        using (ILifetimeScope innerScope = outerScope.BeginLifetimeScope())
        {
            MyType outerInstance1 = outerScope.Resolve<MyType>();
            MyType outerInstance2 = outerScope.Resolve<MyType>();
            MyType innerInstance = innerScope.Resolve<MyType>();
 
            outerInstance1.ShouldReferTo(outerInstance2);
            innerInstance.ShouldNotReferTo(outerInstance1);
        }
    }
}

• Almost never - only if state needs to be shared between consumers. 
• Don't worry about performance - there's no logic in your constructors, right?

• How do you find out where something is registered?
• Press Shift-Alt-F12, then type module
  
  
• Agent Mulder plugin for R#

• Explicit registrations are best
• .As<Interface>() not .AsImplementedInterfaces()
• RegisterAssemblyTypes only for interfaces with many implementations
• ICommand
• Controller
• Last registration for an interface wins
• Great for explicit registrations
• Not so great for automatic registrations

• Don't register types in scopes that shouldn't need them
• IResourceRepository
• Separate modules by 'module' of code
• Resource modules