Est-ce que .NET AppDomains peut faire cela?

Question

J'ai passé des heures à lire sur AppDomains, mais je ne suis pas sûr qu'ils fonctionnent comme j'espère.

Si j'ai deux classes, Foo générique <T> à AppDomain # 1, Bar à AppDomain # 2:

App Domaine # 1 est l'application. App Domain # 2 est quelque chose comme un plugin, et peut être chargé et déchargé dynamiquement. AppDomain # 2 veut créer Foo <Barre> et l'utiliser. Foo <T> utilise beaucoup de classes dans AppDomain # 1 en interne.

Je ne veux pas AppDomain # 2 en utilisant objet foo avec réflexion, je veux qu'il utilise Foo <Bar> foo, avec tout le typage statique et la vitesse compilée qui va avec. Cela peut-il être fait en considérant que AppDomain # 1, contenant Foo <T>, n'est jamais déchargé?

Si tel est le cas, y a-t-il un accès distant lorsque vous utilisez Foo <Bar>?

Lorsque je décharge AppDomain # 2, le type Foo <Bar> est détruit?

éditer SO a dépouillé tous mes < >, les a rajoutés manuellement.

Answer 1

Vous confondez types et les objets dans votre question qui le rend difficile à répondre. Le code dans un AD n'a aucun problème à utiliser des types qui sont également utilisés dans d'autres AD, il charge simplement l'assemblage. Mais un AD a son propre tas de garbage collecté, vous ne pouvez pas référencer directement les objets qui vivent dans une autre AD. Ils doivent être sérialisés sur la limite AD. Oui, Remoting à travers un IpcChannel le fera.

Answer 2

Si vous souhaitez accéder à des objets traversent ces objets application Domaines doivent hériter de MarshalByRefObject; Dans un tel scénario, vous finirez avec un proxy à l'objet réel. De cette façon, il est possible de décharger le domaine d'application en toute sécurité (si vous essayez d'appeler le proxy, une exception sera levée).

Je suppose que ce que vous essayez d'accomplir est quelque chose comme:

using System; 
using System.Reflection; 

namespace TestAppDomain 
{ 
class Program 
{ 
    static void Main(string[] args) 
    { 
     AppDomain pluginsAppDomain = AppDomain.CreateDomain("Plugins"); 

     Foo foo = new Foo(); 
     pluginsAppDomain.SetData("Foo", foo); 

     Bar bar= (Bar) pluginsAppDomain.CreateInstanceAndUnwrap(Assembly.GetEntryAssembly().FullName, typeof (Bar).FullName); 
     bar.UseIt(); 

     AppDomain.Unload(pluginsAppDomain); 
     foo.SaySomething(); 
    } 
} 

class Bar : MarshalByRefObject 
{ 
    public void UseIt() 
    { 
     Console.WriteLine("Current AppDomain: {0}", AppDomain.CurrentDomain.FriendlyName); 
     Foo foo = (Foo) AppDomain.CurrentDomain.GetData("Foo"); 
     foo.SaySomething(); 
    } 
} 

class Foo : MarshalByRefObject 
{ 
    public void SaySomething() 
    { 
     Console.WriteLine("Something from AppDomain: {0}", AppDomain.CurrentDomain.FriendlyName); 
    } 
} 
} 

Si vos types sont définis dans différents ensembles (ce qui est probable), vous définissez probablement une interface (dans un ensemble commun) et faire les types implémenter cette interface.

Espérons que cela aide.