Comment charger un assembly dans AppDomain avec toutes les références de manière récursive?

Je veux charger un nouvel AppDomainassemblage qui a un arbre de références complexe (MyDll.dll -> Microsoft.Office.Interop.Excel.dll -> Microsoft.Vbe.Interop.dll -> Office.dll -> stdole.dll)

D'après ce que j'ai compris, lorsqu'un assemblage est en cours de chargement AppDomain, ses références ne sont pas chargées automatiquement et je dois les charger manuellement. Alors quand je fais:

string dir = @"SomePath"; // different from AppDomain.CurrentDomain.BaseDirectory
string path = System.IO.Path.Combine(dir, "MyDll.dll");

AppDomainSetup setup = AppDomain.CurrentDomain.SetupInformation;
setup.ApplicationBase = dir;
AppDomain domain = AppDomain.CreateDomain("SomeAppDomain", null, setup);

domain.Load(AssemblyName.GetAssemblyName(path));

et obtenu FileNotFoundException:

Impossible de charger le fichier ou l'assembly 'MyDll, Version = 1.0.0.0, Culture = neutral, PublicKeyToken = null' ou l'une de ses dépendances. Le système ne peut pas trouver le fichier spécifié.

Je pense que l'élément clé est l' une de ses dépendances .

Ok, je fais la prochaine avant domain.Load(AssemblyName.GetAssemblyName(path));

foreach (AssemblyName refAsmName in Assembly.ReflectionOnlyLoadFrom(path).GetReferencedAssemblies())
{
    domain.Load(refAsmName);
}

Mais obtenu à FileNotFoundExceptionnouveau, sur un autre assemblage (référencé).

Comment charger toutes les références de manière récursive?

Dois-je créer une arborescence de références avant de charger l'assembly racine? Comment obtenir les références d'un assemblage sans le charger?

Vous devez appeler CreateInstanceAndUnwrapavant que votre objet proxy ne s'exécute dans le domaine d'application étranger.

 class Program
{
    static void Main(string[] args)
    {
        AppDomainSetup domaininfo = new AppDomainSetup();
        domaininfo.ApplicationBase = System.Environment.CurrentDirectory;
        Evidence adevidence = AppDomain.CurrentDomain.Evidence;
        AppDomain domain = AppDomain.CreateDomain("MyDomain", adevidence, domaininfo);

        Type type = typeof(Proxy);
        var value = (Proxy)domain.CreateInstanceAndUnwrap(
            type.Assembly.FullName,
            type.FullName);

        var assembly = value.GetAssembly(args[0]);
        // AppDomain.Unload(domain);
    }
}

public class Proxy : MarshalByRefObject
{
    public Assembly GetAssembly(string assemblyPath)
    {
        try
        {
            return Assembly.LoadFile(assemblyPath);
        }
        catch (Exception)
        {
            return null;
            // throw new InvalidOperationException(ex);
        }
    }
}

Notez également que si vous utilisez, LoadFromvous obtiendrez probablement une FileNotFoundexception car le résolveur d'assembly tentera de trouver l'assembly que vous chargez dans le GAC ou dans le dossier bin de l'application actuelle. Utilisez à la place LoadFilepour charger un fichier d'assemblage arbitraire - mais notez que si vous faites cela, vous devrez charger toutes les dépendances vous-même.

http://support.microsoft.com/kb/837908/en-us

Version C #:

Créez une classe de modérateur et héritez-en de MarshalByRefObject:

class ProxyDomain : MarshalByRefObject
{
    public Assembly GetAssembly(string assemblyPath)
    {
        try
        {
            return Assembly.LoadFrom(assemblyPath);
        }
        catch (Exception ex)
        {
            throw new InvalidOperationException(ex.Message);
        }
    }
}

appel depuis le site client

ProxyDomain pd = new ProxyDomain();
Assembly assembly = pd.GetAssembly(assemblyFilePath);

Une fois que vous avez renvoyé l'instance d'assembly au domaine de l'appelant, le domaine de l'appelant essaiera de la charger! C'est pourquoi vous obtenez l'exception. Cela se produit dans votre dernière ligne de code:

domain.Load(AssemblyName.GetAssemblyName(path));

Ainsi, tout ce que vous voulez faire avec l'assembly doit être fait dans une classe proxy - une classe qui hérite de MarshalByRefObject .

Tenez compte du fait que le domaine de l'appelant et le nouveau domaine créé doivent tous deux avoir accès à l'assembly de classe proxy. Si votre problème n'est pas trop compliqué, envisagez de laisser le dossier ApplicationBase inchangé, il sera donc identique au dossier du domaine de l'appelant (le nouveau domaine ne chargera que les assemblys dont il a besoin).

