Puis-je charger un assembly .NET au moment de l'exécution et instancier un type en ne connaissant que le nom?

Est-il possible d'instancier un objet au moment de l'exécution si je n'ai que le nom de la DLL et le nom de la classe, sans ajouter de référence à l'assembly dans le projet? La classe implémente une interface, donc une fois que j'instancie la classe, je la caste vers l'interface.

Nom de l'assemblage:

library.dll

Nom du type:

Société.Projet.Classe

EDIT: Je n'ai pas le chemin absolu de la DLL, donc Assembly.LoadFilene fonctionnera pas. La DLL peut être à la racine de l'application, system32 ou même chargée dans le GAC.

Oui. Vous devez utiliser Assembly.LoadFrompour charger l'assembly en mémoire, puis vous pouvez l'utiliser Activator.CreateInstancepour créer une instance de votre type préféré. Vous devrez d'abord rechercher le type en utilisant la réflexion. Voici un exemple simple:

Assembly assembly = Assembly.LoadFrom("MyNice.dll");

Type type = assembly.GetType("MyType");

object instanceOfMyType = Activator.CreateInstance(type);

Mettre à jour

Lorsque vous avez le nom du fichier d'assembly et le nom du type, vous pouvez utiliser Activator.CreateInstance(assemblyName, typeName)pour demander à la résolution de type .NET de résoudre cela en un type. Vous pouvez encapsuler cela avec un try / catch afin qu'en cas d'échec, vous puissiez effectuer une recherche dans les répertoires où vous pouvez spécifiquement stocker des assemblys supplémentaires qui, autrement, pourraient ne pas être recherchés. Cela utiliserait la méthode précédente à ce stade.

Considérez les limites des différentes Load*méthodes. À partir de la documentation MSDN ...

LoadFile ne charge pas les fichiers dans le contexte LoadFrom et ne résout pas les dépendances à l'aide du chemin de chargement, comme le fait la méthode LoadFrom.

Plus d'informations sur les contextes de chargement peuvent être trouvées dans la LoadFromdocumentation.

Activator.CreateInstance devrait fonctionner.

IFace object = (IFace)Activator.CreateInstance( "AssemblyName",
                                                "TypeName" )
                               .Unwrap();

Remarque: le nom du type doit être le type pleinement qualifié.

Exemple:

var aray = (IList)Activator.CreateInstance("mscorlib","System.Collections.ArrayList").Unwrap();
aray.Add(10);

foreach (object obj in aray)
{
    Console.WriteLine(obj);
}

J'ai trouvé cette question et certaines réponses très utiles, mais j'ai eu des problèmes de chemin, donc cette réponse couvrirait le chargement de la bibliothèque en trouvant le chemin du répertoire bin.

Première solution:

string assemblyName = "library.dll";
string assemblyPath = HttpContext.Current.Server.MapPath("~/bin/" + assemblyName);
Assembly assembly = Assembly.LoadFrom(assemblyPath);
Type T = assembly.GetType("Company.Project.Classname");
Company.Project.Classname instance = (Company.Project.Classname) Activator.CreateInstance(T);

Deuxième solution

string assemblyName = "library.dll";
string assemblyPath = HttpContext.Current.Server.MapPath("~/bin/" + assemblyName);
Assembly assembly = Assembly.LoadFile(assemblyPath);
(Company.Project.Classname) instance = (Company.Project.Classname) assembly.CreateInstance("Company.Project.Classname");

Vous pouvez utiliser le même principe pour les interfaces (vous créeriez une classe mais la transtyperiez en interface), comme:

(Company.Project.Interfacename) instance = (Company.Project.Interfacename) assembly.CreateInstance("Company.Project.Classname");

Cet exemple est pour une application Web mais similaire pourrait être utilisé pour l'application de bureau, seul le chemin est résolu de manière différente, par exemple

Path.GetDirectoryName(Application.ExecutablePath)

C'est facile.

