Managed C ++ - Importation différentes DLL basé sur le fichier de configuration

Question

Je suis en train d'écrire une application qui servira un but similaire pour plusieurs clients, mais nécessite des adaptations à la façon dont il traitera les données qu'il est l'alimentation. En substance, il servira le même but, mais distribuer des données tout à fait différemment.

Alors j'ai décidé de prodeed comme ceci: -Faire bibliothèque de moteur commun qui contiendra les fonctionnalités communes de toutes les manières et présenter l'interface par défaut assurant que les différents moteurs répondront de la même façon. -Écrivez un moteur spécifique pour chaque mode de fonctionnement .... chacun compile dans son propre .dll.

Alors mon projet va se retrouver avec un tas de bibliothèques avec certains qui ressemble à ceci: project_engine_base.dll project_engine_way1.dll project_engine_way2.dll

dans le fichier de configuration que nous utilisons pour les préférences de l'utilisateur il y a une section de moteur va afin que nous puissions décider de quel moteur utiliser:

[ENGINE]
Way1

Donc quelque part dans le code que nous voulons faire:

If (this->M_ENGINE == "Way1")
  //load dll for way1
Else If (this->M_ENGINE == "Way2")
  //load dll for way2
Else
  //no engines selected...tell user to modify settings and restart application

La question est ... Comment puis-je importer mes dll (s) de cette façon? Est-il même possible? Si je ne peux pas obtenir des suggestions sur la façon de parvenir à la même manière de fonctionner?

Je suis conscient que je pouvais importer tous les dll dès le début et juste choisir le moteur à utiliser, mais l'idée est que je ne voulais pas importer trop de moteurs pour les ressources rien et des déchets et nous n » t veulent avoir à expédier tous ces dll à nos clients. Un client utilisera un moteur autre utilisera un autre. Certains de nos clients utiliseront plus d'un peut-être donc la raison pour laquelle je voulais extérioriser cela et permettre à nos utilisateurs d'utiliser un fichier de configuration pour la commutation du moteur.

Toutes les idées?

EDIT: Juste rendu compte que même si chacun de mon moteur présenterait la même interface si elles sont chargées dynamiquement lors de l'exécution et non pas tous référencés dans le projet, mon projet ne serait pas compiler. Je n'ai donc pas un autre choix que de les inclure dans mon projet non?

Cela signifie aussi qu'ils doivent tous être expédiés à mes clients. Les paramètres de la configuration ne ferait que dicter la classe j'utiliser pour initialiser mon membre du moteur.

ou

Je pourrais avoir chacun de ces moteurs est établi pour le même nom. Seulement importer une dll dans mon projet principal et ce moteur sera utilisé tout le temps. Cela viderait mes clients ne peuvent pas utiliser notre application pour plusieurs clients de leur propre. À moins qu'ils étaient prêts à passer manuellement dll. Beurk

Toutes les suggestions?

EDIT # 2: A ce stade, voir mes options, je pourrais aussi faire un grand juste dll contenant le moteur de base ainsi que tous les enfants et ma configuration pour permettre à l'utilisateur choisi. Au lieu de référencer plusieurs DLLs et les expédier tous. Juste un énorme et navire / référence que l'on ne. Je ne suis pas trop friand de ce soit comme cela signifie la livraison à grande dll tous mes clients au lieu d'un ou deux petits qui conviennent il faut. Ceci est encore la meilleure solution que je suis venu avec cependant.

Je suis toujours à la recherche de meilleures suggestions ou des réponses à ma question initiale. Merci.

Answer 1

La solution que je suis venu est le suivant:

Engine_Base^  engine_for_app;
Assembly^ SampleAssembly;
Type^  engineType;

if (this->M_ENGINE == "A")
{
    SampleAssembly = Assembly::LoadFrom("path\\Engine_A.dll");

    engineType = SampleAssembly->GetType("Engine_A");
    engine_for_app = static_cast<Engine_Base^>(Activator::CreateInstance(engineType, param1, param2));
}
else
{
    SampleAssembly = Assembly::LoadFrom("path\\Engine_B.dll");

    engineType = SampleAssembly->GetType("Engine_B");
    engine_for_app = static_cast<Engine_Base^>(Activator::CreateInstance(engineType, param1, param2, param3, param4));
}

J'ai utilisé la réponse de Daniel et les commentaires qui ont été faites sur sa réponse. Après quelques recherches supplémentaires je suis tombé sur la méthode LoadFrom.

Answer 2

Utilisation des DLL séparées pour chaque moteur et en utilisant LoadLibrary dans votre projet principal pour charger le moteur spécifique en fonction de la configuration.

Demandez à votre interface de moteur dans un fichier d'en-tête commune que tous les moteurs découleront de cette interface et seront utilisés dans votre principale aswell projet.

Il pourrait ressembler à ceci:

// this should be an abstract class
class engine {
public:
     virtual void func1() = 0;
     virtual void func2() = 0;
...
};

Dans chaque autre implémentation du moteur exporter une fonction de la DLL, quelque chose comme ceci:

// might aswell use auto_ptr here
engine* getEngine() { return new EngineImplementationNumberOne(); }

Dans votre projet principal simplement charger la DLL que vous êtes intéressé à utiliser LoadLibrary et GetProcAddress la fonction getEngine.

string dllname;

if (this->M_ENGINE == "Way1")
     dllname = "dllname1.dll";         
else if (this->M_ENGINE == "Way2")
     dllname = "dllname2.dll";
else
     throw configuration_error();

HMODULE h = LoadLibraryA(dllname.c_str());
typedef engine* (*TCreateEngine)();

TCreateEngine func = (TCreateEngine)GetProcAddress(h, "getEngine");
engine* e = func();

Le nom de la fonction exportée sera probablement obtenir mutilée, de sorte que vous pouvez soit utiliser des fichiers DEF ou extern « C » dans vos DLL, ne pas oublier aussi de vérifier les erreurs.