En code simple:

public void DoStuffInOtherDomain()
{
    const string assemblyPath = @"[AsmPath]";
    var newDomain = AppDomain.CreateDomain("newDomain");
    var asmLoaderProxy = (ProxyDomain)newDomain.CreateInstanceAndUnwrap(Assembly.GetExecutingAssembly().FullName, typeof(ProxyDomain).FullName);

    asmLoaderProxy.GetAssembly(assemblyPath);
}

class ProxyDomain : MarshalByRefObject
{
    public void GetAssembly(string AssemblyPath)
    {
        try
        {
            Assembly.LoadFrom(AssemblyPath);
            //If you want to do anything further to that assembly, you need to do it here.
        }
        catch (Exception ex)
        {
            throw new InvalidOperationException(ex.Message, ex);
        }
    }
}

Si vous devez charger les assemblys à partir d'un dossier différent de votre dossier de domaine d'application actuel, créez le nouveau domaine d'application avec un dossier de chemin de recherche de DLL spécifique.

Par exemple, la ligne de création de domaine d'application du code ci-dessus doit être remplacée par:

var dllsSearchPath = @"[dlls search path for new app domain]";
AppDomain newDomain = AppDomain.CreateDomain("newDomain", new Evidence(), dllsSearchPath, "", true);

De cette façon, toutes les dll seront automatiquement résolues à partir de dllsSearchPath.

Sur votre nouveau AppDomain, essayez de définir un gestionnaire d'événements AssemblyResolve . Cet événement est appelé lorsqu'une dépendance est manquante.

Vous devez gérer les événements AppDomain.AssemblyResolve ou AppDomain.ReflectionOnlyAssemblyResolve (selon la charge que vous effectuez) au cas où l'assembly référencé ne se trouve pas dans le GAC ou sur le chemin de détection du CLR.

AppDomain.AssemblyResolve

AppDomain.ReflectionOnlyAssemblyResolve

Il m'a fallu un certain temps pour comprendre la réponse de @ user1996230, j'ai donc décidé de fournir un exemple plus explicite. Dans l'exemple ci-dessous, je crée un proxy pour un objet chargé dans un autre AppDomain et j'appelle une méthode sur cet objet à partir d'un autre domaine.

class ProxyObject : MarshalByRefObject
{
    private Type _type;
    private Object _object;

    public void InstantiateObject(string AssemblyPath, string typeName, object[] args)
    {
        assembly = Assembly.LoadFrom(AppDomain.CurrentDomain.BaseDirectory + AssemblyPath); //LoadFrom loads dependent DLLs (assuming they are in the app domain's base directory
        _type = assembly.GetType(typeName);
        _object = Activator.CreateInstance(_type, args); ;
    }

    public void InvokeMethod(string methodName, object[] args)
    {
        var methodinfo = _type.GetMethod(methodName);
        methodinfo.Invoke(_object, args);
    }
}

