Bon voilà, je suis en train de construire un petit SDK avec des interfaces abstraites en C++, et pour agrémenter un peu la doc je voudrais mettre quelques exemples d´utilisation à partir de différents langages.

Bon en C++ pas de souci, langage C idem . .
Mon problème : je connais pas assez le VB pour ne pas dire pas du tout

Donc ma question, comment déclare-t-on et fait-on appel à des fonctions d´une dll depuis VB ?

Sachant que la déclaration ressemblerait à un truc dans ce genre ( exemple bidon):

1. ifdef __cplusplus

extern " C" {

1. endif

1. undef INTERFACE
2. define INTERFACE IMonInterface

DECLARE_INTERFACE(IMonInterface)
{
STDMETHOD_(DCRC,Initialize)(THIS_ DWORD _Param1) PURE;
STDMETHOD_(DCRC,Release)(THIS_ DWORD _Param1) PURE;
/ / . ..
};

HRESULT CreateInterface(IMonInterface **_ppIMonInterface);
typedef HRESULT ( *pfnCreateInterface) ( IMonInterface **_ppIMonInterface);

HRESULT FreeInterface(IMonInterface **_ppIMonInterface);
typedef HRESULT ( *pfnFreeInterface) ( IMonInterface **_ppIMonInterface);

1. ifdef __cplusplus

}

1. endif

et dans le . def :

( ...)
EXPORTS
CreateInterface
FreeInterface

Ce n´est pas ca ?
- Procédure : [Public | Private] Declare Sub name Lib " libname" [Alias " aliasname"] ( [arglist])]
- Fonction : [Public | Private] Declare Function name Lib " libname" [Alias " aliasname"] [([arglist])] [As type]

Ex : Private Declare Function GetVersionEx Lib " kernel32" Alias " GetVersionExA" _
( lpVersionInformation As OSVERSIONINFO) As Long ´pour renvoyer le numéro de version du sytème d´exploitation Windows.

Appel de la fonction : Dim dl&
dl& = GetVersionEx&(ver)

Bien sûr il faut avoir préalablement crée un type en rapport avec la DLL :
Private Type OSVERSIONINFO ´Pour la version de windows
dwOSVersionInfoSize As Long
dwMajorVersion As Long
dwMinorVersion As Long
dwBuildNumber As Long
dwPlatformId As Long
szCSDVersion As String * 128
wSPMajor As Integer ´ Service Pack Major Version
End Type

Voilà en ayant pris l´exemple de la version de Windows que j´avais fait lors d´un stage en VB6 donc ca date un peu. Je ne sais malheureusement plus ou j´ai trouvé tout ca.

le _ que j´ai pu insérer ici et là permette d´aller à la ligne pour plus de lisibilité. Donc ils ne sont pas obligatoires bien evidemment.

Par contre je ne sais pas si cette méthode fonctionne sous VB.NET.

merci beaucoup

ca devrait déjà me donner une idée sur comment appeler les fonctions exportées mais il me reste un problème d´adaptation . ..

Comment interpréter l´interface dans VB ?

En C++ ca devient une classe avec des méthodes, en C une structure avec des pointeurs de fonctions.

Est il possible de créer une classe en VB sur le même modèle ?

sachant que :

STDMETHOD_(DCRC,Initialize)(THIS_ DWORD _Param1) PURE;

devient en C++ :

virtual DCRC Initialize(DWORD _Param1) = 0;

ou en C :

DCRC Initialize(IMonInterface *_this, DWORD _Param1);

NB: les _ pour moi c´est juste un moyen de différencier les paramètres d´une variable locale à une fonction, simple notation perso

Bon je me réponds

apparement non, c´est pas possible de déclarer une classe en VB venant de C++. A moins de passer par des objets COM ( j´en suis pas loin remarque).

Par COM ou ActiveX c´est possible, sinon c´est impossible car l´exportation de fonction au sein de DLL écrite en C pour du VB doit passer par des fichier . def

Ce qui rend impossible l´exportation de classe ( seul des fonctions peuvent être appeller en VB) mais empêche aussi de surcharger les fonctions ( aussi bien à l´export que tout simplement dans le code pour n´importe quel fonction surchargé).

De toute façons, exporter des class ça demande un fichier . lib et ça limite la porté de la DLL ( il faut déployer un . lib pour chaque compilo donc c´est pas terrible), ça peut poser des problème dans le cas de mise à jour de la DLL et puis de toute façons t´as dit que tu voulais rester compatible avec du C.

donc si tu veux vraiment faire qqch d´universel la seule méthode c´est d´exporter uniquement des fonctions et d´utiliser un fichier de définition.
( ça permet au passage de compiler aussi bien en . dll qu´en . lib ( une vraie librairie je veux dire, pas juste l´en tête des fonctions pour appeller la DLL)).

Par ce moyen tu peux très bien exporter une classe sans lib ni rien . .. C´est le principe même des interfaces abstraites, et plus généralement des COM.

Il y a une ClassFactory dans la DLL qui génère l´objet en fonction de l´interface demandée ( dans mon exemple le CreateInterface retourne un pointeur sur l´objet/structure créé(e)). Dans un COM tu fournis un CLSID qui identifie l´interface demandée, car il peut y en avoir plusieurs et via DllGetClassObject tu obtiens ta référence.

Donc que ce soit une classe en C++ ou une structure en C ca marche plutôt bien. Le problème venait surtout de l´équivalence en VB. Mais le principe étant proche des COM je vais peut être m´y mettre et adapter ca en COM pour avoir qqchose de plus " standard". En plus les langages . NET ( VB, C#) gèrent ca très bien il me semble, ca fera plus de langages compatibles, tant mieux

a peut-être, ça commence à être des mécanisme trop compliqué pour moi.

en passant, l´"automation", c´est pas l´automatisation de ce que tu décrit au dessus, ou alors ça n´a rien a voir ?

juste pour rajoutter que le managed C++ s´interface aussi très bien avec les langages . NET