Discussion :

[syleo2004]

Bonjour,

Je suis parti de l'exemple suivant :
http://www.codeproject.com/KB/cs/unm...tomanaged.aspx

Qui fonctionne très bien.
Mon problème est sur le paramétrage du VARIANT et le prototypage coté C# lorsque je veux utiliser d'autre type que des entiers (donné dans l'exemple)

J'ai réussi à lui passer une string de la manière suivante :

dans l'appli appelant :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
varArgs[0].vt = VT_BSTR;
varArgs[0].bstrVal = SysAllocString(L"Bonjour");

et en c# :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
public int ExempleMethodeString( string dede)
 {
            MessageBox.Show(dede);
            return (2);
}

Je cherche maintenant à faire passer un tableau de BYTE, mais toutes mes tentatives se sont soldées par des échecs.
Je débute et c'est pas simple pour moi.
Toute aide serait la bienvenue.

Merci.

[MABROUKI]

bonjour styleo,
Le prince Rodrigue:
"Je suis jeune, il est vrai, mais aux âmes bien nées,
La valeur n'attend point le nombre des années." le Cid de Corneille.
Pour un debutant tu t'es attaque à un sacre probleme des types dans l'ancien technologie WIN32 ou l'on se perd entre les types de C++,de MFC COM dont les 2 types :
- "fourre-tout Variant" connu sous le nom officiel de SafeArray
- le BSTR (tableau de chaine ).
Il servaitent à marshaller les types entre processus different.

Eh bien maintenant un nouveau challenge il faut continuer à marshaller les types entre ( vb.net,c#) et (c++ ou com).
je t'envoie ci-apres 2 bouts de code illustrant les attributs à utiliser lors declarations des variables en .Net pour marshaller correctement (conversion de type correcte) un type .Net(vb.net ou c# c'est pareil) vers c++ -com et VICE-VERSA.
Apparemment tu affaires à la bete "SafeArray" :
-tableau AutoDescriptif de structure de l'API WIN 32.Il necesiite quand on veut communiquer avec un des membres de la structure d'indiquer la taille du tableau. L'index de depart est pris par .Net toujour egal à 1.

j'espere que cela t'aidera:

Exemple de classe avec parametre Tableau Byte et SafeArray (utile pour Com ou MFC).

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
 
'Exemple de Classe avec declaration de Champ et  Appel de proc
Imports System.Runtime.InteropServices
Public Class ClassA
    'ICI UNE PROCEDURE RECEVANT UN SIMPLE TABLEAU DE BYTE PAR VALEUR
    Sub procByteA(<MarshalAs(UnmanagedType.LPArray, Iidparameterindex:=0, SizeConst:=14)> ByVal _
    ar() As Byte)
        arLocalByte = ar
    End Sub
    'ICI UNE PROCEDURE RECEVANT UN SIMPLE TABLEAU DE BYTE PAR REFERENCE
    Sub procByteC(<MarshalAs(UnmanagedType.LPArray, Iidparameterindex:=0, SizeConst:=14)> ByRef _
  ar() As Byte)
        arLocalByte = ar
    End Sub
    'ICI UNE PROCEDURE RECEVANT UN SIMPLE TABLEAU DE BYTE PAR REFERENCE ET ATTRIBUT In(lecture)
    Sub procByteD(<InAttribute(), MarshalAs(UnmanagedType.LPArray, Iidparameterindex:=0, SizeConst:=14)> ByRef _
  ar() As Byte)
        arLocalByte = ar
    End Sub
    'ICI UNE PROCEDURE RECEVANT UN SIMPLE TABLEAU DE BYTE PAR REFERENCE ET ATTRIBUT Out(ecriture)
    Sub procByteF(<InAttribute(), MarshalAs(UnmanagedType.LPArray, Iidparameterindex:=0, SizeConst:=14)> ByRef _
  ar() As Byte)
        ar = arLocalByte
    End Sub
    'EXEMPLE DE PARAMETRE DE CHAMP MEMBRE  D'UN SAFEARRAY ET APPEL DE PROC
    <MarshalAs(UnmanagedType.SafeArray, SafeArraySubType:=VarEnum.VT_BSTR, Iidparameterindex:=0, SizeConst:=14)> _
    Dim arLocalEntier() As Integer
 
    <MarshalAs(UnmanagedType.SafeArray, SafeArraySubType:=VarEnum.VT_BSTR, Iidparameterindex:=0, SizeConst:=14)> _
    Dim arLocalDate() As DateTime
 
    <MarshalAs(UnmanagedType.SafeArray, SafeArraySubType:=VarEnum.VT_BSTR, Iidparameterindex:=0, SizeConst:=14)> _
    Dim arLocalStr() As String
 
    <MarshalAs(UnmanagedType.SafeArray, SafeArraySubType:=VarEnum.VT_BSTR, Iidparameterindex:=0, SizeConst:=14)> _
    Dim arLocalByte() As Byte
 
    'Exemple de procedure VB recevant des parametres SafeArray
    Sub procInteger(<MarshalAs(UnmanagedType.SafeArray, SafeArraySubType:=VarEnum.VT_I4)> ByVal _
    ar() As Integer)
        arLocalEntier = ar
    End Sub
 
    Sub procDate(<MarshalAs(UnmanagedType.SafeArray, SafeArraySubType:=VarEnum.VT_DATE)> ByVal _
       ar() As DateTime)
        arLocalDate = ar
    End Sub
    Sub procStr(<MarshalAs(UnmanagedType.SafeArray, SafeArraySubType:=VarEnum.VT_BSTR)> ByVal _
    ar() As String)
        arLocalStr = ar
    End Sub
    Sub procByte(<MarshalAs(UnmanagedType.SafeArray, SafeArraySubType:=VarEnum.VT_BSTR)> ByVal _
    ar() As Byte)
        arLocalByte = ar
    End Sub
 
