How enumerate all classes with custom class attribute?

Well, you would have to enumerate through all the classes in all the assemblies that are loaded into the current app domain. To do that, you would call the GetAssemblies method on the AppDomain instance for the current app domain.

From there, you would call GetExportedTypes (if you only want public types) or GetTypes on each Assembly to get the types that are contained in the assembly.

Then, you would call the GetCustomAttributes extension method on each Type instance, passing the type of the attribute you wish to find.

You can use LINQ to simplify this for you:

var typesWithMyAttribute =
    from a in AppDomain.CurrentDomain.GetAssemblies()
    from t in a.GetTypes()
    let attributes = t.GetCustomAttributes(typeof(HelpAttribute), true)
    where attributes != null && attributes.Length > 0
    select new { Type = t, Attributes = attributes.Cast<HelpAttribute>() };

The above query will get you each type with your attribute applied to it, along with the instance of the attribute(s) assigned to it.

Note that if you have a large number of assemblies loaded into your application domain, that operation could be expensive. You can use Parallel LINQ to reduce the time of the operation (at the cost of CPU cycles), like so:

var typesWithMyAttribute =
    // Note the AsParallel here, this will parallelize everything after.
    from a in AppDomain.CurrentDomain.GetAssemblies().AsParallel()
    from t in a.GetTypes()
    let attributes = t.GetCustomAttributes(typeof(HelpAttribute), true)
    where attributes != null && attributes.Length > 0
    select new { Type = t, Attributes = attributes.Cast<HelpAttribute>() };

Filtering it on a specific Assembly is simple:

Assembly assembly = ...;

var typesWithMyAttribute =
    from t in assembly.GetTypes()
    let attributes = t.GetCustomAttributes(typeof(HelpAttribute), true)
    where attributes != null && attributes.Length > 0
    select new { Type = t, Attributes = attributes.Cast<HelpAttribute>() };

And if the assembly has a large number of types in it, then you can use Parallel LINQ again:

Assembly assembly = ...;

var typesWithMyAttribute =
    // Partition on the type list initially.
    from t in assembly.GetTypes().AsParallel()
    let attributes = t.GetCustomAttributes(typeof(HelpAttribute), true)
    where attributes != null && attributes.Length > 0
    select new { Type = t, Attributes = attributes.Cast<HelpAttribute>() };

Other answers reference GetCustomAttributes. Adding this one as an example of using IsDefined

Assembly assembly = ...
var typesWithHelpAttribute = 
        from type in assembly.GetTypes()
        where type.IsDefined(typeof(HelpAttribute), false)
        select type;

As already stated, reflection is the way to go. If you are going to call this frequently, I highly suggest caching the results, as reflection, especially enumerating through every class, can be quite slow.

This is a snippet of my code that runs through all the types in all loaded assemblies:

// this is making the assumption that all assemblies we need are already loaded.
foreach (Assembly assembly in AppDomain.CurrentDomain.GetAssemblies()) 
{
    foreach (Type type in assembly.GetTypes())
    {
        var attribs = type.GetCustomAttributes(typeof(MyCustomAttribute), false);
        if (attribs != null && attribs.Length > 0)
        {
            // add to a cache.
        }
    }
}

This is a performance enhancement on top of the accepted solution. Iterating though all classes can be slow because there are so many. Sometimes you can filter out an entire assembly without looking at any of its types.

For example if you are looking for an attribute that you declared yourself, you don't expect any of the system DLLs to contain any types with that attribute. The Assembly.GlobalAssemblyCache property is a quick way to check for system DLLs. When I tried this on a real program I found I could skip 30,101 types and I only have to check 1,983 types.

Another way to filter is to use Assembly.ReferencedAssemblies. Presumably if you want classes with a specific attribute, and that attribute is defined in a specific assembly, then you only care about that assembly and other assemblies that reference it. In my tests this helped slightly more than checking the GlobalAssemblyCache property.

I combined both of these and got it even faster. The code below includes both filters.

        string definedIn = typeof(XmlDecoderAttribute).Assembly.GetName().Name;
        foreach (Assembly assembly in AppDomain.CurrentDomain.GetAssemblies())
            // Note that we have to call GetName().Name.  Just GetName() will not work.  The following
            // if statement never ran when I tried to compare the results of GetName().
            if ((!assembly.GlobalAssemblyCache) && ((assembly.GetName().Name == definedIn) || assembly.GetReferencedAssemblies().Any(a => a.Name == definedIn)))
                foreach (Type type in assembly.GetTypes())
                    if (type.GetCustomAttributes(typeof(XmlDecoderAttribute), true).Length > 0)

