We make shipped assemblies: we interact between domains without marshalling

Link to the project in GitHub: DotNetEx

On multiple resources, a question is asked from time to time. Is it possible to make shipped assemblies from the current domain? So, to use and "come on, bye!"? Everywhere and always the answer that was given is “no”. After all, the only thing that can be unloaded is the domain. Accordingly, if you want to organize the shipment, the assembly must be placed in the domain, and the interaction between the domains through serializable types should be established. And this is a very slow interaction. And we say so. Can. With nuances. We will also upload to a separate domain. But we will cancel serialization when calling methods between domains .
')
Questions that we will solve:

• Creating a domain with the ability to return the object from the domain to the parent
• Unloading assembly

Solution to the problem

So, as always, we will solve problems as they appear:

• As we have already found out in previous articles, memory is common and does not depend on domains. And this means that if you find a way to transfer a pointer to an object, you can learn to transfer objects between domains without serialization.
  
  Take some general type. For simplicity, let's take the type from mscorlib: IServiceProvider.
  Create an assembly that we are going to make friends with the possibility of shipment:
  

  public class Implementation : IServiceProvider { public override string ToString() { return "Awesome"; } public object GetService(Type serviceType) { return new object(); } } 

  
  
• Now we will write a class that will create a domain and be able to create instances of classes in this domain:
  

    public class AppDomainRunner : MarshalByRefObject, IDisposable { private AppDomain appDomain; private Assembly assembly; private AppDomainRunner remoteRunner; private void LoadAssembly(string assemblyPath) { assembly = Assembly.LoadFile(assemblyPath); } public AppDomainRunner(string assemblyPath) { // make appdomain appDomain = AppDomain.CreateDomain("PseudoIsolated", null, new AppDomainSetup { ApplicationBase = AppDomain.CurrentDomain.BaseDirectory }); // create object instance remoteRunner = (AppDomainRunner)appDomain.CreateInstanceAndUnwrap(typeof(AppDomainRunner).Assembly.FullName, typeof(AppDomainRunner).FullName); remoteRunner.LoadAssembly(assemblyPath); } public IntPtr CreateInstance(string typename) { return remoteRunner.CreateInstanceImpl(typename); } private IntPtr CreateInstanceImpl(string typename) { return EntityPtr.ToPointer(assembly.CreateInstance(typename)); } public void Dispose() { assembly = null; remoteRunner = null; AppDomain.Unload(appDomain); } 

• Now we will write the class for the IoC container:
  

    public class Container : IDisposable { private AppDomainRunner appdomain; private Dictionary<Type, Object> instances = new Dictionary<Type, object>(); public Container(string assemblyName) { appdomain = new AppDomainRunner(Path.Combine(System.Environment.CurrentDirectory, assemblyName)); } public void Register<TInterface>(string fullTypeName) { instances.Add(typeof (TInterface), EntityPtr.ToInstance<Object>(appdomain.CreateInstance(fullTypeName))); } public TInterface Resolve<TInterface>() { return (TInterface)(instances[typeof (TInterface)]); } public void Dispose() { appdomain.Dispose(); } } 

  
  And the last - using code:
  

    static void Main(string[] args) { using (var container = new Container("library.dll")) { container.Register<IServiceProvider>("IocLibrary.Implementation"); var serviceProvider = container.Resolve<IServiceProvider>(); Console.WriteLine("calling method without proxy: {0}", serviceProvider); Console.WriteLine("Current domain assemblies: {0}", string.Join(", ", AppDomain.CurrentDomain.GetAssemblies().Select(asm => asm.GetName().Name).ToArray())); } } 

  
  

findings

As they say, you cannot make shipped types, but if you want, you can. You just need to somehow pass between the domains a pointer to the object and they can be used on equal terms.
There is only one minus of the method: we have no right to use objects after unloading the assembly. This is a minus for one simple reason: it is necessary to additionally control the order of shipment and the loss of references to objects. But, in general, this is not a problem =)