End Class

A noter que les parametres de procedures ont les attributs identiques meme s'il s'agit de parametres autres que SafeArray.

Exemple succint de declarartion de type .net en vue du marsalling(type "blittables" et "non blittables"):

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
 
'Illustre les Attributs de Declarations de  Marshalling pour les types .Net les plus courants qui ne sont pas "blittables":
Public Class ClassB
#Region "champs"
    '---------------------------------------------------------------
    'Declaration de type de base de la classe system.integer,system.double, etc...
    'appeles "Blittables" ne necessitant d'attributs de conversion(marshalling de type)
    Dim aa As Byte
    Dim ab As SByte
    Dim ac As Int16
    Dim ad As Integer
    Dim af As Double
    Dim ag As Single
    Dim pt As IntPtr 'un handle ou un pointeur en c++(32 ou 64 bits suivant plateforme)
    '---------------------------------------------------------------
    'Types non Directement Blittables de la classe System dont la conversion par defaut est la suivante:
    Dim o1 As Array   'Tableau Style c ou SafeArray COM(necessite de preciser les attributs de cette structure)
    Dim o2 As Boolean '1,2,4 octets 
    Dim o3 As Char    ' char  Unicode(si Ansi necessite de preciser un attribut)
    Dim o4 As String  'Null ou BSTR
    '---------------------------------------------------------------
    'Exemples d'utilisation des Attributs pour les types "non-Blittables"
    'quand c'est necessaire (en C ou en VB6 par exemple)
    'chaine Ansi 1 octets(asc_char)
    <MarshalAs(UnmanagedType.AnsiBStr)> _
    Dim chaineAnsi As String
    'BSTR 2 octets
    <MarshalAs(UnmanagedType.BStr)> _
    Dim chaineUnicode As String
    'Boolean 1,2,4 octets (Bool de Bool Win32)
    <MarshalAs(UnmanagedType.Bool)> _
    Dim varBool As Boolean
    'VARIANT_BOOL 2 octets (Bool de OLE COM)
    <MarshalAs(UnmanagedType.VariantBool)> _
    Dim varBoolOLE As Boolean
    'Type "Blittables" Tableau  
    'Tableaux  par Reference à longueur variable (index depart,taille tableau)
    'Integer
    <MarshalAs(UnmanagedType.LPArray, Iidparameterindex:=1, SizeConst:=10)> _
    Dim tableEntierRef() As Integer
    'Byte -> char (unsigned int)
    <MarshalAs(UnmanagedType.LPArray, Iidparameterindex:=2, SizeConst:=10)> _
    Dim tableByteRef() As Integer
    'Double
    <MarshalAs(UnmanagedType.LPArray, Iidparameterindex:=3, SizeConst:=10)> _
    Dim tableReelRef() As Double
 'Type "Non-Blittables" Tableau  
    'Tableau de chaine Unicode à taille fixe(en vb6 un string*10)
    <MarshalAs(UnmanagedType.LPArray, Iidparameterindex:=0, SizeConst:=10)> _
    Dim chaineRef() As String
 
    'Tableau de caractere Unicode à taille fixe
    <MarshalAs(UnmanagedType.LPArray, Iidparameterindex:=0, SizeConst:=10)> _
    Dim charsRef() As Char
    '---------------------------------------------------------------
    'Exemples d'utilisation de l 'Attribut UnmanagedType.ByValArray
    'autorise uniquement quand un tableau est dans une structure.
    <StructLayout(LayoutKind.Auto)> _
    Structure TestStruct
        'Tableau Entier par valeur de longueur fixe(taille tableau) _
        <MarshalAs(UnmanagedType.ByValArray, SizeConst:=10)> _
        Dim tableEntierFixe() As Integer
        'Tableau Byte par valeur de longueur fixe(taille tableau) _
        <MarshalAs(UnmanagedType.ByValArray, SizeConst:=15)> _
        Dim tableByteFixe() As Integer
        'Tableau par valeur de longueur fixe(taille tableau)
        <MarshalAs(UnmanagedType.ByValArray, SizeConst:=12)> _
        Dim tableReelFixe() As Double
    End Structure
 
    '-----------------les SafeArray   tableau AutoDescriptif----------------------------------------------
    'Exemples d'une variable Tableau Chaine destine à un SafeArray BSTR et dimension=14
    '.Net prend rang =1,limite inferieure =0
    <MarshalAs(UnmanagedType.SafeArray, SafeArraySubType:=VarEnum.VT_BSTR, Iidparameterindex:=0, SizeConst:=14)> _
    Dim chaine(14) As String
    'Exemples d'une variable Tableau Bytes destine à un SafeArray byte(VT_UI1) dimension=14
    <MarshalAs(UnmanagedType.SafeArray, SafeArraySubType:=VarEnum.VT_UI1, Iidparameterindex:=0, SizeConst:=14)> _
    Dim mesBytes(14) As Byte
    'Exemples d'une variable Tableau Object destine à un SafeArray de dimension=14
    'Object est equivalent à Variant 
    <MarshalAs(UnmanagedType.SafeArray, SafeArraySubType:=VarEnum.VT_VARIANT, Iidparameterindex:=0, SizeConst:=14)> _
    Dim mesObjets(14) As Object
