Como carregar um assembly para AppDomain com todas as referências recursivamente?

Quero carregar em um novo AppDomainassembly que possui uma árvore de referências complexa (MyDll.dll -> Microsoft.Office.Interop.Excel.dll -> Microsoft.Vbe.Interop.dll -> Office.dll -> stdole.dll)

Pelo que eu entendi, quando um assembly está sendo carregado AppDomain, suas referências não são carregadas automaticamente, e eu tenho que carregá-las manualmente. Então, quando eu faço:

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));

e obteve FileNotFoundException:

Não foi possível carregar o arquivo ou assembly 'MyDll, Version = 1.0.0.0, Culture = neutral, PublicKeyToken = null' ou uma de suas dependências. O sistema não pode encontrar o arquivo especificado.

Acho que a parte principal é uma de suas dependências .

Ok, eu faço a seguir antes domain.Load(AssemblyName.GetAssemblyName(path));

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

Mas consegui FileNotFoundExceptionnovamente, em outra montagem (referenciada).

Como carregar todas as referências recursivamente?

Preciso criar uma árvore de referências antes de carregar o assembly raiz? Como obter as referências de um assembly sem carregá-lo?

Você precisa invocar CreateInstanceAndUnwrapantes que seu objeto proxy seja executado no domínio de aplicativo externo.

 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);
        }
    }
}

Além disso, observe que, se você usar, LoadFromprovavelmente obterá uma FileNotFoundexceção porque o resolvedor de Assembly tentará localizar o assembly que você está carregando no GAC ou na pasta bin do aplicativo atual. Use LoadFilepara carregar um arquivo de montagem arbitrário em vez disso - mas observe que se você fizer isso, você mesmo precisará carregar quaisquer dependências.

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

Versão C #:

Crie uma classe de moderador e herde-a de MarshalByRefObject:

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

chamada do site do cliente

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

Depois de passar a instância do assembly de volta para o domínio do chamador, o domínio do chamador tentará carregá-la! É por isso que você obtém a exceção. Isso acontece na sua última linha de código:

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

Portanto, tudo o que você deseja fazer com a montagem, deve ser feito em uma classe proxy - uma classe que herda MarshalByRefObject .

Considere que o domínio do chamador e o novo domínio criado devem ter acesso ao assembly da classe de proxy. Se o seu problema não for muito complicado, considere deixar a pasta ApplicationBase inalterada, para que seja igual à pasta do domínio do chamador (o novo domínio carregará apenas os assemblies necessários).

Em código simples:

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);
        }
    }
}

Se você precisar carregar os assemblies de uma pasta diferente da pasta de domínio de aplicativo atual, crie o novo domínio de aplicativo com uma pasta de caminho de pesquisa dlls específica.

Por exemplo, a linha de criação de domínio de aplicativo do código acima deve ser substituída por:

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

Dessa forma, todas as dlls serão resolvidas automaticamente a partir de dllsSearchPath.

Em seu novo AppDomain, tente definir um manipulador de eventos AssemblyResolve . Esse evento é chamado quando uma dependência está faltando.

Você precisa manipular os eventos AppDomain.AssemblyResolve ou AppDomain.ReflectionOnlyAssemblyResolve (dependendo de qual carga você está fazendo) no caso de o assembly referenciado não estar no GAC ou no caminho de sondagem do CLR.

AppDomain.AssemblyResolve

AppDomain.ReflectionOnlyAssemblyResolve

Demorei um pouco para entender a resposta de @ user1996230, então decidi fornecer um exemplo mais explícito. No exemplo a seguir, faço um proxy para um objeto carregado em outro AppDomain e chamo um método nesse objeto de outro domínio.

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"});
}

A chave é o evento AssemblyResolve gerado pelo 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"}));
}

Eu tive que fazer isso várias vezes e pesquisei muitas soluções diferentes.

A solução que acho mais elegante e fácil de realizar pode ser implementada como tal.

1. Crie um projeto em que você pode criar uma interface simples

a interface conterá assinaturas de todos os membros que você deseja chamar.

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

É importante manter este projeto limpo e leve. É um projeto que ambos AppDomainpodem fazer referência e nos permitirá não fazer referência ao domínio Assemblyque desejamos carregar em seprate de nosso assembly cliente.

2. Agora crie um projeto que tenha o código que deseja carregar separadamente AppDomain.

Este projeto, assim como o proj cliente, fará referência ao proj proxy e você implementará a interface.

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

3. Em seguida, no projeto do cliente, carregue o código em outro AppDomain .

Então, agora criamos um novo AppDomain. Pode especificar o local de base para referências de montagem. A investigação verificará os assemblies dependentes no GAC e no diretório atual e no AppDomainloc 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 );

se for necessário, existem várias maneiras diferentes de carregar uma montagem. Você pode usar uma maneira diferente com esta solução. Se você tiver o nome qualificado do assembly, eu gosto de usar o, CreateInstanceAndUnwrappois ele carrega os bytes do assembly e, em seguida, instancia o seu tipo para você e retorna um objectque você pode converter para o seu tipo de proxy ou, se não, para um código fortemente tipado, pode use o tempo de execução de linguagem dinâmica e atribua o objeto retornado a uma dynamicvariável digitada e, em seguida, chame os membros diretamente.

Aí está.

Isso permite carregar uma montagem que o projeto do seu cliente não tenha referência em uma AppDomain e chamar membros do cliente.

Para testar, gosto de usar a janela Módulos no Visual Studio. Ele mostrará seu domínio de assembly do cliente e quais módulos são carregados nesse domínio, bem como seu novo domínio de aplicativo e quais assemblies ou módulos são carregados nesse domínio.

A chave é certificar-se de que o código deriva MarshalByRefObject ou é serializável.

`MarshalByRefObject permitirá que você configure o tempo de vida do domínio em que está. Por exemplo, digamos que você deseja que o domínio seja destruído se o proxy não for chamado em 20 minutos.

Eu espero que isso ajude.