/// <summary>
/// Creates the controller.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="controllerType">Type of the controller.</param>
/// <returns>The controller.</returns>
protected override IController GetControllerInstance(RequestContext context, Type controllerType)
{
if (context == null)
throw new ArgumentNullException("context");
// a null controller type is a 404, because the base class couldn't resolve the controller name back to a type
// a common example of this case would be a non-existant favicon.ico
if (controllerType == null)
{
throw new HttpException(404,
string.Format("controller type was not found for path {0}",
context.HttpContext.Request.Path));
}
var controllerService = new TypedService(controllerType);
object controller;
if (_containerProvider.RequestLifetime.TryResolveService(controllerService, out controller))
return (IController)controller;
throw new HttpException(404,
string.Format(AutofacControllerFactoryResources.NotFound,
controllerService,
controllerType.FullName,
context.HttpContext.Request.Path));
}
/// <summary>
/// Since the last registration is considered the active one, when overriding previous registrations
/// use this function to verify if the previous plugins are already registered and will be overriden.
///
/// To force the specific registration order between modules (derivations of Autofac.Module)
/// use [ExportMetadata(MefProvider.DependsOn, typeof(the other Autofac.Module derivation))] attribute
/// on the module that registers the components that override registrations from the other module.
/// </summary>
public static void CheckOverride <TInterface, TImplementation>(ContainerBuilder builder, params Type[] expectedPreviousPlugins)
{
builder.RegisterCallback(componentRegistry =>
{
var existingService = new Autofac.Core.TypedService(typeof(TInterface));
var existingRegistrations = componentRegistry.RegistrationsFor(existingService).Select(r => r.Activator.LimitType).ToList();
var missingRegistration = expectedPreviousPlugins.Except(existingRegistrations).ToList();
var excessRegistration = existingRegistrations.Except(expectedPreviousPlugins).ToList();
if (missingRegistration.Count > 0 || excessRegistration.Count > 0)
{
string error = "Unexpected plugins while overriding '" + typeof(TInterface).Name + "' with '" + typeof(TImplementation).Name + "'.";
if (missingRegistration.Count > 0)
{
error += " The following plugins should have been previous registered in order to be overriden: "
+ string.Join(", ", missingRegistration.Select(r => r.Name)) + ".";
}
if (excessRegistration.Count > 0)
{
error += " The following plugins have been previous registered and whould be unintentionally overriden: "
+ string.Join(", ", excessRegistration.Select(r => r.Name)) + ".";
}
error += " Verify that the module registration is occurring in the right order: Use [ExportMetadata(MefProvider.DependsOn, typeof(other Autofac.Module implementation))], to make those registration will occur before this one.";
throw new FrameworkException(error);
}
});
}
public void ChangeType_ProvidesTypedServiceWithNewType()
{
var nt = typeof(string);
var ts = new TypedService(typeof(object));
var n = ts.ChangeType(nt);
Assert.Equal(new TypedService(nt), n);
}
public override bool Equals(object obj)
{
TypedService service = obj as TypedService;
if (service == null)
{
return(false);
}
return(this.ServiceType.IsCompatibleWith(service.ServiceType));
}
public void AfterResolvingAdapterType_AddingAnAdapter_AddsAdaptingComponents()
{
var registry = new ComponentRegistry();
registry.Register(RegistrationBuilder.ForType<object>().CreateRegistration());
var adapterService = new TypedService(typeof(Func<object>));
var pre = registry.RegistrationsFor(adapterService);
Assert.AreEqual(0, pre.Count());
registry.AddRegistrationSource(new GeneratedFactoryRegistrationSource());
var post = registry.RegistrationsFor(adapterService);
Assert.AreEqual(1, post.Count());
}
public void WhenRegistrationsAreMadeTheyDoNotAffectTheReadRegistry()
{
var read = new ComponentRegistry();
var cow = new CopyOnWriteRegistry(read, () => new ComponentRegistry());
var registration = RegistrationBuilder.ForType<object>().CreateRegistration();
cow.Register(registration);
var objectService = new TypedService(typeof (object));
Assert.True(cow.IsRegistered(objectService));
Assert.False(read.IsRegistered(objectService));
}
public void ConnectionRegistrationsAreExternallyOwned()
{
var builder = new ContainerBuilder();
builder.RegisterPersistentConnections(Assembly.GetExecutingAssembly());
var container = builder.Build();
var service = new TypedService(typeof(TestConnection));
IComponentRegistration registration;
container.ComponentRegistry.TryGetRegistration(service, out registration);
Assert.Equal(InstanceOwnership.ExternallyOwned, registration.Ownership);
}
public void HubRegistrationsAreExternallyOwned()
{
var builder = new ContainerBuilder();
builder.RegisterHubs(Assembly.GetExecutingAssembly());
var container = builder.Build();
var service = new TypedService(typeof(TestHub));
IComponentRegistration registration;
container.ComponentRegistry.TryGetRegistration(service, out registration);
Assert.That(registration.Ownership, Is.EqualTo(InstanceOwnership.ExternallyOwned));
}
private static void ScanAssembly(IComponentRegistry componentRegistry, Assembly assembly)
{
var types = assembly.GetTypes()
.Where(type => (type.IsClass && !type.IsAbstract) && (!type.IsGenericTypeDefinition && !type.IsSubclassOf(typeof(Delegate))))
.ToArray();
foreach (var type in types)
{
var implementedInterfaces = GetImplementedInterfaces(type);
if (!implementedInterfaces.Any())
continue;
if (!HasMarkerAttribute(type))
{
var interfaceName = "I" + type.Name;
if (implementedInterfaces.All(interfaceType => interfaceType.Name != interfaceName))
continue;
}
var typedService = new TypedService(type);
var data = new RegistrationData(typedService);
data.AddServices(
implementedInterfaces.Select(
t =>
{
if (t.FullName == null)
{
return new TypedService(t.GetGenericTypeDefinition());
}
return new TypedService(t);
}).ToArray());
if (IsSingleInstancing(typedService.ServiceType))
{
data.Sharing = InstanceSharing.Shared;
data.Lifetime = new RootScopeLifetime();
}
else if (IsInstancingPerLifetimeScope(typedService.ServiceType))
{
data.Sharing = InstanceSharing.Shared;
data.Lifetime = new MatchingScopeLifetime(LifetimeScopeTags.RequestScope);
}
var registration = RegistrationBuilder.CreateRegistration(
Guid.NewGuid(), data, new ConcreteReflectionActivatorData(typedService.ServiceType).Activator, data.Services);
componentRegistry.Register(registration);
}
}
public void AddingConcreteImplementationWhenAdapterImplementationsExist_AddsChainedAdapters()
{
var registry = new ComponentRegistry();
registry.AddRegistrationSource(new GeneratedFactoryRegistrationSource());
registry.AddRegistrationSource(new MetaRegistrationSource());
registry.Register(RegistrationBuilder.ForType<object>().CreateRegistration());
var chainedService = new TypedService(typeof(Meta<Func<object>>));
var pre = registry.RegistrationsFor(chainedService);
Assert.AreEqual(1, pre.Count());
Func<object> func = () => new object();
registry.Register(RegistrationBuilder.ForDelegate((c, p) => func).CreateRegistration());
var post = registry.RegistrationsFor(chainedService);
Assert.AreEqual(2, post.Count());
}
/// <summary>
/// Since the last registration is considered the active one, when overriding previous registrations
/// use this function to verify if the previous plugins are already registered and will be overridden.
///
/// To force the specific registration order between modules (derivations of Autofac.Module)
/// use [ExportMetadata(MefProvider.DependsOn, typeof(the other Autofac.Module derivation))] attribute
/// on the module that registers the components that override registrations from the other module.
/// </summary>
public void CheckOverride <TInterface, TImplementation>(params Type[] expectedPreviousPlugins)
{
_builder.RegisterCallback(componentRegistry =>
{
var existingService = new Autofac.Core.TypedService(typeof(TInterface));
var existingRegistrations = componentRegistry.RegistrationsFor(existingService).Select(r => r.Activator.LimitType).ToList();
var missingRegistration = expectedPreviousPlugins.Except(existingRegistrations).ToList();
var excessRegistration = existingRegistrations.Except(expectedPreviousPlugins).ToList();
// Backward compatibility for old plugins: Old command-line utilities and unit tests might expect
// to override WcfWindowsUserInfo, but it is no longer used in that context.
var ignoredMissing = missingRegistration.RemoveAll(registation => registation.FullName == "Rhetos.Security.WcfWindowsUserInfo");
if (ignoredMissing > 0)
{
_logger.Trace($"Expecting WcfWindowsUserInfo registered while overriding '{typeof(TInterface).Name}'" +
$" with '{typeof(TImplementation).FullName}'. Error is ignored for backward compatibility," +
$" WcfWindowsUserInfo is no longer used in context of command-line utilities or unit tests.");
}
if (missingRegistration.Count > 0 || excessRegistration.Count > 0)
{
string error = "Unexpected plugins while overriding '" + typeof(TInterface).Name + "' with '" + typeof(TImplementation).Name + "'.";
if (missingRegistration.Count > 0)
{
error += " The following plugins should have been previous registered in order to be overridden: "
+ string.Join(", ", missingRegistration.Select(r => r.Name)) + ".";
}
if (excessRegistration.Count > 0)
{
error += " The following plugins have been previous registered and would be unintentionally overridden: "
+ string.Join(", ", excessRegistration.Select(r => r.Name)) + ".";
}
error += " Verify that the module registration is occurring in the right order: Use [ExportMetadata(MefProvider.DependsOn, typeof(other Autofac.Module implementation))], to make those registration will occur before this one.";
throw new FrameworkException(error);
}
});
}
public void RespectsExplicitInterchangeServices()
{
var builder = new ContainerBuilder();
var catalog = new TypeCatalog(typeof(HasMultipleExports));
var interchangeService1 = new TypedService(typeof(HasMultipleExportsBase));
var interchangeService2 = new KeyedService("b", typeof(HasMultipleExports));
var nonInterchangeService1 = new TypedService(typeof(HasMultipleExports));
var nonInterchangeService2 = new KeyedService("a", typeof(HasMultipleExports));
builder.RegisterComposablePartCatalog(catalog,
interchangeService1,
interchangeService2);
var container = builder.Build();
Assert.IsTrue(container.IsRegisteredService(interchangeService1));
Assert.IsTrue(container.IsRegisteredService(interchangeService2));
Assert.IsFalse(container.IsRegisteredService(nonInterchangeService1));
Assert.IsFalse(container.IsRegisteredService(nonInterchangeService2));
}
public void AfterResolvingAdapter_AddingMoreAdaptees_AddsMoreAdapters()
{
var registry = new ComponentRegistry();
registry.AddRegistrationSource(new MetaRegistrationSource());
var metaService = new TypedService(typeof(Meta<object>));
var first = RegistrationBuilder.ForType<object>().CreateRegistration();
registry.Register(first);
var meta1 = registry.RegistrationsFor(metaService);
var firstMeta = meta1.First();
var second = RegistrationBuilder.ForType<object>().CreateRegistration();
registry.Register(second);
var meta2 = registry.RegistrationsFor(metaService);
Assert.That(meta2.Count(), Is.EqualTo(2));
Assert.That(meta2.Contains(firstMeta));
Assert.That(meta2.Select(m => m.Target), Is.EquivalentTo(new[] { first, second }));
}
public void SetUp()
{
_modelMapper = new ModelMapper();
TypeModel unused;
_modelMapper.GetOrAddTypeModel(typeof(string), out unused);
_service = new TypedService(typeof(string));
_mapped = _modelMapper.GetServiceModel(_service);
}
public IEnumerable<IComponentRegistration> RegistrationsFor(Service service, Func<Service, IEnumerable<IComponentRegistration>> registrationAccessor)
{
var objectService = new TypedService(typeof(object));
if (service == objectService)
yield return Factory.CreateSingletonObjectRegistration(_instance);
}
private object CreateMock(IComponentContext context, TypedService typedService)
{
var specificCreateMethod =
_createMethod.MakeGenericMethod(new[] { typedService.ServiceType });
var mock = (Mock)specificCreateMethod.Invoke(context.Resolve<MockRepository>(), null);
return mock.Object;
}
public void NestedLifetimeScopesMaintainServiceLimitTypes()
{
// Issue #365
var cb = new ContainerBuilder();
cb.RegisterType<Person>();
var container = cb.Build();
var service = new TypedService(typeof(Person));
using (var unconfigured = container.BeginLifetimeScope())
{
IComponentRegistration reg = null;
Assert.True(unconfigured.ComponentRegistry.TryGetRegistration(service, out reg), "The registration should have been found in the unconfigured scope.");
Assert.Equal(typeof(Person), reg.Activator.LimitType);
}
using (var configured = container.BeginLifetimeScope(b => { }))
{
IComponentRegistration reg = null;
Assert.True(configured.ComponentRegistry.TryGetRegistration(service, out reg), "The registration should have been found in the configured scope.");
Assert.Equal(typeof(Person), reg.Activator.LimitType);
}
}
public object Resolve(Type type, object[] args)
{
BuildScopeIfRequired();
if (args == null)
{
Func<object> factory;
if (!SimpleCache.TryGetValue(type, out factory))
{
var serv = new TypedService(type);
IComponentRegistration reg;
var inContainer = CurrentScope.ComponentRegistry.TryGetRegistration(serv, out reg);
RegistrationCache.TryAdd(type, inContainer);
if (inContainer)
factory = CurrentScope.ResolveLookup(serv, reg, new Parameter[0]).Factory;
else
factory = () => BuildWithAspects(type)(null);
SimpleCache.TryAdd(type, factory);
}
return factory();
}
else
{
Func<object[], object> factory;
if (!CacheWithArguments.TryGetValue(type, out factory))
{
var serv = new TypedService(type);
IComponentRegistration reg;
var inContainer = CurrentScope.ComponentRegistry.TryGetRegistration(serv, out reg);
RegistrationCache.TryAdd(type, inContainer);
if (inContainer)
factory = a => CurrentScope.ResolveLookup(serv, reg, a.Select(it => new TypedParameter(it.GetType(), it))).Factory();
else
factory = BuildWithAspects(type);
CacheWithArguments.TryAdd(type, factory);
}
return factory(args);
}
}
protected virtual void OnContainerConfigured(IComponentRegistry registry)
{
var service = new TypedService(typeof(ITransportMessages));
registry.RegistrationsFor(service).First().Activated += (s, e) =>
{
var subscriber = e.Context.Resolve<ISubscribeToMessages>();
foreach (var request in this.requests)
subscriber.Subscribe(request.Key, DateTime.MaxValue, request.Value.ToArray());
};
}
public void WhenAdaptersAreAppliedButNoRegistrationsCreated_AddingAdapteesAddsAdapters()
{
var registry = new ComponentRegistry();
registry.AddRegistrationSource(new GeneratedFactoryRegistrationSource());
var adapterService = new TypedService(typeof(Func<object>));
registry.RegistrationsFor(adapterService);
registry.Register(RegistrationBuilder.ForType<object>().CreateRegistration());
var adapters = registry.RegistrationsFor(adapterService);
Assert.AreEqual(1, adapters.Count());
}
