Utilisation de DLL mixtes à partir de/clr: projets purs

Question

Je construis un projet avec une DLL. La DLL doit prendre en charge le code natif, donc je l'ai déclaré comme un/clr. Mon projet était aussi un projet a/clr et tout allait bien. Cependant, je voudrais inclure des tests NUnit donc j'ai dû passer de mon projet principal de/clr à/clr: pure.

Tout compile encore mais tout appel Dll génère une erreur d'exécution. Quand je revenir à tout/clr est ok

Dans mes dll, les fonctions exportées sont déclarées comme suit:

#define DllExport __declspec(dllexport) 
DllExport bool DisplayScan(bool bShow, bool bAllPasses) { } 

J'ai aussi fait un fichier contenant def les vrais noms de toutes les fonctions exportées

LIBRARY "Controller" 
EXPORTS 
DisplayScan 

De mon projet principal mes importations sont déclarées comme suit:

#define _DllImport [DllImport("Controller.dll", CallingConvention = CallingConvention::Cdecl)] static 
_DllImport bool DisplayScan(bool bShow, bool bAllPasses) 

Quelqu'un a déjà rencontré un tel problème?

Answer 1

tout Ok travaille maintenant

En fait, il travaille depuis le début.

morale: ne pas essayer de jeter un char * dans un std :: string

chose étrange: son ok dans/clr jusqu'à ce que vous revenez de la fonction. Il se bloque tout de suite dans/clr: pur

Answer 2

Fondamentalement, vous faites quelque chose qui n'est pas supporté;/clr: exportation de DLL pure et native. Comme cité dans this MSDN article "les assemblages purs ne peuvent pas exporter les fonctions qui peuvent être appelées à partir de fonctions natives car les points d'entrée dans un assemblage pur utilisent la convention d'appel __clrcall".

Je ne suis pas sûr de la meilleure solution de contournement. Cependant, avec un peu d'expérimentation, vous pourriez probablement profiter de la convention d'appel __clrcall avec l'option/clr. Here's a link qui peut être utile. D'après ce que je peux comprendre, vous devriez être capable d'exporter ces classes gérées et de les consommer depuis un assemblage géré tel que votre projet de test NUnit géré, mais conserver vos exports non gérés avec des signatures de méthodes différentes. Gardez à l'esprit que dès que vous exposez une classe .net via une exportation, elle doit utiliser la convention d'appel __clrcall.

Answer 3

votre problème appelle conventionCallingConvention = CallingConvention :: CDECL ... définir votre fonction comme ça ou utiliser stdcall ou clrcall, clecl est pour C pure

ou le problème est ici: définir que extern fonction non statique

Answer 4

Avantages de/clr: pur

meilleure performance: Parce que pures assemblées ne contiennent que MSIL, il n'y a pas des fonctions natives, et donc pas de transitions non gérés/managed sont nécessaires. (Les appels de fonction effectués via P/Invoke font exception à cette règle.)

AppDomain Awareness: Les fonctions managées et les types de données CLR existent dans les domaines d'application, ce qui affecte leur visibilité et leur accessibilité.Les assemblages purs sont sensibles au domaine (__declspec (appdomain) est implicite pour chaque type). L'accès à leurs types et fonctionnalités à partir d'autres composants .NET est donc plus facile et plus sûr. Par conséquent, les assemblages purs interagissent plus facilement avec d'autres composants .NET qu'avec des assemblages mixtes.

Chargement sans disque: Les assemblages purs peuvent être chargés en mémoire et même en continu. Ceci est essentiel pour utiliser les assemblys .NET en tant que procédures stockées. Cela diffère des assemblages mixtes, qui en raison d'une dépendance sur les mécanismes de chargement de Windows, doivent exister sur le disque pour s'exécuter. Réflexion: Il n'est pas possible de réfléchir sur des exécutables mixtes, alors que les assemblages purs fournissent un support de réflexion complet. Pour plus d'informations, voir Reflection (C++/CLI). Contrôlabilité de l'hôte: Comme les assemblages purs ne contiennent que du MSIL, ils se comportent de manière plus prévisible et plus flexible que les assemblages mixtes lorsqu'ils sont utilisés dans des applications qui hébergent le CLR et modifient son comportement par défaut.

Limites de/clr: pur

Cette section couvre les fonctionnalités pas pris en charge par/clr: pure.

Les assemblages purs ne peuvent pas être appelés par des fonctions non gérées. Par conséquent, les assemblys purs ne peuvent pas implémenter des interfaces COM ou exposer des rappels natifs. Les assemblages purs ne peuvent pas exporter de fonctions via les fichiers __declspec (dllexport) ou .DEF. De même, les fonctions déclarées avec la convention __clrcall ne peuvent pas être importées via __declspec (dllimport). Les fonctions d'un module natif peuvent être appelées à partir d'un assemblage pur, mais les assemblages purs ne peuvent pas exposer les fonctions appelables natives. La fonctionnalité d'exposition dans un assemblage pur doit donc être effectuée via des fonctions managées dans un assemblage mixte. Voir Comment: migrer vers/clr: pure (C++/CLI) pour plus d'informations.

Les bibliothèques ATL et MFC ne sont pas prises en charge par la compilation en mode pur dans Visual C++.

Les .netmodules purs ne sont pas acceptés en tant qu'entrée dans le lieur Visual C++. Cependant, les fichiers .obj purs sont acceptés par l'éditeur de liens, et les fichiers .obj contiennent un surensemble d'informations contenues dans netmodules. Voir Fichiers .netmodule en tant qu'entrée de lieur pour plus d'informations.

La prise en charge COM du compilateur (#import) n'est pas prise en charge, car cela introduirait des instructions non gérées dans l'assembly pur.

Les options de virgule flottante pour l'alignement et la gestion des exceptions ne sont pas réglables pour les assemblages purs. Par conséquent, __declspec (align) ne peut pas être utilisé. Cela rend certains fichiers d'en-tête, tels que fpieee.h, incompatible avec/clr: pure.

La fonction GetLastError dans le PSDK peut donner un comportement indéfini lors de la compilation avec/clr: pure.