Ho to get custom attributes from an assembly that is not (really) loaded

Question

We all know that the assembly can be queried for attributes using the GetCustomAttributes method. I want to use this to identify an extension module for my application. However, to avoid loading every assembly I prefer a defensive approach:

1. using Assembly.ReflectionOnlyLoadFrom to get more details about an assembly (has it my ModuleAttribute?)

2. if the ModuleAttribute is found, I will finally load it using Assembly.LoadFrom

Unfortunately it seems that there is no way to get the attributes from an assembly, that is loaded into the reflection-only context:

myAssembly.GetCustomAttributes(typeof(ModuleAttribute), false)

fails with an InvalidOperationException ("It is illegal to reflect on the custom attributes of a Type loaded via ReflectionOnlyGetType") and

CustomAttributeData.GetCustomAttributes(myAssembly)

fails with ReflectionTypeLoadException because of dependant assemblies not being loaded.

So how to get the attributes without

1. polluting my application domain with useless (maybe harmful) types by calling Assembly.LoadFrom
2. the need to load all referenced assemblies
3. the need for separate application domains (gave it a short try, smelled like even more PITA)

?

Answer 1

If I were you I'd cache assembly metadata in, for instance, XML files. Using this approach you completely eliminate a need to load anything. And you can store even information, to calculate which you need to perform a time-consuming operation.

You can have XML files pregenerated or generated on-the-fly by scanning all existing assemblies.

Answer 2

Have you looked at the microsoft AddIn Framework.

It allows for loading modules (AddIns) in the different app domains and processes, and querying by interface on specific attribute data.

It might not be what you want, but could be worth a look.

http://msdn.microsoft.com/en-us/library/bb384200.aspx

string[] warnings = AddInStore.Update(Environment.CurrentDirectory);
Collection<AddInToken> tokens = AddInStore.FindAddIns(typeof(YourType), Environment.CurrentDirectory)

AddInEnvironment addInEnvironment = new AddInEnvironment(AppDomain.CurrentDomain);
YourType module = tokens[0].Activate<YourType>(addInEnvironment);

And with a bit of LINQ you can query it

AddInToken myToken = tokens.FirstOrDefault(currentAddInToken => currentAddInToken.Name.Equals(moduleName))

Answer 3

After checking all answers and doing some more research, it seems that there is simply no way to do what I want: check if an assembly is a valid extension module before loading it into the application domain.

Either I have to load the assembly that should be inspected into another application domain, inspect it there and when it succeeds load it again into my current application domain or I need to store metadata of the assembly outside the assembly itself and trust this metadata. Option one is not possible because of architectural restrictions, option two just shifts the problem but not solves it.

Probably the best alternative is to use the Managed Extensibility Framework, but this is unfortunately not that easy in the current setup.

I end up with trusting that there is nothing "bad" in the modules directory and loading everything (with some checks for not exceeding a maximum file size and not being loaded already).

Nevertheless, thank you for your ideas.