I think I have a solution thanks to the current post, and this and its accepted answer: AppDomain.Load () error with FileNotFoundException
First, I think you should use an interface instead of the base class for your handler. The interface must be declared in the base class, and then you use it only.
Solution : create a specific type in the general assembly, which inherits from MarshalByRefObject and implements your server interface. This particular type is a proxy that can be serialized / deserialized between AppDomains because your main application knows its definition. You no longer need to inherit from MarshalByRefObject in your ServerBase class.
// - MUST be serializable, and MUSNT'T use unknown types for main App [Serializable] public class Query { ... } public interface IServerBase { string Execute(Query q); } public abstract class ServerBase : IServerBase { public abstract string Execute(Query q); } // Our CUSTOM PROXY: the concrete type which will be known from main App [Serializable] public class ServerBaseProxy : MarshalByRefObject, IServerBase { private IServerBase _hostedServer; /// <summary> /// cstor with no parameters for deserialization /// </summary> public ServerBaseProxy () { } /// <summary> /// Internal constructor to use when you write "new ServerBaseProxy" /// </summary> /// <param name="name"></param> public ServerBaseProxy(IServerBase hostedServer) { _hostedServer = hostedServer; } public string Execute(Query q) { return(_hostedServer.Execute(q)); } }
Note : for sending and receiving data, each type declared in IServer must be serializable (for example: with the [Serializable] attribute)
Then you can use the method found in the previous link “ Loader Class ”. Here is my modified Loader class that creates a specific type in the general assembly and returns a proxy for each plugin:
/// <summary> /// Source: /questions/687073/appdomainload-fails-with-filenotfoundexception /// </summary> public class Loader : MarshalByRefObject { /// <summary> /// Load plugins /// </summary> /// <param name="assemblyName"></param> /// <returns></returns> public IPlugin[] LoadPlugins(string assemblyPath) { List<PluginProxy> proxyList = new List<PluginProxy>(); // a proxy could be transfered outsite AppDomain, but not the plugin itself ! https://stackoverflow.com/questions/4185816/how-to-pass-an-unknown-type-between-two-net-appdomains var assemb = Assembly.LoadFrom(assemblyPath); // use Assembly.Load if you want to use an Assembly name and not a path var types = from type in assemb.GetTypes() where typeof(IPlugin).IsAssignableFrom(type) select type; var instances = types.Select( v => (IPlugin)Activator.CreateInstance(v)).ToArray(); foreach (IPlugin instance in instances) { proxyList.Add(new PluginProxy(instance)); } return (proxyList.ToArray()); } }
Then in the main application , I also use the code "dedpichto" and "James Thurley" to create the AppDomain, initialize and call the Loader class. Then I can use my proxy server, because it was my plugin, because .NET creates a "transparent proxy" because of MarshalByRefObject :
/// <see cref="https://stackoverflow.com/questions/4185816/how-to-pass-an-unknown-type-between-two-net-appdomains"/> public class PlugInLoader { /// <summary> /// /questions/687073/appdomainload-fails-with-filenotfoundexception /// </summary> public void LoadPlugins(string pluginsDir) { // List all directories where plugins could be var privatePath = ""; var paths = new List<string>(); List<DirectoryInfo> dirs = new DirectoryInfo(pluginsDir).GetDirectories().ToList(); dirs.Add(new DirectoryInfo(pluginsDir)); foreach (DirectoryInfo d in dirs) privatePath += d.FullName + ";"; if (privatePath.Length > 1) privatePath = privatePath.Substring(0, privatePath.Length - 1); // Create AppDomain ! AppDomainSetup appDomainSetup = AppDomain.CurrentDomain.SetupInformation; appDomainSetup.PrivateBinPath = privatePath; Evidence evidence = AppDomain.CurrentDomain.Evidence; AppDomain sandbox = AppDomain.CreateDomain("sandbox_" + Guid.NewGuid(), evidence, appDomainSetup); try { // Create an instance of "Loader" class of the shared assembly, that is referenced in current main App sandbox.Load(typeof(Loader).Assembly.FullName); Loader loader = (Loader)Activator.CreateInstance( sandbox, typeof(Loader).Assembly.FullName, typeof(Loader).FullName, false, BindingFlags.Public | BindingFlags.Instance, null, null, null, null).Unwrap(); // Invoke loader in shared assembly to instanciate concrete types. As long as concrete types are unknown from here, they CANNOT be received by Serialization, so we use the concrete Proxy type. foreach (var d in dirs) { var files = d.GetFiles("*.dll"); foreach (var f in files) { // This array does not contains concrete real types, but concrete types of "my custom Proxy" which implements IPlugin. And here, we are outside their AppDomain, so "my custom Proxy" is under the form of a .NET "transparent proxy" (we can see in debug mode) generated my MarshalByRefObject. IPlugin[] plugins = loader.LoadPlugins(f.FullName); foreach (IPlugin plugin in plugins) { // The custom proxy methods can be invoked ! string n = plugin.Name.ToString(); PluginResult result = plugin.Execute(new PluginParameters(), new PluginQuery() { Arguments = "", Command = "ENUMERATE", QueryType = PluginQueryTypeEnum.Enumerate_Capabilities }); Debug.WriteLine(n); } } } } finally { AppDomain.Unload(sandbox); } } }
It is very difficult to find a working solution, but we can finally store instances of our specific proxy server types embedded in another AppDomain and use them as if they were available in the main application.
Hope this (huge answer) helps!