//--- Constructors ---
 /// <summary>
 /// Create a new XDoc configurator.
 /// </summary>
 /// <param name="config">Configuration fragment.</param>
 /// <param name="defaultScope">Default registration scope.</param>
 public XDocAutofacContainerConfigurator(XDoc config, DreamContainerScope defaultScope)
 {
     if(config == null) {
         throw new ArgumentNullException("config");
     }
     _defaultScope = defaultScope;
     _config = config;
 }
 private void IsRegisteredInScopeWithName(Type type, DreamContainerScope scope, string name)
 {
     IComponentRegistration registration;
     Assert.IsTrue(_serviceContainer.ComponentRegistry.TryGetRegistration(new NamedService(name, type), out registration),
                   string.Format("no registration found for type '{0}' with name '{1}'", typeof(Foo), "fooz"));
     Assert.AreEqual(InstanceOwnership.OwnedByLifetimeScope, registration.Ownership);
     object instance;
     switch(scope) {
     case DreamContainerScope.Factory:
         Assert.AreEqual(InstanceSharing.None, registration.Sharing);
         break;
     case DreamContainerScope.Host:
         Assert.AreEqual(InstanceSharing.Shared, registration.Sharing);
         Assert.IsTrue(_hostContainer.TryResolve(name, type, out instance), "unable to resolve in host");
         Assert.IsTrue(_serviceContainer.TryResolve(name, type, out instance), "unable to resolve in service");
         Assert.IsTrue(_requestContainer.TryResolve(name, type, out instance), "unable to resolve in request");
         break;
     case DreamContainerScope.Service:
         Assert.AreEqual(InstanceSharing.Shared, registration.Sharing);
         try {
             Assert.IsFalse(_hostContainer.TryResolve(name, type, out instance), "able to resolve in host");
         } catch(DependencyResolutionException) {}
         Assert.IsTrue(_serviceContainer.TryResolve(name, type, out instance), "unable to resolve in service");
         Assert.IsTrue(_requestContainer.TryResolve(name, type, out instance), "unable to resolve in request");
         break;
     case DreamContainerScope.Request:
         Assert.AreEqual(InstanceSharing.Shared, registration.Sharing);
         try {
             Assert.IsFalse(_hostContainer.TryResolve(name, type, out instance), "able to resolve in host");
         } catch(DependencyResolutionException) {}
         try {
             Assert.IsFalse(_serviceContainer.TryResolve(name, type, out instance), "able to resolve in service");
         } catch(DependencyResolutionException) {}
         Assert.IsTrue(_requestContainer.TryResolve(name, type, out instance), "unable to resolve in request");
         break;
     }
 }
 private void IsRegisteredInScope(Type type, DreamContainerScope scope)
 {
     IComponentRegistration registration = GetRegistration(type);
     if(scope == DreamContainerScope.Factory) {
         var componentRegistration = registration as Registration;
         Assert.IsNotNull(componentRegistration);
         Assert.AreEqual(typeof(FactoryScope), componentRegistration.Scope.GetType());
     } else {
         var taggedRegistration = registration as TaggedRegistration<DreamContainerScope>;
         Assert.IsNotNull(taggedRegistration);
         Assert.AreEqual(scope, taggedRegistration.Tag);
     }
 }
Exemplo n.º 4
0
 /// <summary>
 /// Set the registered item's container resolution scope.
 /// </summary>
 /// <param name="registrar">Registrar instance.</param>
 /// <param name="scope">Container Resolution scope.</param>
 /// <returns>The modified registrar instance.</returns>
 public static IReflectiveRegistrar InScope(this IReflectiveRegistrar registrar, DreamContainerScope scope)
 {
     return scope == DreamContainerScope.Factory ? registrar.WithScope(InstanceScope.Factory) : registrar.InContext(scope);
 }