/// <summary> /// Executes the task. Returns continuation of the next task(s) in the chain. /// </summary> /// <returns></returns> public override TaskContinuation Execute() { Func <Type, bool> filter = type => KnownTypes.ControllerType.IsAssignableFrom(type) && type.Assembly != KnownAssembly.AspNetMvcAssembly && !type.Assembly.GetName().Name.Equals(KnownAssembly.AspNetMvcFutureAssemblyName, StringComparison.OrdinalIgnoreCase) && !IgnoredTypes.Any(ignoredType => ignoredType == type); Container.GetService <IBuildManager>() .ConcreteTypes .Where(filter) .Each(type => { var controllerName = type.Name; if (controllerName.EndsWith("Controller")) { controllerName = controllerName.Substring(0, controllerName.Length - "Controller".Length); } var areaName = type.Assembly.GetName().Name; var serviceKey = (areaName + "/" + controllerName).ToLowerInvariant(); Container.RegisterType(serviceKey, KnownTypes.ControllerType, type, LifetimeType.Transient); }); return(TaskContinuation.Continue); }
private void GetConcreteTypes(Assembly assembly, List <T> results) { if (ReflectionBlackList.IsBlackListed(assembly)) { return; } var allTypes = AssemblyTypesResolver.ResolveTypes(assembly, Logger); var concreteTypes = allTypes.Where(type => typeof(T).IsAssignableFrom(type) && !type.IsInterface && !type.IsAbstract && !IgnoredTypes.Contains(type)); foreach (var type in concreteTypes) { try { var instance = (T)Activator.CreateInstance(type); results.Add(instance); } catch (Exception exception) { Logger.Error(Resources.DiscoverCreateInstance, exception, typeof(T), type); } } }
public void IgnoresOpenGeneric() { var ignoredType = typeof(IgnoredGenericType <>); var ignoredTypes = IgnoredTypes.Create(new[] { ignoredType }); Assert.AreEqual(true, ignoredTypes.IsIgnoringType(ignoredType)); Assert.AreEqual(true, ignoredTypes.IsIgnoringType(typeof(IgnoredGenericType <double>))); }
public void IgnoresSimple() { var ignoredType = typeof(IgnoredType); var ignoredTypes = IgnoredTypes.Create(new[] { ignoredType }); Assert.AreEqual(true, ignoredTypes.IsIgnoringType(ignoredType)); Assert.AreEqual(false, ignoredTypes.IsIgnoringType(typeof(IgnoredGenericType <int>))); }
/// <summary> /// Filter to be applied to Concrete types list /// </summary> /// <param name="type"></param> /// <returns></returns> protected virtual bool MatchTypeFilter(Type type) { if (KnownType.IsAssignableFrom(type) && !KnownAttributeType.IsAssignableFrom(type) && (type.Assembly != AspNetMvcAssembly && type.Assembly != AspNetMvcExtensionsAssembly) && !type.Assembly.GetName().Name.Equals(AspNetMvcFutureAssemblyName, StringComparison.OrdinalIgnoreCase)) { return IgnoredTypes.All(ignoredType => ignoredType != type); } return false; }
public override void DefaultVisit(SyntaxNode node) { if (!IgnoredTypes.TryGetValue(node.GetType(), out var terminating)) { throw new NotSupportedException($"{node.GetType().Name} is not supported at: {node}"); } if (!terminating) { base.DefaultVisit(node); } }
/// <summary> /// Executes the task. Returns continuation of the next task(s) in the chain. /// </summary> /// <returns></returns> public override TaskContinuation Execute() { Func <Type, bool> filter = type => KnownTypes.ActionInvokerType.IsAssignableFrom(type) && !IgnoredTypes.Contains(type); Container.GetService <IBuildManager>() .ConcreteTypes .Where(filter) .Each(type => Container.RegisterAsTransient(type)); return(TaskContinuation.Continue); }
/// <summary> /// Executes the task. Returns continuation of the next task(s) in the chain. /// </summary> /// <returns></returns> public override TaskContinuation Execute() { Func <Type, bool> filter = type => KnownTypes.ViewEngineType.IsAssignableFrom(type) && type.Assembly != KnownAssembly.AspNetMvcAssembly && !IgnoredTypes.Contains(type); Container.GetService <IBuildManager>() .ConcreteTypes .Where(filter) .Each(type => Container.RegisterAsSingleton(KnownTypes.ViewEngineType, type)); return(TaskContinuation.Continue); }
/// <summary> /// Executes the task. Returns continuation of the next task(s) in the chain. /// </summary> /// <returns></returns> public override TaskContinuation Execute() { Func <Type, bool> filter = type => KnownTypes.ValueProviderFactoryType.IsAssignableFrom(type) && type.Assembly != KnownAssembly.AspNetMvcAssembly && !IgnoredTypes.Any(ignoredType => ignoredType == type); Container.GetService <IBuildManager>() .ConcreteTypes .Where(filter) .Each(type => Container.RegisterAsTransient(KnownTypes.ValueProviderFactoryType, type)); return(TaskContinuation.Continue); }
/// <summary> /// Executes the task. /// </summary><returns></returns> public override TaskContinuation Execute() { Func <Type, bool> filter = type => KnownTypes.ViewType.IsAssignableFrom(type) && type.Assembly != KnownAssembly.AspNetMvcAssembly && !type.Assembly.GetName().Name.Equals(KnownAssembly.AspNetMvcFutureAssemblyName, StringComparison.OrdinalIgnoreCase) && !IgnoredTypes.Any(ignoredType => ignoredType == type); Container.GetService <IBuildManager>() .ConcreteTypes .Where(filter) .Each(type => Container.RegisterAsTransient(type)); return(TaskContinuation.Continue); }
/// <summary> /// Determines if the specified property should be included in the list of a given type's properties. /// <para> /// The default behavior is to check the property name against the <see cref="IgnoredNames"/> list /// and check the property type against the <see cref="IgnoredTypes"/> list. The type is /// checked for equality and via <see cref="Type.IsAssignableFrom(Type)"/>. If both the property /// type and the currently tested type are generic (<see cref="Type.IsGenericType"/>), the equality and assignable tests are repeated /// with the generic definitions obtained by calling <see cref="Type.GetGenericTypeDefinition"/>. Additionally, /// read-only properties are ignored. /// </para> /// </summary> /// <param name="property">The property</param> /// <returns>True if the property should be included, or false.</returns> protected virtual bool IncludeProperty(PropertyInfo property) { if (IgnoredNames.Contains(property.Name, StringComparer.OrdinalIgnoreCase)) { return(false); } var type = property.PropertyType; if (IgnoredTypes.Any(a => { if (a.Equals(type)) { return(true); } if (a.IsAssignableFrom(type)) { return(true); } if (type.IsGenericType && a.IsGenericType) { var genericA = a.GetGenericTypeDefinition(); var genericType = type.GetGenericTypeDefinition(); if (genericA.Equals(genericType)) { return(true); } if (genericA.IsAssignableFrom(genericType)) { return(true); } } return(false); })) { return(false); } // If we have a read-only property, we don't want to map // it to anything. if (!property.CanWrite) { return(false); } return(true); }
private void GetConcreteTypes(Assembly assembly, List <T> results) { // GetTypes potentially throws and exception. Defensive coding as per http://haacked.com/archive/2012/07/23/get-all-types-in-an-assembly.aspx Type[] allTypes; try { allTypes = assembly.GetTypes(); } catch (ReflectionTypeLoadException ex) { allTypes = ex.Types.Where(t => t != null).ToArray(); foreach (var exception in ex.LoaderExceptions) { Logger.Warn(Resources.DiscoverGetType, exception); } } var concreteTypes = allTypes.Where(type => typeof(T).IsAssignableFrom(type) && !type.IsInterface && !type.IsAbstract && !IgnoredTypes.Contains(type)); foreach (var type in concreteTypes) { try { var instance = (T)Activator.CreateInstance(type); results.Add(instance); } catch (Exception exception) { Logger.Error(Resources.DiscoverCreateInstance, exception, typeof(T), type); } } }
/// <summary> /// Discovers this all instanced of <typeparamref name="T"/> within the discovery location. /// </summary> public void Discover() { Logger.Debug("Discovering {0}'s in '{1}' and all sub directories.", typeof(T).Name, DiscoveryLocation); var results = new List <T>(); foreach (var file in Directory.GetFiles(DiscoveryLocation, "*.dll", SearchOption.AllDirectories)) { try { Assembly assembly = Assembly.LoadFrom(file); Type[] allTypes; // GetTypes potentially throws and exception. Defensive coding as per http://haacked.com/archive/2012/07/23/get-all-types-in-an-assembly.aspx try { allTypes = assembly.GetTypes(); } catch (ReflectionTypeLoadException ex) { allTypes = ex.Types.Where(t => t != null).ToArray(); foreach (var exception in ex.LoaderExceptions) { Logger.Warn(Resources.DiscoverGetType, exception); } } var concreteTypes = allTypes.Where(type => typeof(T).IsAssignableFrom(type) && !type.IsInterface && !type.IsAbstract && !IgnoredTypes.Contains(type)); foreach (var type in concreteTypes) { try { var instance = (T)Activator.CreateInstance(type); results.Add(instance); } catch (Exception exception) { Logger.Error(Resources.DiscoverCreateInstance, exception, typeof(T), type); } } } catch (Exception exception) { Logger.Error(Resources.DiscoverLoadAssembly, exception, file); } } if (results.Count > 0) { Items.Clear(); foreach (var result in results) { Logger.Debug(string.Format(Resources.DiscoverableCollectionDiscover, typeof(T).Name, result.GetType())); } Items.AddRange(results); } }
/// <summary> /// Ignores the type. /// </summary> /// <param name="type">The type.</param> public void IgnoreType(Type type) { IgnoredTypes.Add(type); }
public override void VisitTypeDeclaration(TypeDeclaration typeDeclaration) { if (CurrentType != null) { NestedTypes = NestedTypes ?? new List <Tuple <TypeDeclaration, ITypeInfo> >(); NestedTypes.Add(new Tuple <TypeDeclaration, ITypeInfo>(typeDeclaration, CurrentType)); return; } ValidateNamespace(typeDeclaration); var rr = Resolver.ResolveNode(typeDeclaration); var fullName = rr.Type.ReflectionName; var partialType = Types.FirstOrDefault(t => t.Key == fullName); var add = true; var ignored = IgnoredTypes.Contains(fullName); var external = HasExternal(typeDeclaration); if (!external) { var resolveResult = Resolver.ResolveNode(typeDeclaration); if (resolveResult != null && resolveResult.Type != null) { var def = resolveResult.Type.GetDefinition(); external = def != null && (Validator.IsTypeFromH5Core(def.FullName) || def.ParentAssembly.AssemblyAttributes.Any(a => a.AttributeType.FullName == "H5.ExternalAttribute")); } } if ((external || ignored || IsNonScriptable(typeDeclaration)) && !IsObjectLiteral(typeDeclaration)) { if (partialType != null) { Types.Remove(partialType); } if (!ignored) { IgnoredTypes.Add(fullName); } return; } if (partialType == null) { ITypeInfo parentTypeInfo = null; var parentTypeDeclaration = typeDeclaration.GetParent <TypeDeclaration>(); if (parentTypeDeclaration != null) { var rr1 = Resolver.ResolveNode(parentTypeDeclaration); var parentName = rr1.Type.ReflectionName; parentTypeInfo = Types.FirstOrDefault(t => t.Key == parentName); } CurrentType = new TypeInfo() { Key = rr.Type.ReflectionName, TypeDeclaration = typeDeclaration, ParentType = parentTypeInfo, Name = typeDeclaration.Name, ClassType = typeDeclaration.ClassType, Namespace = Namespace, IsEnum = typeDeclaration.ClassType == ClassType.Enum, IsStatic = typeDeclaration.ClassType == ClassType.Enum || typeDeclaration.HasModifier(Modifiers.Static), IsObjectLiteral = IsObjectLiteral(typeDeclaration), Type = rr.Type }; } else { CurrentType = partialType; CurrentType.PartialTypeDeclarations.Add(typeDeclaration); add = false; } if (typeDeclaration.ClassType != ClassType.Interface) { typeDeclaration.AcceptChildren(this); } else { typeDeclaration.AcceptChildren(this); } if (add) { Types.Add(CurrentType); } if (typeDeclaration.ClassType != ClassType.Interface) { AddMissingAliases(typeDeclaration); } CurrentType = null; while (NestedTypes != null && NestedTypes.Count > 0) { var types = NestedTypes; NestedTypes = null; foreach (var nestedType in types) { VisitTypeDeclaration(nestedType.Item1); } } }
public void IgnoresCollectionTypes(Type type) { var ignoredTypes = IgnoredTypes.Create(null); Assert.AreEqual(true, ignoredTypes.IsIgnoringType(type)); }