public void DynamicProxyCallNullShouldNull()
{
var context = new DynamicProxyContext();
var proxy = generator.CreateInterfaceProxy <IHelloRpc>(context);
var str = proxy.HelloString(3, "Vic");
Assert.Null(str);
}
protected override void AttachToComponentRegistration(IComponentRegistry componentRegistry, IComponentRegistration registration)
{
Type implementationType = registration.Activator.LimitType;
if (DynamicProxyContext.From(registration) != null && implementationType.FullName == "Orchard.Car.Services.CarInfoService")
{
registration.InterceptedBy <SimpleInterceptor>();
}
}
protected override void AttachToComponentRegistration(
IComponentRegistry componentRegistry,
IComponentRegistration registration)
{
if (DynamicProxyContext.From(registration) != null)
{
registration.InterceptedBy <SimpleInterceptor>();
}
}
public void DynamicProxyCallHelloVoidShouldNoError()
{
var context = new DynamicProxyContext()
{
Invoke = (c, s, ps) => null
};
var proxy = generator.CreateInterfaceProxy <IHelloRpc>(context);
proxy.HelloVoid(3, "Vic");
}
public static IContainer CreateHostContainer(Action <ContainerBuilder> registrations)
{
var builder = new ContainerBuilder();
var dynamicProxyContext = new DynamicProxyContext();
builder.RegisterModule(new CollectionOrderModule());
builder.RegisterModule(new LoggingModule());
builder.RegisterModule(new DataModule());
builder.RegisterApiControllers(AppDomain.CurrentDomain.GetAssemblies());
builder.RegisterWebApiFilterProvider(GlobalConfiguration.Configuration);
builder.Register(ctx => dynamicProxyContext);
var assemblies = AppDomain.CurrentDomain.GetAssemblies()
.Where(c => c.FullName.StartsWith(GetRootNamespaces(typeof(VICloudStarter))));
builder.RegisterAssemblyModules(assemblies.ToArray());
var dependencyTypes = assemblies.SelectMany(c => c.ExportedTypes)
.Where(t => typeof(IDependency).IsAssignableFrom(t));
foreach (var item in dependencyTypes.Where(c => !c.IsAbstract && !c.IsInterface))
{
var registration = builder.RegisterType(item)
.EnableDynamicProxy(dynamicProxyContext)
.InstancePerLifetimeScope();
foreach (var interfaceType in item.GetInterfaces()
.Where(itf => typeof(IDependency).IsAssignableFrom(itf)))
{
registration = registration.As(interfaceType).AsSelf();
if (typeof(ISingletonDependency).IsAssignableFrom(interfaceType))
{
registration = registration.SingleInstance();
}
else if (typeof(ITransientDependency).IsAssignableFrom(interfaceType))
{
registration = registration.InstancePerDependency();
}
}
}
registrations(builder);
var container = builder.Build();
GlobalConfiguration.Configuration.Filters.Add(new VICloudApiActionFilterDispatcher());
GlobalConfiguration.Configuration.MessageHandlers.Add(new EncryptDecodeMessageHandler(container));
GlobalConfiguration.Configuration.Filters.Add(new VICloudApiAuthorizationFilterDispatcher(container));
GlobalConfiguration.Configuration.Filters.Add(new VICloudApiExceptionFilterDispatcher());
GlobalConfiguration.Configuration.DependencyResolver = new AutofacWebApiDependencyResolver(container);
return(container);
}
public async void DynamicProxyCallHelloValueTaskShouldNoError()
{
var context = new DynamicProxyContext()
{
Invoke = (c, s, ps) => Task.FromResult($"{s}({ps[0]},{ps[1]},{ps[2]})")
};
var proxy = generator.CreateInterfaceProxy <IHelloRpc>(context);
var str = await proxy.HelloValueTask(3, "Vic", context);
Assert.Equal("HelloValueTask(3,Vic,Tars.Csharp.Rpc.DynamicProxy.DynamicProxyContext)", str);
}
public void DynamicProxyCallHelloStringShouldNoError()
{
var context = new DynamicProxyContext()
{
Invoke = (c, s, ps) => $"{s}({ps[0]},{ps[1]})"
};
var proxy = generator.CreateInterfaceProxy <IHelloRpc>(context);
var str = proxy.HelloString(3, "Vic");
Assert.Equal("HelloString(3,Vic)", str);
}
public void ContextAddedToMetadataWhenRegistered() {
var context = new DynamicProxyContext();
var builder = new ContainerBuilder();
builder.RegisterType<SimpleComponent>().EnableDynamicProxy(context);
var container = builder.Build();
var meta = container.Resolve<Meta<SimpleComponent>>();
Assert.That(meta.Metadata, Has.Some.Property("Key").EqualTo("Orchard.Environment.AutofacUtil.DynamicProxy2.DynamicProxyContext.ProxyContextKey"));
Assert.That(meta.Metadata["Orchard.Environment.AutofacUtil.DynamicProxy2.DynamicProxyContext.ProxyContextKey"], Is.SameAs(context));
}
public void ProxyContextReturnsTrueIfTypeHasBeenProxied() {
var context = new DynamicProxyContext();
Type proxyType;
Assert.That(context.TryGetProxy(typeof(SimpleComponent), out proxyType), Is.False);
Assert.That(context.TryGetProxy(typeof(SimpleComponent), out proxyType), Is.False);
Assert.That(proxyType, Is.Null);
context.AddProxy(typeof(SimpleComponent));
Assert.That(context.TryGetProxy(typeof(SimpleComponent), out proxyType), Is.True);
Assert.That(context.TryGetProxy(typeof(SimpleComponent), out proxyType), Is.True);
Assert.That(proxyType, Is.Not.Null);
}
public async void DynamicProxyCallNullTaskShouldNull()
{
try
{
var context = new DynamicProxyContext();
var proxy = generator.CreateInterfaceProxy <IHelloRpc>(context);
var str = await proxy.HelloTask(3, "Vic");
}
catch (NullReferenceException e)
{
Assert.NotNull(e);
}
}
public void ResolvedObjectIsSubclass() {
var context = new DynamicProxyContext();
var builder = new ContainerBuilder();
builder.RegisterType<SimpleComponent>().EnableDynamicProxy(context);
builder.RegisterModule(new SimpleInterceptorModule());
var container = builder.Build();
var simpleComponent = container.Resolve<SimpleComponent>();
Assert.That(simpleComponent, Is.InstanceOf<SimpleComponent>());
Assert.That(simpleComponent, Is.Not.TypeOf<SimpleComponent>());
}
public void InterceptorAddedToContextFromModules() {
var context = new DynamicProxyContext();
var builder = new ContainerBuilder();
builder.RegisterType<SimpleComponent>().EnableDynamicProxy(context);
builder.RegisterModule(new SimpleInterceptorModule());
builder.Build();
Type proxyType;
Assert.That(context.TryGetProxy(typeof(SimpleComponent), out proxyType), Is.True);
Assert.That(proxyType, Is.Not.Null);
}
public void AddProxyCanBeCalledMoreThanOnce() {
var context = new DynamicProxyContext();
context.AddProxy(typeof(SimpleComponent));
Type proxyType;
Assert.That(context.TryGetProxy(typeof(SimpleComponent), out proxyType), Is.True);
Assert.That(proxyType, Is.Not.Null);
Type proxyType2;
context.AddProxy(typeof(SimpleComponent));
Assert.That(context.TryGetProxy(typeof(SimpleComponent), out proxyType2), Is.True);
Assert.That(proxyType2, Is.SameAs(proxyType));
}
public void ProxyContextReturnsTrueIfTypeHasBeenProxied()
{
var context = new DynamicProxyContext();
Type proxyType;
Assert.That(context.TryGetProxy(typeof(SimpleComponent), out proxyType), Is.False);
Assert.That(context.TryGetProxy(typeof(SimpleComponent), out proxyType), Is.False);
Assert.That(proxyType, Is.Null);
context.AddProxy(typeof(SimpleComponent));
Assert.That(context.TryGetProxy(typeof(SimpleComponent), out proxyType), Is.True);
Assert.That(context.TryGetProxy(typeof(SimpleComponent), out proxyType), Is.True);
Assert.That(proxyType, Is.Not.Null);
}
public void ContextAddedToMetadataWhenRegistered()
{
var context = new DynamicProxyContext();
var builder = new ContainerBuilder();
builder.RegisterType <SimpleComponent>().EnableDynamicProxy(context);
var container = builder.Build();
var meta = container.Resolve <Meta <SimpleComponent> >();
Assert.That(meta.Metadata, Has.Some.Property("Key").EqualTo("Orchard.Environment.AutofacUtil.DynamicProxy2.DynamicProxyContext.ProxyContextKey"));
Assert.That(meta.Metadata["Orchard.Environment.AutofacUtil.DynamicProxy2.DynamicProxyContext.ProxyContextKey"], Is.SameAs(context));
}
public void ContextAddedToMetadataWhenRegistered()
{
var context = new DynamicProxyContext();
var builder = new ContainerBuilder();
builder.RegisterType <SimpleComponent>().EnableDynamicProxy(context);
var container = builder.Build();
var meta = container.Resolve <Meta <SimpleComponent> >();
Assert.Contains(meta.Metadata, t => t.Key.Equals("Framework.AutofacExtend.DynamicProxy2.DynamicProxyContext.ProxyContextKey"));
Assert.Same(meta.Metadata["Framework.AutofacExtend.DynamicProxy2.DynamicProxyContext.ProxyContextKey"], context);
}
public void DynamicProxyCallHelloOutShouldNoError()
{
var context = new DynamicProxyContext()
{
Invoke = (c, s, ps) =>
{
ps[1] = ps[0] + "66";
return(null);
}
};
var proxy = generator.CreateInterfaceProxy <IHelloRpc>(context);
proxy.HelloOut("vic", out string str);
Assert.Equal("vic66", str);
}
public void ResolvedObjectIsSubclass()
{
var context = new DynamicProxyContext();
var builder = new ContainerBuilder();
builder.RegisterType <SimpleComponent>().EnableDynamicProxy(context);
builder.RegisterModule(new SimpleInterceptorModule());
var container = builder.Build();
var simpleComponent = container.Resolve <SimpleComponent>();
Assert.That(simpleComponent, Is.InstanceOf <SimpleComponent>());
Assert.That(simpleComponent, Is.Not.TypeOf <SimpleComponent>());
}
public void InterceptorAddedToContextFromModules()
{
var context = new DynamicProxyContext();
var builder = new ContainerBuilder();
builder.RegisterType <SimpleComponent>().EnableDynamicProxy(context);
builder.RegisterModule(new SimpleInterceptorModule());
builder.Build();
Type proxyType;
Assert.That(context.TryGetProxy(typeof(SimpleComponent), out proxyType), Is.True);
Assert.That(proxyType, Is.Not.Null);
}
public void ResolvedObjectIsSubclass()
{
var context = new DynamicProxyContext();
var builder = new ContainerBuilder();
builder.RegisterType <SimpleComponent>().EnableDynamicProxy(context);
builder.RegisterModule(new SimpleInterceptorModule());
var container = builder.Build();
var simpleComponent = container.Resolve <SimpleComponent>();
Assert.True(simpleComponent is SimpleComponent);
Assert.False(simpleComponent.GetType() == typeof(SimpleComponent));
}
public void AddProxyCanBeCalledMoreThanOnce()
{
var context = new DynamicProxyContext();
context.AddProxy(typeof(SimpleComponent));
Type proxyType;
Assert.That(context.TryGetProxy(typeof(SimpleComponent), out proxyType), Is.True);
Assert.That(proxyType, Is.Not.Null);
Type proxyType2;
context.AddProxy(typeof(SimpleComponent));
Assert.That(context.TryGetProxy(typeof(SimpleComponent), out proxyType2), Is.True);
Assert.That(proxyType2, Is.SameAs(proxyType));
}
public void InterceptorCatchesMethodCallOnlyFromContainerWithInterceptor()
{
var context = new DynamicProxyContext();
var builder1 = new ContainerBuilder();
builder1.RegisterType<SimpleComponent>().EnableDynamicProxy(context);
builder1.RegisterModule(new SimpleInterceptorModule());
var container1 = builder1.Build();
var simple1 = container1.Resolve<SimpleComponent>();
var builder2 = new ContainerBuilder();
builder2.RegisterType<SimpleComponent>().EnableDynamicProxy(context);
var container2 = builder2.Build();
var simple2 = container2.Resolve<SimpleComponent>();
Assert.That(simple2.SimpleMethod(), Is.EqualTo("default return value"));
Assert.That(simple1.SimpleMethod(), Is.EqualTo("different return value"));
}
public void Init()
{
var context = new DynamicProxyContext();
var builder = new ContainerBuilder();
builder.RegisterType <StubWorkContextAccessor>().As <IWorkContextAccessor>();
builder.RegisterType <ThemeService>().EnableDynamicProxy(context).As <IThemeService>();
builder.RegisterType <SiteService>().As <ISiteService>();
builder.RegisterGeneric(typeof(Repository <>)).As(typeof(IRepository <>));
builder.RegisterType <Orchard.Localization.Text>().As <IText>();
builder.RegisterType <DefaultContentManager>().As <IContentManager>();
builder.RegisterType <StubCacheManager>().As <ICacheManager>();
builder.RegisterType <ContentDefinitionManager>().As <IContentDefinitionManager>();
builder.RegisterType <DefaultContentManagerSession>().As <IContentManagerSession>();
builder.RegisterType <DefaultShapeFactory>().As <IShapeFactory>();
builder.RegisterType <DefaultShapeTableManager>().As <IShapeTableManager>();
builder.RegisterType <StubExtensionManager>().As <IExtensionManager>();
builder.RegisterType <DefaultContentQuery>().As <IContentQuery>();
builder.RegisterType <SiteSettingsPartHandler>().As <IContentHandler>();
builder.RegisterType <ThemeSiteSettingsPartHandler>().As <IContentHandler>();
//builder.RegisterType<ModuleService>().As<IModuleService>();
builder.RegisterType <ShellDescriptor>();
builder.RegisterType <OrchardServices>().As <IOrchardServices>();
builder.RegisterType <StubShellDescriptorManager>().As <IShellDescriptorManager>().InstancePerLifetimeScope();
builder.RegisterType <TransactionManager>().As <ITransactionManager>();
builder.RegisterType <Notifier>().As <INotifier>();
builder.RegisterType <StubAuthorizer>().As <IAuthorizer>();
builder.RegisterType <DefaultContentDisplay>().As <IContentDisplay>();
builder.RegisterType(typeof(SettingsFormatter))
.As(typeof(IMapper <XElement, SettingsDictionary>))
.As(typeof(IMapper <SettingsDictionary, XElement>));
_session = _sessionFactory.OpenSession();
builder.RegisterInstance(new TestSessionLocator(_session)).As <ISessionLocator>();
builder.RegisterAutoMocking(MockBehavior.Loose);
_container = builder.Build();
_themeService = _container.Resolve <IThemeService>();
_siteThemeService = _container.Resolve <ISiteThemeService>();
_featureManager = _container.Resolve <IFeatureManager>();
}
public void InterceptorCatchesMethodCallOnlyFromContainerWithInterceptor()
{
var context = new DynamicProxyContext();
var builder1 = new ContainerBuilder();
builder1.RegisterType <SimpleComponent>().EnableDynamicProxy(context);
builder1.RegisterModule(new SimpleInterceptorModule());
var container1 = builder1.Build();
var simple1 = container1.Resolve <SimpleComponent>();
var builder2 = new ContainerBuilder();
builder2.RegisterType <SimpleComponent>().EnableDynamicProxy(context);
var container2 = builder2.Build();
var simple2 = container2.Resolve <SimpleComponent>();
Assert.That(simple2.SimpleMethod(), Is.EqualTo("default return value"));
Assert.That(simple1.SimpleMethod(), Is.EqualTo("different return value"));
}
public void Init() {
var context = new DynamicProxyContext();
var builder = new ContainerBuilder();
builder.RegisterType<StubWorkContextAccessor>().As<IWorkContextAccessor>();
builder.RegisterType<ThemeService>().EnableDynamicProxy(context).As<IThemeService>();
builder.RegisterType<SiteService>().As<ISiteService>();
builder.RegisterGeneric(typeof(Repository<>)).As(typeof(IRepository<>));
builder.RegisterType<Orchard.Localization.Text>().As<IText>();
builder.RegisterType<DefaultContentManager>().As<IContentManager>();
builder.RegisterType<StubCacheManager>().As<ICacheManager>();
builder.RegisterType<ContentDefinitionManager>().As<IContentDefinitionManager>();
builder.RegisterType<DefaultContentManagerSession>().As<IContentManagerSession>();
builder.RegisterType<DefaultShapeFactory>().As<IShapeFactory>();
builder.RegisterType<DefaultShapeTableManager>().As<IShapeTableManager>();
builder.RegisterType<StubExtensionManager>().As<IExtensionManager>();
builder.RegisterType<DefaultContentQuery>().As<IContentQuery>();
builder.RegisterType<SiteSettingsPartHandler>().As<IContentHandler>();
builder.RegisterType<ThemeSiteSettingsPartHandler>().As<IContentHandler>();
//builder.RegisterType<ModuleService>().As<IModuleService>();
builder.RegisterType<ShellDescriptor>();
builder.RegisterType<OrchardServices>().As<IOrchardServices>();
builder.RegisterType<StubShellDescriptorManager>().As<IShellDescriptorManager>().InstancePerLifetimeScope();
builder.RegisterType<TransactionManager>().As<ITransactionManager>();
builder.RegisterType<Notifier>().As<INotifier>();
builder.RegisterType<StubAuthorizer>().As<IAuthorizer>();
builder.RegisterType<DefaultContentDisplay>().As<IContentDisplay>();
builder.RegisterType(typeof(SettingsFormatter))
.As(typeof(IMapper<XElement, SettingsDictionary>))
.As(typeof(IMapper<SettingsDictionary, XElement>));
_session = _sessionFactory.OpenSession();
builder.RegisterInstance(new TestSessionLocator(_session)).As<ISessionLocator>();
builder.RegisterAutoMocking(MockBehavior.Loose);
_container = builder.Build();
_themeService = _container.Resolve<IThemeService>();
_siteThemeService = _container.Resolve<ISiteThemeService>();
_featureManager = _container.Resolve<IFeatureManager>();
}
public ConstructorFinderWrapper(IConstructorFinder constructorFinder, DynamicProxyContext dynamicProxyContext)
{
_constructorFinder = constructorFinder;
_dynamicProxyContext = dynamicProxyContext;
}
public ILifetimeScope CreateContainer(ShellSettings settings, ShellBlueprint blueprint) {
var intermediateScope = _lifetimeScope.BeginLifetimeScope(
builder => {
foreach (var item in blueprint.Dependencies.Where(t => typeof(IModule).IsAssignableFrom(t.Type))) {
var registration = RegisterType(builder, item)
.Keyed<IModule>(item.Type)
.InstancePerDependency();
foreach (var parameter in item.Parameters) {
registration = registration
.WithParameter(parameter.Name, parameter.Value)
.WithProperty(parameter.Name, parameter.Value);
}
}
});
return intermediateScope.BeginLifetimeScope(
"shell",
builder => {
var dynamicProxyContext = new DynamicProxyContext();
builder.Register(ctx => dynamicProxyContext);
builder.Register(ctx => settings);
builder.Register(ctx => blueprint.Descriptor);
builder.Register(ctx => blueprint);
var moduleIndex = intermediateScope.Resolve<IIndex<Type, IModule>>();
foreach (var item in blueprint.Dependencies.Where(t => typeof(IModule).IsAssignableFrom(t.Type))) {
builder.RegisterModule(moduleIndex[item.Type]);
}
foreach (var item in blueprint.Dependencies.Where(t => typeof(IDependency).IsAssignableFrom(t.Type))) {
var registration = RegisterType(builder, item)
.EnableDynamicProxy(dynamicProxyContext)
.InstancePerLifetimeScope();
foreach (var interfaceType in item.Type.GetInterfaces()
.Where(itf => typeof(IDependency).IsAssignableFrom(itf)
&& !typeof(IEventHandler).IsAssignableFrom(itf))) {
registration = registration.As(interfaceType);
if (typeof(ISingletonDependency).IsAssignableFrom(interfaceType)) {
registration = registration.InstancePerMatchingLifetimeScope("shell");
}
else if (typeof(IUnitOfWorkDependency).IsAssignableFrom(interfaceType)) {
registration = registration.InstancePerMatchingLifetimeScope("work");
}
else if (typeof(ITransientDependency).IsAssignableFrom(interfaceType)) {
registration = registration.InstancePerDependency();
}
}
if (typeof(IEventHandler).IsAssignableFrom(item.Type)) {
var interfaces = item.Type.GetInterfaces();
foreach (var interfaceType in interfaces) {
// register named instance for each interface, for efficient filtering inside event bus
// IEventHandler derived classes only
if (interfaceType.GetInterface(typeof (IEventHandler).Name) != null) {
registration = registration.Named<IEventHandler>(interfaceType.Name);
}
}
}
foreach (var parameter in item.Parameters) {
registration = registration
.WithParameter(parameter.Name, parameter.Value)
.WithProperty(parameter.Name, parameter.Value);
}
}
foreach (var item in blueprint.Controllers) {
var serviceKeyName = (item.AreaName + "/" + item.ControllerName).ToLowerInvariant();
var serviceKeyType = item.Type;
RegisterType(builder, item)
.EnableDynamicProxy(dynamicProxyContext)
.Keyed<IController>(serviceKeyName)
.Keyed<IController>(serviceKeyType)
.WithMetadata("ControllerType", item.Type)
.InstancePerDependency()
;
}
foreach (var item in blueprint.HttpControllers) {
var serviceKeyName = (item.AreaName + "/" + item.ControllerName).ToLowerInvariant();
var serviceKeyType = item.Type;
RegisterType(builder, item)
.EnableDynamicProxy(dynamicProxyContext)
.Keyed<IHttpController>(serviceKeyName)
.Keyed<IHttpController>(serviceKeyType)
.WithMetadata("ControllerType", item.Type)
.InstancePerDependency();
}
// Register code-only registrations specific to a shell
_shellContainerRegistrations.Registrations(builder);
var optionalShellByNameConfig = HostingEnvironment.MapPath("~/Config/Sites." + settings.Name + ".config");
if (File.Exists(optionalShellByNameConfig)) {
builder.RegisterModule(new ConfigurationSettingsReader(ConfigurationSettingsReaderConstants.DefaultSectionName, optionalShellByNameConfig));
}
else {
var optionalShellConfig = HostingEnvironment.MapPath("~/Config/Sites.config");
if (File.Exists(optionalShellConfig))
builder.RegisterModule(new ConfigurationSettingsReader(ConfigurationSettingsReaderConstants.DefaultSectionName, optionalShellConfig));
}
});
}
public ILifetimeScope CreateContainer(ShellSettings settings, ShellBlueprint blueprint)
{
var intermediateScope = _lifetimeScope.BeginLifetimeScope(
builder => {
foreach (var item in blueprint.Dependencies.Where(t => typeof(IModule).IsAssignableFrom(t.Type)))
{
var registration = RegisterType(builder, item)
.Keyed <IModule>(item.Type)
.InstancePerDependency();
foreach (var parameter in item.Parameters)
{
registration = registration
.WithParameter(parameter.Name, parameter.Value)
.WithProperty(parameter.Name, parameter.Value);
}
}
});
return(intermediateScope.BeginLifetimeScope(
"shell",
builder => {
var dynamicProxyContext = new DynamicProxyContext();
builder.Register(ctx => dynamicProxyContext);
builder.Register(ctx => settings);
builder.Register(ctx => blueprint.Descriptor);
builder.Register(ctx => blueprint);
var concreteRegistrationNames = new ConcurrentDictionary <Type, ConcurrentBag <NamedRegistration> >();
var moduleIndex = intermediateScope.Resolve <IIndex <Type, IModule> >();
foreach (var item in blueprint.Dependencies.Where(t => typeof(IModule).IsAssignableFrom(t.Type)))
{
builder.RegisterModule(moduleIndex[item.Type]);
}
var itemsToBeRegistered = new ConcurrentQueue <ItemToBeRegistered>();
var decorators = new ConcurrentQueue <DecoratorRegistration>();
foreach (var item in blueprint.Dependencies.Where(t => typeof(IDependency).IsAssignableFrom(t.Type)))
{
// Determine if this service is an IEventHandler
var isEventHandler = typeof(IEventHandler).IsAssignableFrom(item.Type);
// Harvest any interfaces that this service decorates
var decoratingTypes = item.Type.GetInterfaces()
.Where(x => x.IsGenericType && x.GetGenericTypeDefinition() == typeof(IDecorator <>))
.Select(t => t.GetGenericArguments().First());
var isDecorator = decoratingTypes != null && decoratingTypes.Any();
if (isDecorator && isEventHandler)
{
Logger.Error(string.Format("Type `{0}` is an IDecorator, but is also an IEventHandler. Decorating IEventHandlers is not currently supported. This decorator will not be registered.", item.Type.FullName));
continue;
}
if (isDecorator)
{
// If this service is a decorator, we need to determine which types it decorates
foreach (var itemToBeRegistered in itemsToBeRegistered)
{
foreach (var interfaceType in decoratingTypes)
{
if (itemToBeRegistered.InterfaceTypes.Contains(interfaceType))
{
if (itemToBeRegistered.DecoratedTypes == null)
{
itemToBeRegistered.DecoratedTypes = new List <Type>();
}
// Add to the collection of interfaces that are decorated only if this interface type has not previously been added
if (!itemToBeRegistered.DecoratedTypes.Contains(interfaceType))
{
itemToBeRegistered.DecoratedTypes.Add(interfaceType);
}
}
}
}
}
itemsToBeRegistered.Enqueue(new ItemToBeRegistered {
Item = item, InterfaceTypes = GetInterfacesFromBlueprint(item), DecoratingTypes = decoratingTypes, IsEventHandler = isEventHandler
});
}
foreach (var itemToBeRegistered in itemsToBeRegistered)
{
var registration = RegisterType(builder, itemToBeRegistered.Item)
.AsSelf()
.EnableDynamicProxy(dynamicProxyContext)
.InstancePerLifetimeScope();
var registrationName = registration.ActivatorData.ImplementationType.FullName;
registration.Named(registrationName, itemToBeRegistered.Item.Type);
foreach (var interfaceType in itemToBeRegistered.InterfaceTypes)
{
registration = SetRegistrationScope(interfaceType, registration);
var itemIsDecorator = itemToBeRegistered.IsDecorator(interfaceType);
var itemIsDecorated = itemToBeRegistered.IsDecorated(interfaceType);
if (!itemIsDecorated && !itemIsDecorator)
{
// This item is not decorated by another implementation of this interface type and is not a decorator.
// It should be registered as the implementation of this interface. The ensures that Autofac will resolve only a single implementation should there be one or more decorators.
registration = registration.As(interfaceType);
}
if (itemIsDecorator)
{
// This item decorates the interface currently being registered.
// It needs to be added to the list of decorators so that is can be registered once all of the concrete implementations have been registered.
decorators.Enqueue(new DecoratorRegistration(interfaceType, itemToBeRegistered, itemIsDecorated));
}
else
{
// This item is not a decorator.
// We need to add it to the list of concrete implementations. This allows us to know the names of the implementations that need to be decorated should a decorator for this interface exist.
AddConcreteRegistrationName(registrationName, interfaceType, itemToBeRegistered.Item.Type, concreteRegistrationNames);
}
}
if (itemToBeRegistered.IsEventHandler)
{
var interfaces = itemToBeRegistered.Item.Type.GetInterfaces();
foreach (var interfaceType in interfaces)
{
// register named instance for each interface, for efficient filtering inside event bus
// IEventHandler derived classes only
if (interfaceType.GetInterface(typeof(IEventHandler).Name) != null)
{
registration = registration.Named <IEventHandler>(interfaceType.Name);
}
}
}
foreach (var parameter in itemToBeRegistered.Item.Parameters)
{
registration = registration
.WithParameter(parameter.Name, parameter.Value)
.WithProperty(parameter.Name, parameter.Value);
}
}
foreach (var decorator in decorators)
{
// We need to ensure that there is an implementation of this service that can be decorated
if (!concreteRegistrationNames.ContainsKey(decorator.InterfaceType) || concreteRegistrationNames[decorator.InterfaceType] == null || !concreteRegistrationNames[decorator.InterfaceType].Any())
{
var exception = new SystemFatalException(T("The only registered implementations of `{0}` are decorators. In order to avoid circular dependenices, there must be at least one implementation that is not marked with the `OrchardDecorator` attribute.", decorator.InterfaceType.FullName));
Logger.Fatal(exception, "Could not complete dependency registration as a circular dependency chain has been found.");
throw exception;
}
var decoratorNames = new ConcurrentBag <NamedRegistration>();
// For every implementation that can be decorated
foreach (var namedRegistration in concreteRegistrationNames[decorator.InterfaceType])
{
var registration = RegisterType(builder, decorator.ItemToBeRegistered.Item)
.AsSelf()
.EnableDynamicProxy(dynamicProxyContext)
.InstancePerLifetimeScope();
registration = SetRegistrationScope(decorator.InterfaceType, registration);
// Create a unique name for the decorator
var decoratorName = string.Format("{0}-{1}", namedRegistration.Name, decorator.ItemToBeRegistered.Item.Type.FullName);
registration = registration.Named(decoratorName, decorator.ItemToBeRegistered.Item.Type);
// Tell Autofac to resolve the decorated service with the implementation that has already been registered
registration = registration.WithParameter(
(p, c) => p.ParameterType == decorator.InterfaceType,
(p, c) => c.ResolveNamed(namedRegistration.Name, namedRegistration.ImplementationType));
if (!decorator.IsDecorated)
{
// This is the last decorator in the stack, so register it as the implmentation of the interface that it is decorating
registration = registration.As(decorator.InterfaceType);
}
decoratorNames.Add(new NamedRegistration(decoratorName, decorator.ItemToBeRegistered.Item.Type));
}
// Update the collection of implmentation names that can be decorated to contain only the decorators (this allows us to stack decorators)
concreteRegistrationNames[decorator.InterfaceType] = decoratorNames;
}
foreach (var item in blueprint.Controllers)
{
var serviceKeyName = (item.AreaName + "/" + item.ControllerName).ToLowerInvariant();
var serviceKeyType = item.Type;
RegisterType(builder, item)
.EnableDynamicProxy(dynamicProxyContext)
.Keyed <IController>(serviceKeyName)
.Keyed <IController>(serviceKeyType)
.WithMetadata("ControllerType", item.Type)
.InstancePerDependency();
}
foreach (var item in blueprint.HttpControllers)
{
var serviceKeyName = (item.AreaName + "/" + item.ControllerName).ToLowerInvariant();
var serviceKeyType = item.Type;
RegisterType(builder, item)
.EnableDynamicProxy(dynamicProxyContext)
.Keyed <IHttpController>(serviceKeyName)
.Keyed <IHttpController>(serviceKeyType)
.WithMetadata("ControllerType", item.Type)
.InstancePerDependency();
}
// Register code-only registrations specific to a shell
_shellContainerRegistrations.Registrations(builder);
var optionalShellByNameConfig = HostingEnvironment.MapPath("~/Config/Sites." + settings.Name + ".config");
if (File.Exists(optionalShellByNameConfig))
{
builder.RegisterModule(ConfigurationSettingsReaderFactory.CreateConfigurationSettingsReader(optionalShellByNameConfig));
}
else
{
var optionalShellConfig = HostingEnvironment.MapPath("~/Config/Sites.config");
if (File.Exists(optionalShellConfig))
{
builder.RegisterModule(ConfigurationSettingsReaderFactory.CreateConfigurationSettingsReader(optionalShellConfig));
}
}
var optionalComponentsConfig = HostingEnvironment.MapPath("~/Config/HostComponents.config");
if (File.Exists(optionalComponentsConfig))
{
builder.RegisterModule(new HostComponentsConfigModule(optionalComponentsConfig));
}
}));
}
public ILifetimeScope CreateContainer(ShellSettings settings, ShellBlueprint blueprint)
{
var intermediateScope = lifetimeScope.BeginLifetimeScope(
builder =>
{
foreach (var item in blueprint.Dependencies.Where(t => typeof(IModule).IsAssignableFrom(t.Type)))
{
RegisterType(builder, item)
.Keyed <IModule>(item.Type)
.InstancePerDependency();
}
});
return(intermediateScope.BeginLifetimeScope(
"shell",
builder =>
{
var dynamicProxyContext = new DynamicProxyContext();
builder.Register(ctx => dynamicProxyContext);
builder.Register(ctx => settings);
builder.Register(ctx => blueprint.Descriptor);
builder.Register(ctx => blueprint);
var moduleIndex = intermediateScope.Resolve <IIndex <Type, IModule> >();
foreach (var item in blueprint.Dependencies.Where(t => typeof(IModule).IsAssignableFrom(t.Type)))
{
builder.RegisterModule(moduleIndex[item.Type]);
}
foreach (var item in blueprint.Dependencies.Where(t => typeof(IDependency).IsAssignableFrom(t.Type)))
{
var registration = RegisterType(builder, item)
.EnableDynamicProxy(dynamicProxyContext)
.InstancePerLifetimeScope();
foreach (var interfaceType in item.Type.GetInterfaces()
.Where(itf => typeof(IDependency).IsAssignableFrom(itf) &&
!typeof(IEventHandler).IsAssignableFrom(itf)))
{
registration = registration.As(interfaceType);
if (typeof(ISingletonDependency).IsAssignableFrom(interfaceType))
{
registration = registration.InstancePerMatchingLifetimeScope("shell");
}
else if (typeof(IUnitOfWorkDependency).IsAssignableFrom(interfaceType))
{
registration = registration.InstancePerMatchingLifetimeScope("work");
}
else if (typeof(ITransientDependency).IsAssignableFrom(interfaceType))
{
registration = registration.InstancePerDependency();
}
else if (typeof(IEntityTypeConfiguration).IsAssignableFrom(interfaceType))
{
if (item.Type.BaseType != null && item.Type.BaseType.GenericTypeArguments.Length == 1)
{
var domainType = item.Type.BaseType.GenericTypeArguments[0];
registration = registration.Named <IEntityTypeConfiguration>(domainType.Namespace);
}
}
}
if (typeof(IEventHandler).IsAssignableFrom(item.Type))
{
registration = registration.As(typeof(IEventHandler));
}
}
foreach (var item in blueprint.Controllers)
{
var serviceKeyName = (item.AreaName + "/" + item.ControllerName).ToLowerInvariant();
var serviceKeyType = item.Type;
RegisterType(builder, item)
.EnableDynamicProxy(dynamicProxyContext)
.Keyed <IController>(serviceKeyName)
.Keyed <IController>(serviceKeyType)
.WithMetadata("ControllerType", item.Type)
.InstancePerDependency()
.OnActivating(e =>
{
// necessary to inject custom filters dynamically see FilterResolvingActionInvoker
var controller = e.Instance as Controller;
if (controller != null)
{
controller.ActionInvoker = (IActionInvoker)e.Context.ResolveService(new TypedService(typeof(IActionInvoker)));
}
});
}
foreach (var item in blueprint.HttpControllers)
{
var serviceKeyName = (item.AreaName + "/" + item.ControllerName).ToLowerInvariant();
var serviceKeyType = item.Type;
RegisterType(builder, item)
.EnableDynamicProxy(dynamicProxyContext)
.Keyed <IHttpController>(serviceKeyName)
.Keyed <IHttpController>(serviceKeyType)
.WithMetadata("ControllerType", item.Type)
.InstancePerDependency();
}
// Register code-only registrations specific to a shell
shellContainerRegistrations.Registrations(builder);
}));
}
public ILifetimeScope CreateContainer(ShellSettings settings, ShellBlueprint blueprint)
{
var intermediateScope = _lifetimeScope.BeginLifetimeScope(
builder =>
{
foreach (var item in blueprint.Dependencies.Where(t => typeof(IModule).IsAssignableFrom(t.Type)))
{
var registration = RegisterType(builder, item)
.Keyed <IModule>(item.Type)
.InstancePerDependency();
foreach (var parameter in item.Parameters)
{
registration = registration
.WithParameter(parameter.Name, parameter.Value)
.WithProperty(parameter.Name, parameter.Value);
}
}
});
return(intermediateScope.BeginLifetimeScope(
"shell",
builder =>
{
var dynamicProxyContext = new DynamicProxyContext();
builder.Register(ctx => dynamicProxyContext);
builder.Register(ctx => settings);
builder.Register(ctx => blueprint.Descriptor);
builder.Register(ctx => blueprint);
var moduleIndex = intermediateScope.Resolve <IIndex <Type, IModule> >();
foreach (var item in blueprint.Dependencies.Where(t => typeof(IModule).IsAssignableFrom(t.Type)))
{
builder.RegisterModule(moduleIndex[item.Type]);
}
foreach (var item in blueprint.Dependencies.Where(t => typeof(IDependency).IsAssignableFrom(t.Type)))
{
var registration = RegisterType(builder, item)
.EnableDynamicProxy(dynamicProxyContext)
.InstancePerLifetimeScope();
foreach (var interfaceType in item.Type.GetInterfaces()
.Where(itf => typeof(IDependency).IsAssignableFrom(itf) &&
!typeof(IEventHandler).IsAssignableFrom(itf)))
{
registration = registration.As(interfaceType).AsSelf();
if (typeof(ISingletonDependency).IsAssignableFrom(interfaceType))
{
registration = registration.InstancePerMatchingLifetimeScope("shell");
}
else if (typeof(IUnitOfWorkDependency).IsAssignableFrom(interfaceType))
{
registration = registration.InstancePerMatchingLifetimeScope("work");
}
else if (typeof(ITransientDependency).IsAssignableFrom(interfaceType))
{
registration = registration.InstancePerDependency();
}
}
if (typeof(IEventHandler).IsAssignableFrom(item.Type))
{
var interfaces = item.Type.GetInterfaces();
foreach (var interfaceType in interfaces)
{
// register named instance for each interface, for efficient filtering inside event bus
// IEventHandler derived classes only
if (interfaceType.GetInterface(typeof(IEventHandler).Name) != null)
{
registration = registration.Named <IEventHandler>(interfaceType.Name);
}
}
}
foreach (var parameter in item.Parameters)
{
registration = registration
.WithParameter(parameter.Name, parameter.Value)
.WithProperty(parameter.Name, parameter.Value);
}
}
foreach (var item in blueprint.Controllers)
{
var serviceKeyName = (item.AreaName + "/" + item.ControllerName).ToLowerInvariant();
var serviceKeyType = item.Type;
RegisterType(builder, item)
.EnableDynamicProxy(dynamicProxyContext)
.Keyed <IController>(serviceKeyName)
.Keyed <IController>(serviceKeyType)
.WithMetadata("ControllerType", item.Type)
.InstancePerDependency()
;
}
foreach (var item in blueprint.HttpControllers)
{
var serviceKeyName = (item.AreaName + "/" + item.ControllerName).ToLowerInvariant();
var serviceKeyType = item.Type;
RegisterType(builder, item)
.EnableDynamicProxy(dynamicProxyContext)
.Keyed <IHttpController>(serviceKeyName)
.Keyed <IHttpController>(serviceKeyType)
.WithMetadata("ControllerType", item.Type)
.InstancePerDependency();
}
// Register code-only registrations specific to a shell
_shellContainerRegistrations.Registrations(builder);
var optionalShellByNameConfig = HostingEnvironment.MapPath("~/Config/Sites." + settings.Name + ".config");
if (File.Exists(optionalShellByNameConfig))
{
builder.RegisterModule(new ConfigurationSettingsReader(ConfigurationSettingsReaderConstants.DefaultSectionName, optionalShellByNameConfig));
}
else
{
var optionalShellConfig = HostingEnvironment.MapPath("~/Config/Sites.config");
if (File.Exists(optionalShellConfig))
{
builder.RegisterModule(new ConfigurationSettingsReader(ConfigurationSettingsReaderConstants.DefaultSectionName, optionalShellConfig));
}
}
var optionalComponentsConfig = HostingEnvironment.MapPath("~/Config/HostComponents.config");
if (File.Exists(optionalComponentsConfig))
{
builder.RegisterModule(new HostComponentsConfigModule(optionalComponentsConfig));
}
}));
}
public ILifetimeScope CreateContainer(ShellSettings settings, ShellTopology topology)
{
var intermediateScope = _lifetimeScope.BeginLifetimeScope(
builder => {
foreach (var item in topology.Dependencies.Where(t => typeof(IModule).IsAssignableFrom(t.Type))) {
var registration = RegisterType(builder, item)
.Keyed<IModule>(item.Type)
.InstancePerDependency();
foreach (var parameter in item.Parameters) {
registration = registration
.WithParameter(parameter.Name, parameter.Value)
.WithProperty(parameter.Name, parameter.Value);
}
}
});
return intermediateScope.BeginLifetimeScope(
"shell",
builder => {
var dynamicProxyContext = new DynamicProxyContext();
builder.Register(ctx => dynamicProxyContext);
builder.Register(ctx => settings);
builder.Register(ctx => topology);
var moduleIndex = intermediateScope.Resolve<IIndex<Type, IModule>>();
foreach (var item in topology.Dependencies.Where(t => typeof(IModule).IsAssignableFrom(t.Type))) {
builder.RegisterModule(moduleIndex[item.Type]);
}
foreach (var item in topology.Dependencies.Where(t => typeof(IDependency).IsAssignableFrom(t.Type))) {
var registration = RegisterType(builder, item)
.EnableDynamicProxy(dynamicProxyContext)
.InstancePerLifetimeScope();
foreach (var interfaceType in item.Type.GetInterfaces()
.Where(itf => typeof(IDependency).IsAssignableFrom(itf)
&& !typeof(IEventHandler).IsAssignableFrom(itf))) {
registration = registration.As(interfaceType);
if (typeof(ISingletonDependency).IsAssignableFrom(interfaceType)) {
registration = registration.InstancePerMatchingLifetimeScope("shell");
}
else if (typeof(ITransientDependency).IsAssignableFrom(interfaceType)) {
registration = registration.InstancePerDependency();
}
}
if (typeof(IEventHandler).IsAssignableFrom(item.Type)) {
registration = registration.As(typeof(IEventHandler));
}
foreach (var parameter in item.Parameters) {
registration = registration
.WithParameter(parameter.Name, parameter.Value)
.WithProperty(parameter.Name, parameter.Value);
}
}
foreach (var item in topology.Controllers) {
var serviceKey = (item.AreaName + "/" + item.ControllerName).ToLowerInvariant();
RegisterType(builder, item)
.EnableDynamicProxy(dynamicProxyContext)
.Keyed<IController>(serviceKey)
.InstancePerDependency()
.InjectActionInvoker();
}
var optionalShellConfig = HostingEnvironment.MapPath("~/Config/Sites.config");
if (File.Exists(optionalShellConfig))
builder.RegisterModule(new ConfigurationSettingsReader(ConfigurationSettingsReader.DefaultSectionName, optionalShellConfig));
var optionalShellByNameConfig = HostingEnvironment.MapPath("~/Config/Sites." + settings.Name + ".config");
if (File.Exists(optionalShellByNameConfig))
builder.RegisterModule(new ConfigurationSettingsReader(ConfigurationSettingsReader.DefaultSectionName, optionalShellByNameConfig));
});
}
