J'ai plusieurs fonctions dont certaines utilisent un pointeur sur tableau de structure, comment dois-je déclarer ces structure et en C# et declarer la fonction
Est ce que ceci est bon ?
public struct PntF
{
public double X;
public double Y;
};
[DllImport("bcta.Dll")]
static extern int bctaOpen(IntPtr handle, string a, int b);
[DllImport("bcta.Dll")]
static extern int bctaGetTrack(IntPtr hBcta, ref PntF Pnt, int count);
PntF []Pnt;
Est-il possible de definir un tableau de longueur fixée ?
Salut, le marshalling par défaut vers le code unsafe va fixer ton tableau en mémoire si le prototype managé de la fonction prend un tableau en paramètre mais pour les types non blittables ça peut être couteux en terme de performance. Il est possible de fixer un tableau en mémoire pour le protéger du GC avec l'instruction fixed ou la structure GCHandle.
[ StructLayout( LayoutKind.Sequential ) ]
private struct MyStruct
{
public unsafe fixed int MyArray[ 4 ]; // tableau inline.
}
private static unsafe void Main( string[ ] args )
{
MyStruct[ ] tab = new MyStruct[ 4 ]; // tableau sur le tas managé.
fixed( MyStruct* p = tab )
{
// Ici le tableau est fixé et ne sera pas déplacé par le GC.
}
}
J'ai hesité a ouvrir un nouveau sujet, mais la question reste liée a l'utilisation de pointeur et l'appel de dll
[DllImport("bcta.Dll")]
static extern int bctaOpen(IntPtr handle, string a, int b);
bctaOpen voit handle comme void ** et l'alloue (calloc en C)
Comment dois-je prototyper ma fonction en C# et declarer handle ?
Tel que je l'ai fait je me fais jeter et je peux comprendre car Handle est un pointeur et non un pointeur de pointeur ??
Je suis con ou mal réveillé mais j'ai encore rien compris
Pas toujours évident le C# quand on est imprégné d'habitudes en C
Toujours mon probleme de declarer et assigner un tableau de structure
1- Je declare une fonction de ma dll qui utilise un tableau de structures PntF dont le count est donné (count)
[DllImport("bcta.Dll")]
static extern int bctaGetTrack(IntPtr hBcta, ref PntF Pnt, int count);
2- Je declare la structure
public struct PntF
{
public double X;
public double Y;
};
3- Je declare le tableau
PntF []Pnt;
4- ICI je suis perdu Comment dois je allouer ce tableau qui n'a toujours pas de dimension ??
En C j'aurais fait Pnt[2]; ou un calloc
ref IntPtr pour le double pointeur, c'est bon, tu as trouvé tout seul.
..
3 ) Déclaration du tableau.
PntF[ ] pnt;
4 ) Allocation sur le tas managé. ( ou Marshal.AllocHGlobal pour alloué de l'espace sur le tas non-managé comme en C ).
pnt = new PnF[ 10 ]; // allocation de sizeof( PnF ) * 10
5 ) En C# il y a un garbage collector qui déplace les objets en mémoire, donc il faut fixer le tableau en mémoire avant de le passer à la dll, avec l'instruction fixed ou avec un GCHandle.. Si ton prototype managé, (celui avec dllimport ) prend un tableau en argument à la place d'un pointeur ou d'un ref, dans ce cas le marshaling par défaut va fixer le tableau le temps de l'appel de la fonction. ( c'est ce que j'ai déja écris dans le 1er message ^^ )
Je suis content de voir qu'il y'a des gens qui ont galérés sur les dll's et les passages de pointeur....
J'ai compris ce que vous aviez fait mais de mon côté je galère car je dois passer un tableau à 2 dimensions....
je dois utiliser cette fonction dans ma dll:
int MSTX_EXPORT S00X_ReadPageC240(BOOL readc240, unsigned char blocknb, unsigned char firstpage, unsigned char nbpages, unsigned char pages[][S00X_ANTICOLL_ARRAY], unsigned char *cmdstatus);
dans mon code en C#, je l'ai déclarée de cette manière:
[DllImport("MedioSTX.dll")]
static extern unsafe int S00X_ReadPageC240(bool readc240, char blocknb, char firstpage, char nbpages, char** pages, char* cmdstatus);
depuis ma fonction je l'appelle de cette façon:
char[][] pages= new char[4][];
for (int i = 0; i < 4; i++)
pages[i] = new char[8];
char cmdstatus = '0';
fixed( char** pBuffer = pages[0] )
{
S00X_ReadPageC240(true, (char)0, (char)0, (char)1, pBuffer, &cmdstatus);
}
Si quelqu'un pouvait m'expliquer comment je peux passer mon char[][] pages dans la dll pour qu'elle l'initialise.
A mon avis, t'est mal barré !
Qui a écrit ta DLL ?
Comment cette DLL peut elle connaitre la dimension que tu donne à pages ?
en particulier S00X_ANTICOLL_ARRAY ?
Dans ce genre de situation, soit tu cree une fonction d'init de la DLL qui prepare ses buffer et une fonction close qui les libere
Soit tu passe a la DLL toute l'information nécessaire pour pour qu'elle sache ou elle peurt chatouiller la memoire.
Si j'ai bien lu et compris, ni l'un ni l'autre ne sont fait ici.
char = 1 octet en C/C++ et 2 octets en C#, il faut modifier la déclaration de la fonction et remplacer les "char" par des "byte".
Il faut trouver dans le header C de ta fonction la valeur de S00X_ANTICOLL_ARRAY.
Créer un tableau managé avec le nombre de colonnes égale à S00X_ANTICOLL_ARRAY.
Pour le reste sans la documentation de ta fonction c'est pas facile.. je pense que "nbpages" est le nombre de rangée ( row ) à intitialiser coté C# avant de passer le tableau..
a aidé 94 internautes ce mois-ci