Argument String in DLL

Version imprimable

30/10/2013, 18h04
marcus7

Argument String in DLL
Bonjour à tous
ça fait 2 jours que je tourne en rond, je cherche à passer un string à une fonction d'une DLL appelée depuis du VB d'excel. en vb ça donne :

Code:

Private Declare Function LoadAndSortRequestData_dll Lib "Mydll.dll" (ByVal aTestString As String, ByVal aFileRequests As String) as long

et en C++ :
Code:

1 2 3 4 5 int __stdcall LoadAndSortRequestData_dll(BSTR ateststring, char* aRequestsFile) { //....fonction de lecture de données return 0; }
Je lis partout que le BSTR est le type approprié pour récupérer un string venant du VB, mais seul le type char* récupère correctement le string vb, le BSTR m'affiche une liste interminable de symbole chinois 8O.
J'ai obsolumement besoin de pouvoir passer un BSTR pour gérer après des SAFEARRAY de caractères...
Quelqu'un a t il une idée ?
Merci
30/10/2013, 19h53
moldavi
Bonjour.

Le type BSTR, c'est plutôt pour des dll COM.

Je dirais que si le type char* va bien, ne pas s'en priver.

Par contre je ferais ceci :
Code:

1 2 3 4 5 6 7 int __stdcall LoadAndSortRequestData_dll(char* ateststring, int SizeTestString, char* aRequestsFile, int SizeRequestString) { //....fonction de lecture de données return 0; }
Cela permettra à la dll d'éviter de faire des bêtises avec la mémoire.

S'il faut utiliser absolument le BSTR, faire attention que c'est du Wide Char :

http://msdn.microsoft.com/en-us/libr...(v=vs.85).aspx

Sinon faire un essaie avec ceci :
Code:

1 2 3 4 5 6 int __stdcall LoadAndSortRequestData_dll(wchar_t* ateststring, char* aRequestsFile) { //....fonction de lecture de données return 0; }
31/10/2013, 09h17
marcus7

Merci beaucoup pour la réponse, mais une variable wchart_t* ne me récupère pas plus la variable venant du VB.
Sinon j'aurai très volontier continuer à gérer des char*, mais je voudrais pouvoir passer des gros vecteurs de string et je n'ai trouvé aucun moyen de le faire avec des char* ce qui de toute façon me parait dangereux pour la gestion de la mémoire comme tu dis.
31/10/2013, 09h23
jouana

Bonjour,

Un char* (pointeur de type char)
et un string (objet contenant un char* et d'autres trucs)

C'est pas trop la même chose.
31/10/2013, 09h41
marcus7

Oui je sais, mais ça ne résoud pas mon problème. Comment je peux récupérer un BSTR ou un wchart* (en gros quelque chose te propre avec une taille, pas juste un pointeur) dans les argument de ma dll en tant que "chaine de caractères" pour être en mesure de gérer des arguments de vecteur de chaines de caractères.
Merci
31/10/2013, 09h49
therwald

Citation:

Envoyé par marcus7

un BSTR ou un wchart* (en gros quelque chose te propre avec une taille, pas juste un pointeur)
Merci

à mon avis un wcahrt* c'est juste un pointeur, justement...
tes informations sur la signature de VB ne seraient-elles pas obsolètes ou inadaptées à la version? Ça s'est vu...
31/10/2013, 10h16
marcus7

Citation:

tes informations sur la signature de VB ne seraient-elles pas obsolètes ou inadaptées à la version?

Je ne sais pas, comment je peux savoir ?
31/10/2013, 11h24
therwald

Il n'y a pas de réponse exacte à cette question. Où as tu trouvé cette signature? Est-ce que des informations de version (VB, windows?) étaient mentionnées?
Si ça ne compile qu'avec char*, est-ce que tu es sûr du type d'environnement (la déclaration est peut-être faite avec TCHAR, qui devient char* ou wchar_t* en focntion de certains defines...
31/10/2013, 12h25
marcus7

Je crois que j'ai une explication à mon pb (mais sans la solution hélas :cry:) :

Citation:

Visual Basic, like Windows NT and Windows 2000, is based internally on the double-byte Unicode standard. However, Visual Basic assumes that the world outside of itself still uses the single-byte ANSI model. Any strings passed as parameters to an external function will be converted by Visual Basic from their internal Unicode representation to an ANSI representation before the call to the function is made. In the same way, all strings that return to Visual Basic from an external function are assumed to be in an ANSI representation, and Visual Basic will attempt to make the conversion to a Unicode representation for internal use. This behavior makes it impossible to call an external function that expects or returns a Unicode string in the same way as a function that deals only with ANSI strings.

cf : http://support.microsoft.com/kb/145727/en-us
31/10/2013, 17h22
marcus7

Comme il s'agit plus d'un sujet VB, j'ai ouvert un post là bas spécifique pour la passage d'un tableau de string :

http://www.developpez.net/forums/d13...p/#post7550574

Encore merci pour vos réponses.
04/11/2013, 16h43
Médinoc

Il y a une solution, c'est de faire un objet COM, qui lui pourra être appelé depuis VB (et bien d'autres choses!) en utilisant des vraies BSTR, et même un SAFEARRAY de BSTR (le format utilisé par VB pour les tableaux de chaînes).

Le plus simple, je pense, c'est de faire un objet COM qui ne soit pas un composant COM: pas d'enregistrement dans le Registre ou de fioritures similaires (tu auras besoin de générer une bibliothèque de types par contre pour que VB connaisse ton interface COM), juste une fonction qui retourne un pointeur vers un objet COM supportant une seule interface héritée de IUnknown.
(enfin, j'espère que ça suffit pour VB ou VBA, sinon il faudra faire la version compliquée)

Edit: Il faut faire un poil plus compliqué que je croyais, parce que Visual Basic n'accepte que le dispatch dynamique.

J'ai pu faire un objet COM simple qui n'a pas besoin d'enregistrement. Par contre, il a besoin que le .tlb et la DLL générés soient dans le répertoire courant:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
[uuid("B92AB342-0BA3-48EF-9C1C-E1EA2412A630")]
library DynLib1
{
	importlib("stdole2.tlb");
 
	[uuid("7700F4DA-A84A-4672-B6D0-19D6817777E7")]
	[oleautomation, dual]
	interface IDynLib1 : IDispatch
	{
		[id(1)] HRESULT Fonc([in, ref] SAFEARRAY(BSTR)* ppArr, [out, retval] int* pRet);
	}
}

Compilé avec:

Code:

1
2
mkdir TLBHeader (si le dossier n'existe pas)
midl iface.idl /h TLBHeader/iface.h /tlb TLBHeader/iface.tlb /iid TLBHeader/uuids.c

Ensuite, c'est un object COM assez simple. Je ne commenterai pas sur l'implémentation classique du comptage de références par IUnknown,
en fait la seule partie difficile c'est l'implémentation de IDispatch (pour l'interface duale), exigée par VB. Sauf qu'en fait, cette page explique qu'on peut s'en sortir à peu de frais si on a une Type Library pour une interface duale: On charge la Type Library et on laisse Windows faire le reste.

Tout ce qui reste, c'est une fonction de test qui accepte un SafeArray de BSTRs, et affiche la seconde chaîne dans une MessageBox. Et cette fois, enfin, on voit qu'il s'agit de vraies BSTRs Unicode.

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
#include "stdafx.h" //Windows.h, OleAuto.h, ObjBase.h
#include "TLBHeader\iface.h"
#include "DynLib1.h"
 
class CCOMObj : public IDynLib1
{
private:
	LONG count;
	ITypeInfo *m_pTypeInfo;
	IUnknown *m_pUnknownStdDisp;
public:
	CCOMObj() : count(1) {}
	~CCOMObj();
	HRESULT Init(void);
 
	STDMETHODIMP QueryInterface(REFIID riid, void** ppv);
	STDMETHODIMP_(ULONG) AddRef(void);
	STDMETHODIMP_(ULONG) Release(void);
 
	STDMETHODIMP GetTypeInfoCount(UINT* pCountTypeInfo);
	STDMETHODIMP GetTypeInfo(UINT iTypeInfo, LCID lcid, ITypeInfo** ppITypeInfo);
	STDMETHODIMP GetIDsOfNames(REFIID riid, LPOLESTR* rgszNames, UINT cNames, LCID lcid, DISPID* rgDispId);
	STDMETHODIMP Invoke(DISPID dispIdMember, REFIID riid, 
		LCID lcid, WORD wFlags, DISPPARAMS* pDispParams, 
		VARIANT* pVarResult, EXCEPINFO* pExcepInfo, 
		UINT* puArgErr);
 
	STDMETHODIMP Fonc(SAFEARRAY** ppArr, int *pRet); 
};
 
 
//IUnknown implementation
STDMETHODIMP CCOMObj::QueryInterface(REFIID riid, void** ppv)
{
	if(riid == IID_IUnknown || riid == IID_IDynLib1)
	{
		IDynLib1 * pRet = this;
		pRet->AddRef();
		*ppv = pRet;
		return S_OK;
	}
	else if(riid == IID_IDispatch)
	{
		return m_pUnknownStdDisp->QueryInterface(riid, ppv);
	}
	else
	{
		*ppv = NULL;
		return E_NOINTERFACE;
	}
}
STDMETHODIMP_(ULONG) CCOMObj::AddRef(void)
{
	return InterlockedIncrement(&count);
}
STDMETHODIMP_(ULONG) CCOMObj::Release(void)
{
	ULONG ret = InterlockedDecrement(&count);
	if(ret == 0)
	{
		delete this;
	}
	return ret;
}
 
 
//IDispatch implementation
HRESULT CCOMObj::GetTypeInfoCount(UINT* pCountTypeInfo)
{
    *pCountTypeInfo = 1;
    return S_OK;
}
HRESULT CCOMObj::GetTypeInfo(UINT iTypeInfo, LCID lcid, 
    ITypeInfo** ppITypeInfo)
{
    *ppITypeInfo = NULL;
    if(iTypeInfo != 0)
        return DISP_E_BADINDEX;
    m_pTypeInfo->AddRef();
    *ppITypeInfo = m_pTypeInfo;
    return S_OK;
}
HRESULT CCOMObj::GetIDsOfNames(REFIID riid, 
    LPOLESTR* rgszNames, UINT cNames, LCID lcid, 
    DISPID* rgDispId)
{
    if(riid != IID_NULL)
        return DISP_E_UNKNOWNINTERFACE;
    return DispGetIDsOfNames(m_pTypeInfo, rgszNames, cNames, 
        rgDispId);
}
HRESULT CCOMObj::Invoke(DISPID dispIdMember, REFIID riid, 
    LCID lcid, WORD wFlags, DISPPARAMS* pDispParams, 
    VARIANT* pVarResult, EXCEPINFO* pExcepInfo, UINT* puArgErr)
{
    if(riid != IID_NULL)
        return DISP_E_UNKNOWNINTERFACE;
    return DispInvoke(this, m_pTypeInfo, dispIdMember, wFlags, 
        pDispParams, pVarResult, pExcepInfo, puArgErr); 
}
 
 
//IDynLib1 implementation
STDMETHODIMP CCOMObj::Fonc(SAFEARRAY** ppArr, int *pRet)
{
	if(ppArr==NULL || pRet==NULL)
		return E_POINTER;
 
	SAFEARRAY* pArr = *ppArr;
	if(pArr != NULL && SafeArrayGetDim(pArr)==1)
	{
		LONG ix = 1;
		BSTR s = NULL;
		HRESULT hr = SafeArrayGetElement(pArr, &ix, &s);
		MessageBoxW(NULL, s, L"Test (W)", MB_OK|MB_ICONINFORMATION);
		SysFreeString(s);
	}
	*pRet = 0;
	return S_OK;
}
 
//Creation
HRESULT CCOMObj::Init()
{
	ITypeLib* pTypeLib;
	HRESULT hr;
	hr = LoadTypeLib(L"iface.tlb", &pTypeLib);
	if(FAILED(hr))
		return hr;//E_FAIL;
	hr = pTypeLib->GetTypeInfoOfGuid(IID_IDynLib1, &m_pTypeInfo);
	pTypeLib->Release();
	if(FAILED(hr))
		return hr;
 
	return CreateStdDispatch(this, this, m_pTypeInfo, &m_pUnknownStdDisp);
}
 
CCOMObj::~CCOMObj()
{
	count = 42; //Artificial bump to avoid double-destruction if some destructor plays with references to this class
	if(m_pTypeInfo != NULL)
		m_pTypeInfo->Release(), m_pTypeInfo=NULL;
	if(m_pUnknownStdDisp != NULL)
		m_pUnknownStdDisp->Release(), m_pUnknownStdDisp=NULL;
}
 
EXTERN_C DYNLIB1_API STDMETHODIMP GetCOMObj(IDynLib1 **ppRet)
{
	if(ppRet==NULL)
		return E_POINTER;
	*ppRet = NULL;
 
	CCOMObj *pRet = new CCOMObj();
	HRESULT hRet = pRet->Init();
	if(SUCCEEDED(hRet))
	{
		pRet->QueryInterface(__uuidof(*ppRet), (void**)ppRet);
	}
	pRet->Release();
	return hRet;
}

Ce fichier est juste rajouté dans la DLL, il ajoute une fonction exportée qui retourne une nouvelle instance de l'objet COM.

Et voici le code VB simple qui l'appelle:
Je l'ai séparé en fonctions lors du débogage, on pourrait tout mettre dans une seule facilement.

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
Private Declare Function GetCOMObj Lib "DynLib1" Alias "_GetCOMObj@4" (ByRef obj As DynLib1.IDynLib1) As Long
Option Explicit
 
Private Sub DoSomething(ByVal obj As DynLib1.IDynLib1, ByRef strings() As String)
    obj.Fonc strings
End Sub
 
Private Function Acquire() As DynLib1.IDynLib1
    Dim obj As DynLib1.IDynLib1
    Dim ret As Long
    ret = GetCOMObj(obj)
    If ret < 0 Then
        MsgBox "Failed: " + Hex(ret)
    End If
    Set Acquire = obj
End Function
 
 
 
Private Sub Command1_Click()
    'fnDynamic "Ceci est un test"
 
    'Ce test a été écrit pour savoir si un SAFEARRAY de BSTR était transmis en ASCII étendu ou en Wide.
    'Réponse: Quand on appelle une fonction normale, même ça c'est de l'ASCII étendu.
    'Mais quand on appelle une méthode COM, ça marche
    Dim strings(3) As String
    strings(0) = "Alpha"
    strings(1) = "Beta"
    strings(2) = "Gamma"
 
    Dim obj As DynLib1.IDynLib1
    ChDir "D:\MesDocs\Visual Studio 6\Projects\VB6_3" 'changer le dossier
    'MsgBox "Attention..."
    Set obj = Acquire()
    If Not (obj Is Nothing) Then
        DoSomething obj, strings
    End If
End Sub
 
Private Sub CommandQuit_Click()
    Unload Me
End Sub

Ce code change le répertoire courant pour être utilisable depuis l'Environnement de Développement de VB6 (qui lui, débute dans son propre dossier). Si tu utilises le code de test, pense à tout mettre dans le même dossier.