In case of the Portable .NET limitations, the following code should work:

    public static IEnumerable<TypeInfo> GetAtributedTypes( Assembly[] assemblies, 
                                                           Type attributeType )
    {
        var typesAttributed =
            from assembly in assemblies
            from type in assembly.DefinedTypes
            where type.IsDefined(attributeType, false)
            select type;
        return typesAttributed;
    }

or for a large number of assemblies using loop-state based yield return:

    public static IEnumerable<TypeInfo> GetAtributedTypes( Assembly[] assemblies, 
                                                           Type attributeType )
    {
        foreach (var assembly in assemblies)
        {
            foreach (var typeInfo in assembly.DefinedTypes)
            {
                if (typeInfo.IsDefined(attributeType, false))
                {
                    yield return typeInfo;
                }
            }
        }
    }

We can improve on Andrew's answer and convert the whole thing into one LINQ query.

    public static IEnumerable<Type> GetTypesWithHelpAttribute(Assembly assembly)
    {
        return assembly.GetTypes().Where(type => type.GetCustomAttributes(typeof(HelpAttribute), true).Length > 0);
    }

This is another version of the code provided by Trade-Ideas philip, I've condensed the code to linq, plugged it into a nice static function which you can just drop in the project.

Original: https://stackoverflow.com/a/41411243/4122889

I've also added AsParallel() - on my machine with enough cores etc, and with a 'normally' sized project (which is completely subjective), this was the fastest/

Without AsParallel() this took 1,5 seconds for about 200 results, and with it, it took about a couple milliseconds - therefore this seems the fastest to me.

Note that this skips the assemblies in the GAC.

private static IEnumerable<IEnumerable<T>> GetAllAttributesInAppDomain<T>()
{
    var definedIn = typeof(T).Assembly.GetName().Name;
    var assemblies = AppDomain.CurrentDomain.GetAssemblies();

   var res = assemblies.AsParallel()
        .Where(assembly => (!assembly.GlobalAssemblyCache) && ((assembly.GetName().Name == definedIn) ||
                                                               assembly.GetReferencedAssemblies()
                                                                   .Any(a => a.Name == definedIn))
            )
        .SelectMany(c => c.GetTypes())
        .Select(type => type.GetCustomAttributes(typeof(T), true)
            .Cast<T>()
            )
        .Where(c => c.Any());

    return res;
}

Usage:

var allAttributesInAppDomain = GetAllAttributesInAppDomain<ExportViewAttribute>();

Note if you have only 1 attribute per class, so not multiple, its easier to flatten the result from IEnumerable<IEnumerable<T>> to IEnumerable<T> like so:

var allAttributesInAppDomainFlattened = allAttributesInAppDomain.SelectMany(c => c);

Remember, this uses IEnumerable so call ToList() to actually run the function.

Further to Andrew's answer

Following are two extension methods that I use for such cases. these return an enumerable of Specific attributes on a type individually or on types in an assembly.

public static IEnumerable<TAttribute> GetAttributes<TAttribute>(this Type type) where TAttribute : Attribute
{
    if (type.GetCustomAttributes<TAttribute>(true).Any())
        foreach (var atribute in type.GetCustomAttributes<TAttribute>(true))
            yield return atribute;
}
public static IEnumerable<TAttribute> GetAttributes<TAttribute>(this Assembly assembly) where TAttribute : Attribute
{
    return assembly.GetTypes().Where(type => type.GetCustomAttributes<TAttribute>(true).Any()).SelectMany(x => GetAttributes<TAttribute>(x)).AsEnumerable();
}

these can be enhanced further to use expressions/predicates to return the desired result.

public static IEnumerable<TAttribute> GetAttributes<TAttribute>(this Type type, Func<TAttribute, bool> predicate) where TAttribute : Attribute
{
    if (type.GetCustomAttributes<TAttribute>(true).Any())
    {
        var attributes = type.GetCustomAttributes<TAttribute>(true).Where(predicate);
        foreach (var atribute in attributes) yield return atribute;
    }
}
public static IEnumerable<TAttribute> GetAttributes<TAttribute>(this Assembly assembly, Func<TAttribute, bool> predicate) where TAttribute : Attribute => assembly.GetTypes()
                                                                                                                                                                  .Where(type => type.GetCustomAttributes<TAttribute>(true).Any())
                                                                                                                                                                  .SelectMany(x => GetAttributes<TAttribute>(x))
                                                                                                                                                                  .Where(predicate)
                                                                                                                                                                  .AsEnumerable();

these above methods are generic and need the attribute type to fetch relevant attributes in a class. e.g.

    var modules = typeof(IEntity).Assembly.GetAttributes<Module>();
    var modules = typeof(MyClass).GetAttributes<Module>();