Exemple de MSDN:

public static void Main()
{
    // Use the file name to load the assembly into the current
    // application domain.
    Assembly a = Assembly.Load("example");
    // Get the type to use.
    Type myType = a.GetType("Example");
    // Get the method to call.
    MethodInfo myMethod = myType.GetMethod("MethodA");
    // Create an instance.
    object obj = Activator.CreateInstance(myType);
    // Execute the method.
    myMethod.Invoke(obj, null);
}

Voici un lien de référence

https://msdn.microsoft.com/en-us/library/25y1ya39.aspx

À partir de Framework v4.5, vous pouvez utiliser Activator.CreateInstanceFrom () pour instancier facilement des classes dans des assemblys. L'exemple suivant montre comment l'utiliser et comment appeler une méthode en passant des paramètres et en obtenant la valeur de retour.

    // Assuming moduleFileName contains full or valid relative path to assembly    
    var moduleInstance = Activator.CreateInstanceFrom(moduleFileName, "MyNamespace.MyClass");
    MethodInfo mi = moduleInstance.Unwrap().GetType().GetMethod("MyMethod");
    // Assuming the method returns a boolean and accepts a single string parameter
    bool rc = Convert.ToBoolean(mi.Invoke(moduleInstance.Unwrap(), new object[] { "MyParamValue" } ));

Oui. Je n'ai aucun exemple que j'ai fait personnellement disponible pour le moment. Je posterai plus tard quand j'en trouverai. En gros, vous utiliserez la réflexion pour charger l'assemblage, puis pour extraire les types dont vous avez besoin.

En attendant, ce lien devrait vous aider à démarrer:

Utilisation de la réflexion pour charger des assemblys non référencés au moment de l'exécution

((ISomeInterface)Activator.CreateInstance(Assembly.LoadFile("somePath").GetTypes()[0])).SomeInterfaceMethod();

Vous pouvez charger un assembly à l'aide des méthodes * Assembly.Load **. En utilisant Activator.CreateInstance, vous pouvez créer de nouvelles instances du type souhaité. Gardez à l'esprit que vous devez utiliser le nom de type complet de la classe que vous souhaitez charger (par exemple Namespace.SubNamespace.ClassName ). En utilisant la méthode InvokeMember de la classe Type , vous pouvez appeler des méthodes sur le type.

De plus, tenez compte du fait qu'une fois chargé, un assembly ne peut pas être déchargé tant que tout l'AppDomain n'est pas déchargé (il s'agit essentiellement d'une fuite de mémoire).

En fonction de la façon dont ce type de fonctionnalité est intrinsèque à votre projet, vous voudrez peut-être envisager quelque chose comme MEF qui se chargera du chargement et de la liaison des composants pour vous.

Assembly assembly = Assembly.LoadFrom("MyAssembly.dll");

Type type = assembly.GetType("MyType");

dynamic instanceOfMyType = Activator.CreateInstance(type);

Ainsi, de cette façon, vous pouvez utiliser des fonctions non avec get methodinfo, puis l'invoquer. Vous ferez comme ceci instanceOfMyType.MethodName (); Mais vous ne pouvez pas utiliser Intellisense car les types dynamiques sont tapés au moment de l'exécution, pas au moment de la compilation.

Oui, vous souhaiterez utiliser la méthode statique Load sur la classe Assembly, puis appeler puis appeler la méthode CreateInstance sur l'instance Assembly qui vous est retournée par l'appel à Load.

En outre, vous pouvez appeler l'une des autres méthodes statiques commençant par "Load" sur la classe Assembly, selon vos besoins.

Vous pouvez faire ces choses de cette façon:

using System.Reflection;

Assembly MyDALL = Assembly.Load("DALL"); //DALL name of your assembly
Type MyLoadClass = MyDALL.GetType("DALL.LoadClass"); // name of your class
 object  obj = Activator.CreateInstance(MyLoadClass);