private static IEnumerable <Type> GetFilteredTypesFromAssembly(
     Assembly assembly,
     TypeOptionsAttribute filter)
 {
     return(GetVisibleTypesFromAssembly(assembly)
            .Where(type => type.IsVisible && FilterConstraintIsSatisfied(filter, type)));
 }
Ejemplo n.º 2
0
        private static bool FilterConstraintIsSatisfied(TypeOptionsAttribute filter, Type type)
        {
            if (filter == null)
            {
                return(true);
            }

            return(filter.MatchesRequirements(type));
        }
Ejemplo n.º 3
0
        public static List <Type> GetFilteredTypesFromAssemblies(
            IEnumerable <Assembly> assemblies,
            TypeOptionsAttribute filter)
        {
            var types = new List <Type>();

            foreach (var assembly in assemblies)
            {
                types.AddRange(GetFilteredTypesFromAssembly(assembly, filter));
            }

            return(types);
        }
        private static List <Type> GetFilteredTypesFromAssembly(Assembly assembly, TypeOptionsAttribute filter)
        {
            var visibleTypes      = GetVisibleTypesFromAssembly(assembly);
            var filteredTypes     = new List <Type>();
            int visibleTypesCount = visibleTypes.Count;

            for (int i = 0; i < visibleTypesCount; i++)
            {
                Type type = visibleTypes[i];

                if (FilterConstraintIsSatisfied(filter, type))
                {
                    filteredTypes.Add(type);
                }
            }

            return(filteredTypes);
        }
Ejemplo n.º 5
0
        public static List <Type> GetFilteredTypesFromAssemblies(
            List <Assembly> assemblies,
            TypeOptionsAttribute filter)
        {
            int assembliesCount = assemblies.Count;

            var types = new List <Type>(assembliesCount * 20);

            for (int i = 0; i < assembliesCount; i++)
            {
                var filteredTypes      = GetFilteredTypesFromAssembly(assemblies[i], filter);
                int filteredTypesCount = filteredTypes.Count;

                for (int j = 0; j < filteredTypesCount; j++)
                {
                    types.Add(filteredTypes[j]);
                }
            }

            return(types);
        }
Ejemplo n.º 6
0
 public TypeDropdownDrawer(Type selectedType, TypeOptionsAttribute attribute, Type declaringType)
 {
     _attribute     = attribute;
     _declaringType = declaringType;
     _selectedType  = selectedType;
 }
 public void BeforeEveryTest()
 {
     _attribute = new TypeOptionsAttribute();
 }
 public TypeDropDownDrawer(string typeName, TypeOptionsAttribute constraints, Type declaringType)
 {
     _selectedType  = CachedTypeReference.GetType(typeName);
     _constraints   = constraints;
     _declaringType = declaringType;
 }