private ScopeRestrictedRegistry CreateScopeRestrictedRegistry(object tag, Action <ContainerBuilder> configurationAction) { var builder = new ContainerBuilder(new FallbackDictionary <string, object>(ComponentRegistry.Properties)); foreach (var source in ComponentRegistry.Sources .Where(src => src.IsAdapterForIndividualComponents)) { builder.RegisterSource(source); } // Issue #272: Only the most nested parent registry with HasLocalComponents is registered as an external source // It provides all non-adapting registrations from itself and from it's parent registries var parent = Traverse.Across <ISharingLifetimeScope>(this, s => s.ParentLifetimeScope) .Where(s => s.ComponentRegistry.HasLocalComponents) .Select(s => new ExternalRegistrySource(s.ComponentRegistry)) .FirstOrDefault(); if (parent != null) { builder.RegisterSource(parent); } configurationAction(builder); var locals = new ScopeRestrictedRegistry(tag, builder.Properties); builder.UpdateRegistry(locals); return(locals); }
ScopeRestrictedRegistry CreateScopeRestrictedRegistry(object tag, Action <ContainerBuilder> configurationAction) { var builder = new ContainerBuilder(); foreach (var source in ComponentRegistry.Sources .Where(src => src.IsAdapterForIndividualComponents)) { builder.RegisterSource(source); } var parents = Traverse.Across <ISharingLifetimeScope>(this, s => s.ParentLifetimeScope) .Where(s => s.ComponentRegistry.HasLocalComponents) .Select(s => new ExternalRegistrySource(s.ComponentRegistry)) .Reverse(); foreach (var external in parents) { builder.RegisterSource(external); } configurationAction(builder); var locals = new ScopeRestrictedRegistry(tag); builder.Update(locals); return(locals); }
public void traverses_the_object() { var type = typeof(StubsForReflection); var result = Traverse.Across(type, x => x !.BaseType).ToList(); result.ShouldNotBeNull(); result.Count.ShouldBe(2); result[0].ShouldBe(typeof(StubsForReflection)); result[1].ShouldBe(typeof(object)); }
public static void EnforceBindable(Type implementationType, IEnumerable <Service> services) { if (implementationType == null) { throw new ArgumentNullException("implementationType"); } if (services == null) { throw new ArgumentNullException("services"); } #if !ASPNETCORE50 if (!implementationType.IsGenericTypeDefinition) #else if (!implementationType.GetTypeInfo().IsGenericTypeDefinition) #endif { throw new ArgumentException( string.Format(CultureInfo.CurrentCulture, OpenGenericServiceBinderResources.ImplementorMustBeOpenGenericTypeDefinition, implementationType)); } foreach (IServiceWithType service in services) { #if !ASPNETCORE50 if (!service.ServiceType.IsGenericTypeDefinition) #else if (!service.ServiceType.GetTypeInfo().IsGenericTypeDefinition) #endif { throw new ArgumentException( string.Format(CultureInfo.CurrentCulture, OpenGenericServiceBinderResources.ServiceTypeMustBeOpenGenericTypeDefinition, service)); } #if !ASPNETCORE50 if (service.ServiceType.IsInterface) #else if (service.ServiceType.GetTypeInfo().IsInterface) #endif { if (GetInterface(implementationType, service.ServiceType) == null) { throw new ArgumentException(string.Format(CultureInfo.CurrentCulture, OpenGenericServiceBinderResources.InterfaceIsNotImplemented, implementationType, service)); } } else { #if !ASPNETCORE50 if (!Traverse.Across(implementationType, t => t.BaseType).Any(t => IsCompatibleGenericClassDefinition(t, service.ServiceType))) #else if (!Traverse.Across(implementationType, t => t.GetTypeInfo().BaseType).Any(t => IsCompatibleGenericClassDefinition(t, service.ServiceType))) #endif { throw new ArgumentException(string.Format(CultureInfo.CurrentCulture, OpenGenericServiceBinderResources.TypesAreNotConvertible, implementationType, service)); } } } }
public static void EnforceBindable(Type implementationType, IEnumerable <Service> services) { if (implementationType == null) { throw new ArgumentNullException("implementationType"); } if (services == null) { throw new ArgumentNullException("services"); } if (!implementationType.IsGenericTypeDefinition) { throw new ArgumentException(string.Format(OpenGenericServiceBinderResources.ImplementorMustBeOpenGenericTypeDefinition, implementationType)); } using (IEnumerator <Service> enumerator = services.GetEnumerator()) { Func <Type, bool> predicate = null; while (enumerator.MoveNext()) { IServiceWithType service = (IServiceWithType)enumerator.Current; if (!service.ServiceType.IsGenericTypeDefinition) { throw new ArgumentException(string.Format(OpenGenericServiceBinderResources.ServiceTypeMustBeOpenGenericTypeDefinition, service)); } if (service.ServiceType.IsInterface) { if (GetInterface(implementationType, service.ServiceType) == null) { throw new ArgumentException(string.Format(OpenGenericServiceBinderResources.InterfaceIsNotImplemented, implementationType, service)); } } else { if (predicate == null) { predicate = t => IsCompatibleGenericClassDefinition(t, service.ServiceType); } if (!Traverse.Across <Type>(implementationType, t => t.BaseType).Any <Type>(predicate)) { throw new ArgumentException(string.Format(OpenGenericServiceBinderResources.TypesAreNotConvertible, implementationType, service)); } } } } }
/// <summary> /// Throws an exception if an open generic implementation type cannot implement the set of specified open services. /// </summary> /// <param name="implementationType">The open generic implementation type.</param> /// <param name="services">The set of open generic services.</param> public static void EnforceBindable(Type implementationType, IEnumerable <Service> services) { if (implementationType == null) { throw new ArgumentNullException(nameof(implementationType)); } if (services == null) { throw new ArgumentNullException(nameof(services)); } if (!implementationType.IsGenericTypeDefinition) { throw new ArgumentException( string.Format(CultureInfo.CurrentCulture, OpenGenericServiceBinderResources.ImplementorMustBeOpenGenericTypeDefinition, implementationType)); } foreach (var service in services.OfType <IServiceWithType>()) { if (!service.ServiceType.IsGenericTypeDefinition) { throw new ArgumentException( string.Format(CultureInfo.CurrentCulture, OpenGenericServiceBinderResources.ServiceTypeMustBeOpenGenericTypeDefinition, service)); } if (service.ServiceType.IsInterface) { if (GetInterfaces(implementationType, service.ServiceType).Length == 0) { var message = string.Format(CultureInfo.CurrentCulture, OpenGenericServiceBinderResources.ImplementorDoesntImplementService, implementationType.FullName, service.ServiceType.FullName); throw new InvalidOperationException(message); } } else { if (!Traverse.Across(implementationType, t => t.BaseType !).Any(t => IsCompatibleGenericClassDefinition(t, service.ServiceType))) { throw new ArgumentException(string.Format(CultureInfo.CurrentCulture, OpenGenericServiceBinderResources.TypesAreNotConvertible, implementationType, service)); } } } }
public static void EnforceBindable(Type implementationType, IEnumerable <Service> services) { if (implementationType == null) { throw new ArgumentNullException("implementationType"); } if (services == null) { throw new ArgumentNullException("services"); } if (!implementationType.IsGenericTypeDefinition) { throw new ArgumentException( string.Format("The implementation type '{0}' is not an open generic type definition.", implementationType)); } foreach (IServiceWithType service in services) { if (!service.ServiceType.IsGenericTypeDefinition) { throw new ArgumentException( string.Format("The service '{0}' is not an open generic type definition.", service)); } if (service.ServiceType.IsInterface) { if (GetInterface(implementationType, service.ServiceType) == null) { throw new ArgumentException(string.Format("The implementation type '{0}' does not support the interface '{1}'.", implementationType, service)); } } else { if (!Traverse.Across(implementationType, t => t.BaseType).Any(t => IsCompatibleGenericClassDefinition(t, service.ServiceType))) { throw new ArgumentException(string.Format("The service '{1}' is not assignable from implementation type '{0}'.", implementationType, service)); } } } }
private ScopeRestrictedRegistry CreateScopeRestrictedRegistry(object tag, Action <ContainerBuilder> configurationAction) { ContainerBuilder builder = new ContainerBuilder(); foreach (IRegistrationSource source in from src in this.ComponentRegistry.Sources where src.IsAdapterForIndividualComponents select src) { builder.RegisterSource(source); } foreach (ExternalRegistrySource source2 in (from s in Traverse.Across <ISharingLifetimeScope>(this, s => s.ParentLifetimeScope) where s.ComponentRegistry.HasLocalComponents select new ExternalRegistrySource(s.ComponentRegistry)).Reverse <ExternalRegistrySource>()) { builder.RegisterSource(source2); } configurationAction(builder); ScopeRestrictedRegistry componentRegistry = new ScopeRestrictedRegistry(tag); builder.Update(componentRegistry); return(componentRegistry); }
public void throws_on_null_next() { Should.Throw <ArgumentNullException>(() => Traverse.Across(new object(), null !).Materialize()); }
/// <summary> /// Gets the types assignable from the specified type. /// </summary> /// <param name="type"> /// The type to traverse for assignable types. /// </param> /// <returns> /// All available assignable types. /// </returns> public static IEnumerable <Type> TypesAssignableFrom(this Type type) { type = Guard.NotNull(type, nameof(type)); return(type.GetInterfaces().Concat(Traverse.Across(type, t => t?.BaseType))); }