/// <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));
}