#End Region
#Region "Methodes"
    'Exemple de procedures avec   parametre SafeArray
    'SafeArray manage avec Attribut  InOut et par Valeur (appel par Valeur)
    Sub proc1(<MarshalAs(UnmanagedType.SafeArray, SafeArraySubType:=VarEnum.VT_I4)> ByVal _
 ar() As Integer)
 
    End Sub
    'SafeArray manage avec Attribut avec Attribut InOut et par Valeur (appel par Valeur)
    Sub proc1(<MarshalAs(UnmanagedType.SafeArray, SafeArraySubType:=VarEnum.VT_DATE)> ByVal _
       ar() As DateTime)
    End Sub
    'SafeArray manage avec Attribut InOut et par Reference (appel  par Reference)
    Sub proc1(<MarshalAs(UnmanagedType.SafeArray, SafeArraySubType:=VarEnum.VT_BSTR)> ByRef _
   ar() As String)
    End Sub
    'SafeArray manage avec Attribut InOut et par Reference (appel  par Reference)
    Sub proc1(<MarshalAs(UnmanagedType.SafeArray, SafeArraySubType:=VarEnum.VT_BSTR)> ByRef _
   ar() As Byte)
    End Sub
    'Proc avec Attribut In et Reference
    'SafeArray manage avec Attribut InOut et par Reference (appel  par Reference)
    Sub procedure1(<InAttribute(), MarshalAs(UnmanagedType.SafeArray, SafeArraySubType:=VarEnum.VT_BSTR)> ByRef _
   ar() As Byte)
    End Sub
    'Proc avec Attribut Out et Reference
    'SafeArray manage avec Attribut InOut et par Reference (appel  par Reference)
    Sub procedure2(<OutAttribute(), MarshalAs(UnmanagedType.SafeArray, SafeArraySubType:=VarEnum.VT_BSTR)> ByRef _
   ar() As Byte)
    End Sub
#End Region
End Class

bon code.....