static void Main(string[] args)
{
    AppDomainSetup setup = new AppDomainSetup();
    setup.ApplicationBase = @"SomePathWithDLLs";
    AppDomain domain = AppDomain.CreateDomain("MyDomain", null, setup);
    ProxyObject proxyObject = (ProxyObject)domain.CreateInstanceFromAndUnwrap(typeof(ProxyObject).Assembly.Location,"ProxyObject");
    proxyObject.InstantiateObject("SomeDLL","SomeType", new object[] { "someArgs});
    proxyObject.InvokeMethod("foo",new object[] { "bar"});
}

La clé est l'événement AssemblyResolve déclenché par AppDomain.

[STAThread]
static void Main(string[] args)
{
    fileDialog.ShowDialog();
    string fileName = fileDialog.FileName;
    if (string.IsNullOrEmpty(fileName) == false)
    {
        AppDomain.CurrentDomain.AssemblyResolve += CurrentDomain_AssemblyResolve;
        if (Directory.Exists(@"c:\Provisioning\") == false)
            Directory.CreateDirectory(@"c:\Provisioning\");

        assemblyDirectory = Path.GetDirectoryName(fileName);
        Assembly loadedAssembly = Assembly.LoadFile(fileName);

        List<Type> assemblyTypes = loadedAssembly.GetTypes().ToList<Type>();

        foreach (var type in assemblyTypes)
        {
            if (type.IsInterface == false)
            {
                StreamWriter jsonFile = File.CreateText(string.Format(@"c:\Provisioning\{0}.json", type.Name));
                JavaScriptSerializer serializer = new JavaScriptSerializer();
                jsonFile.WriteLine(serializer.Serialize(Activator.CreateInstance(type)));
                jsonFile.Close();
            }
        }
    }
}

static Assembly CurrentDomain_AssemblyResolve(object sender, ResolveEventArgs args)
{
    string[] tokens = args.Name.Split(",".ToCharArray());
    System.Diagnostics.Debug.WriteLine("Resolving : " + args.Name);
    return Assembly.LoadFile(Path.Combine(new string[]{assemblyDirectory,tokens[0]+ ".dll"}));
}

J'ai dû faire cela plusieurs fois et j'ai recherché de nombreuses solutions différentes.

La solution que je trouve la plus élégante et la plus facile à réaliser peut être mise en œuvre telle quelle.

1. Créez un projet que vous pouvez créer une interface simple

l'interface contiendra les signatures de tous les membres que vous souhaitez appeler.

public interface IExampleProxy
{
    string HelloWorld( string name );
}

Il est important de garder ce projet propre et léger. C'est un projet que les deux AppDomainpeuvent référencer et qui nous permettra de ne pas référencer le que Assemblynous souhaitons charger dans un domaine séparé de notre assembly client.

2. Créez maintenant un projet contenant le code que vous souhaitez charger séparément AppDomain.

Ce projet comme avec le projet client référencera le proj proxy et vous implémenterez l'interface.

public interface Example : MarshalByRefObject, IExampleProxy
{
    public string HelloWorld( string name )
    {
        return $"Hello '{ name }'";
    }
}

3. Ensuite, dans le projet client, chargez le code dans un autre AppDomain.

Alors, maintenant, nous créons un nouveau AppDomain. Peut spécifier l'emplacement de base des références d'assemblage. Le sondage vérifiera les assemblys dépendants dans GAC et dans le répertoire actuel et la AppDomainlocalisation de base.

// set up domain and create
AppDomainSetup domaininfo = new AppDomainSetup
{
    ApplicationBase = System.Environment.CurrentDirectory
};

Evidence adevidence = AppDomain.CurrentDomain.Evidence;

AppDomain exampleDomain = AppDomain.CreateDomain("Example", adevidence, domaininfo);

// assembly ant data names
var assemblyName = "<AssemblyName>, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null|<keyIfSigned>";
var exampleTypeName = "Example";

// Optional - get a reflection only assembly type reference
var @type = Assembly.ReflectionOnlyLoad( assemblyName ).GetType( exampleTypeName ); 

// create a instance of the `Example` and assign to proxy type variable
IExampleProxy proxy= ( IExampleProxy )exampleDomain.CreateInstanceAndUnwrap( assemblyName, exampleTypeName );

// Optional - if you got a type ref
IExampleProxy proxy= ( IExampleProxy )exampleDomain.CreateInstanceAndUnwrap( @type.Assembly.Name, @type.Name );    

// call any members you wish
var stringFromOtherAd = proxy.HelloWorld( "Tommy" );

// unload the `AppDomain`
AppDomain.Unload( exampleDomain );

si vous en avez besoin, il existe une multitude de façons différentes de charger un assemblage. Vous pouvez utiliser une méthode différente avec cette solution. Si vous avez le nom qualifié d'assembly, j'aime utiliser le CreateInstanceAndUnwrapcar il charge les octets de l'assembly, puis instancie votre type pour vous et retourne un objectque vous pouvez simplement convertir en votre type de proxy ou si vous ne le faites pas en code fortement typé, vous pouvez utilisez le runtime de langage dynamique et affectez l'objet retourné à une dynamicvariable typée, puis appelez simplement les membres directement dessus.

Voilà.

Cela permet de charger un assembly auquel votre projet client n'a pas de référence dans un fichier séparé AppDomainet d'appeler les membres dessus à partir du client.

Pour tester, j'aime utiliser la fenêtre Modules dans Visual Studio. Il vous montrera votre domaine d'assembly client et quels modules sont chargés dans ce domaine, ainsi que votre nouveau domaine d'application et quels assemblys ou modules sont chargés dans ce domaine.

La clé est de s'assurer que le code dérive MarshalByRefObjectou est sérialisable.

`MarshalByRefObject vous permettra de configurer la durée de vie du domaine dans lequel il se trouve. Exemple, disons que vous voulez que le domaine soit détruit si le proxy n'a pas été appelé dans 20 minutes.

J'espère que ça aide.