Loading an assembly and applying a predicate by type in another application

Question

Please read the whole question. I have a unique situation with several limitations that I would like to solve.

In my code, I have an expression tree that is compiled into Predicate<System.Type> . My goal is to load the assembly without blocking it (it will be displayed on the project assembly, constantly rebuild), apply this predicate in the list of its types and return a list of resulting name types:

 // this is what I need: return assembly.GetTypes().Where(t => predicate(t)).Select(t => t.FullName); 

This assembly must be loaded in another appdomain, because I want to unload it as soon as I get the information I need.

That's where it gets complicated. There are several issues that I am facing:

If I load the assembly into another appdomain and simply return an array of all its types so that I can apply the predicate in my main application, as soon as the types are redirected back to my main appdomain, I get a FileNotFoundException , stating that this assembly was not found. This causes the assembly to load only in another appdomain that I created. Downloading it also basically appdomain will defeat the goal.

If, as an alternative, I try to pass the predicate to another appdomain to apply it there and return an array of strings (full type name), I get a SerializationException: "Cannot serialize delegates over unmanaged function pointers, dynamic methods or methods outside the delegate creator assembly." because a predicate is a dynamic method (compiled from an expression tree).

Loading into the primary appdomain would not have any of these problems, but since it is not possible to unload the downloaded assembly without unloading the entire application, as soon as the assembly changes (after rebuilding), any attempt to load the assembly using the same name will throw an exception.

Context:
I am creating a plugin for ReSharper called Agent Mulder . The idea of ​​the plugin is to analyze the registration of the DI / IoC Container in your solution and help ReSharper figure out the use of types registered through the DI container (you can watch a short video on how it works here ).

For the most part, analysis of container registration is simple - I only need to find enough information to find out which specific types are affected. In this example with Castle Windsor: Component.For<IFoo>().ImplementedBy<Foo>() resulting type is obvious, so AllTypes.FromThisAssembly().BasedOn<IFoo>() - gives me enough information to indicate specific types, that will be affected by this line. However, consider this registration at Castle Windsor:

 container.Register(Classes .FromAssemblyInDirectory(new AssemblyFilter(".").FilterByName(an => an.Name.StartsWith("Ploeh.Samples.Booking"))) .Where(t => !(t.IsGenericType && t.GetGenericTypeDefinition() == typeof(Dispatcher<>))) .WithServiceAllInterfaces()); 

( source )

Here the information depends on the predicate, which will be evaluated only at runtime.

Since all I can do is statically analyze this, I have in my hand a representation of the ReSharper AST (called PSI in ReSharper) lambda expressions from the Where clause. I can convert this AST to a LINQ expression tree and then compile it into a delegate.

My idea was to load the output assembly (defined by the FromAssembly* descriptor) using reflection and apply this delegate to the assembly types to get the type names (I only need the names). This will need to be reevaluated every time the assembly changes (at the moment I'm not worried about performance).

In conclusion, if someone cannot recommend a better way to determine the types affected by the predicate, I would like to know how to do this with reflection (unfortunately, I did not consider other metadata readers, because I would have to somehow convert AST lambda expression to predicate of another data type, and I don't know if 1 to 1 conversion exists).

Thanks for reading. This question will have 500 points when it becomes available.

Answer 1

You need to load the assembly to get Type instances, so a separate AppDomain seems to be the right solution.

So you need to get the Expression predicate in AppDomain , which means you have to serialize / deserialize it.

This requirement is becoming more frequent for various reasons. I looked at this because I wanted to compress Linq to Entities expressions through the WCF service.

Fortunately, there are several existing implementations.

I found this: CodePlex - Expression Tree Serializer

---

I just tested it with Types and it works:

 Expression<Func<Type,bool>> predicate = t => ( !t.IsGenericType && t.Name == "Int32" ); var s = new ExpressionSerialization.ExpressionSerializer(); var xml = s.Serialize( predicate ); var p = s.Deserialize( xml ) as Expression<Func<Type, bool>>; var f = p.Compile(); Console.WriteLine( "Int32: " + f( typeof( int ) ) ); // true Console.WriteLine( "String: " + f( typeof( string ) ) ); // false 

Answer 2

Allows you to wrap a predicate instance of a delegate using an MBR object; a parameter of type Type will be perfectly removed from another domain:

 class RemotablePredicate<T> : MarshalByRefObject { readonly Predicate<T> predicate; public RemotablePredicate(Predicate<T> predicate) { this.predicate = predicate; } public bool Accepts(T arg) { return predicate(arg); } } 

Create some type to load, examine the assembly, and return the results to the main domain:

 class AssemblyExplorer : MarshalByRefObject { public string[] GetTypesByPredicate( string assemblyPath, RemotablePredicate<Type> predicate) { // MS reflection api reqires all dependencies here var bytes = File.ReadAllBytes(assemblyPath); var assembly = Assembly.ReflectionOnlyLoad(bytes); var types = new List<string>(); foreach (var type in assembly.GetTypes()) if (predicate.Accepts(type)) types.Add(type.FullName); return types.ToArray(); } } 

To do it all:

 using System; using System.Collections.Generic; using System.IO; using System.Linq.Expressions; using System.Reflection; class Program { static void Main() { var fooDomain = AppDomain.CreateDomain("Foo"); Expression<Predicate<Type>> expr = t => t.IsValueType; var compiledPredicate = expr.Compile(); var remotablePredicate = new RemotablePredicate<Type>(compiledPredicate); var explorerType = typeof(AssemblyExplorer); var explorerInstance = (AssemblyExplorer) fooDomain .CreateInstanceAndUnwrap(explorerType.Assembly.FullName, explorerType.FullName); var types = explorerInstance.GetTypesByPredicate( "JetBrains.Annotations.dll", remotablePredicate); Console.WriteLine("Matched types: {0}", types.Length); foreach (var type in types) Console.WriteLine(" {0}", type); } }