Jak załadować Assembly do AppDomain ze wszystkimi referencjami rekurencyjnie?

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

Wersja C#:

Stwórz klasę moderatora i Dziedzicz ją z MarshalByRefObject:

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

Call from client site

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

W nowej aplikacji AppDomain spróbuj ustawić obsługę zdarzenia AssemblyResolve . To zdarzenie zostanie wywołane, gdy brakuje zależności.

Po przekazaniu instancji assembly z powrotem do domeny wywołującej, domena wywołująca spróbuje ją załadować! Dlatego dostajesz wyjątek. Dzieje się tak w ostatniej linijce kodu:

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

Tak więc, cokolwiek chcesz zrobić z assembly, powinno być zrobione w klasie proxy - klasie, która dziedziczy MarshalByRefObject .

Policz, że domena wywołująca i nowo utworzona domena powinny mieć dostęp do zestawu klasy proxy. Jeśli twój problem nie jest zbyt skomplikowane, rozważ pozostawienie folderu ApplicationBase bez zmian, więc będzie on taki sam jak folder domeny wywołującej (nowa domena załaduje tylko potrzebne zespoły).

W kodzie prostym:

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

Jeśli musisz załadować zespoły z folderu innego niż bieżący folder domeny aplikacji, Utwórz nową domenę aplikacji z określonym folderem ścieżki wyszukiwania bibliotek DLL.

Na przykład linia tworzenia domeny aplikacji z powyższego kodu powinna zostać zastąpiona z:

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

W ten sposób wszystkie biblioteki DLL zostaną automatycznie rozwiązane z biblioteki DLL.

Musisz obsługiwać AppDomain.AssemblyResolve lub AppDomain.ReflectionOnlyAssemblyResolve zdarzenia (w zależności od obciążenia, które robisz) w przypadku, gdy odwołany zespół nie znajduje się w GAC lub na ścieżce sondowania CLR.

AppDomain.AssemblyResolve

AppDomain.ReflectionOnlyAssemblyResolve

Trochę mi zajęło zrozumienie odpowiedzi @user1996230, więc postanowiłem podać bardziej wyraźny przykład. W poniższym przykładzie robię proxy dla obiektu załadowanego w innym AppDomain i wywołuję metodę na tym obiekcie z innej domeny.

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

Kluczem Jest Zdarzenie AssemblyResolve wywołane przez 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"}));
}

[14]} musiałem to zrobić kilka razy i zbadałem wiele różnych rozwiązań.

Rozwiązanie, które znajduję w najbardziej eleganckim i łatwym do wykonania, może być wdrożone jako takie.

1. Tworzenie projektu, który można utworzyć prosty interfejs

interfejs będzie zawierał podpisy wszystkich członków, do których chcesz zadzwonić.

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

Its important to keep this project clean and lite. Jest to projekt, który zarówno AppDomain's może odwoływać się i pozwoli nam aby nie odwoływać się do Assembly, chcemy załadować domenę seprate z naszego zestawu klienta.

2. Teraz Utwórz projekt, który ma kod, który chcesz załadować w oddzielnym AppDomain.

ten projekt podobnie jak w przypadku Klienta proj będzie odwoływał się do proxy proj i zaimplementujesz interfejs.

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

3. Następnie w projekcie klienta Wczytaj kod w innym AppDomain.

teraz tworzymy nową AppDomain. Może określić lokalizację bazową dla odniesień do złożenia. Sondowanie sprawdzi, czy w GAC i w bieżącym katalogu oraz w AppDomain Base loc znajdują się zależne zespoły.

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

jeśli potrzebujesz, istnieje mnóstwo różnych sposobów ładowania zespołu. Możesz użyć innego sposobu z tym rozwiązaniem. Jeśli masz kwalifikowaną nazwę asemblera, to lubię używać CreateInstanceAndUnwrap, ponieważ ładuje bajty asemblera, a następnie tworzy instancje Twojego typu i zwraca object, które możesz łatwo wysłać do swojego typu proxy lub jeśli nie, to do silnie wpisanego Kod możesz użyć środowiska uruchomieniowego dynamic language I przypisać zwrócony obiekt do zmiennej dynamic wpisanej, a następnie bezpośrednio wywołać członków.

Pozwala to na załadowanie zestawu, do którego twój Klient proj nie ma odniesienia w oddzielnym AppDomain i wywołanie na nim członków od klienta.

Do testowania lubię używać okna modułów w Visual Studio. Pokaże Ci domenę montażu klienta i jakie są w niej załadowane wszystkie moduły domena, a także nowa domena aplikacji i to, jakie zespoły lub moduły są ładowane w tej domenie.

Kluczem jest upewnienie się, że kod pochodzi z MarshalByRefObject lub jest serializowalny.

`MarshalByRefObject pozwoli Ci skonfigurować czas życia domeny. Na przykład, powiedzmy, że chcesz, aby domena została zniszczona, jeśli proxy nie został wywołany w ciągu 20 minut.