DLLImport -> comment gérer un manche en C#

dans mon code C# je veux importer une DLL C++. J'utilise le dllimport et il fonctionne très bien avec un certaines fonctions. Mais dans une fonction je obtenir une POIGNÉE dont j'ai besoin plus tard pour appeler une autre fonction.

   [DllImport("SiUSBXp.dll")]
   public static extern int SI_Open(UInt32 deviceNum,ref IntPtr devHandle );   //this function gets the HANDLE
   [DllImport("SiUSBXp.dll")]
   public static extern int SI_Write([In]IntPtr devHandle, [In, Out] byte[] inputByte, UInt32 size,ref UInt32 bytesWritten); //this function needs the HANDLE

Dans mon code de ces fonctions sont appelées comme ceci:

   IntPtr devHandle = new IntPtr();
   UInt32 bytesWritten = new UInt32();
   byte[] byteArr = new byte[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
   SI_Open(0, ref devHandle);
   SI_Write(devHandle, byteArr, 10, ref bytesWritten);

Si je fais comme ça, je reçois un "Système.AccessViolationException". J'ai cherché ici et sur internet, mais il n'a pas trouver une réponse précise. Comment puis-je utiliser le IntPtr correctement, de sorte qu'il fonctionne?
En Ce Qui Concerne Meilleur

Toby

Quelle est la fonction C++ prototypes pour SI_Open et SI_Write ressembler?
Vous êtes initialisation du tableau d'octets à 10 éléments, mais est-ce suffisant pour le SI_Write fonction?
SI_STATUS WINAPI SI_Open( DWORD dwDevice, la POIGNÉE* cyHandle );
SI_STATUS WINAPI SI_Write( POIGNÉE cyHandle, LPVOID lpBuffer, DWORD dwBytesToWrite, LPDWORD lpdwBytesWritten );
Pour le tableau d'octets => il actuall travaillé avec le "même" tableau dans le Code C++. Aussi j'ai essayé quelque chose -> j'ai initialisé un IntPtr comme ce "IntPtr Test = new IntPtr()" - Lorsque j'appelle la fonction d'Écriture avec cette IntPtr il ne marche pas lever une exception...donc en fait je pense que l'erreur est liée à la IntPtr

InformationsquelleAutor Toby | 2011-05-08

c#c++dllimport handle intptr

1

Votre SI_Write fonction ressemble tout à fait comme Windows Kernel32 du WriteFile.

Donc, je voudrais faire cela:
```
[DllImport("SiUSBXp.dll", SetLastError = true)]
static extern int SI_Open(uint dwDevice, ref IntPtr cyHandle);  

[DllImport("SiUSBXp.dll", SetLastError = true)]
static extern int SI_Write(IntPtr cyHandle, byte[] lpBuffer,
   uint dwBytesToWrite, out uint lpdwBytesWritten);
```
MODIFIER: j'ai trouvé cette documentation USBXPRESS® GUIDE DU PROGRAMMEUR sur le web, et il affirme que le SI_Write prototype ressemble en fait beaucoup plus proche de WriteFile que je ne le pensais. La doc stipule ceci:
```
SI_STATUS SI_Write (HANDLE Handle, LPVOID Buffer, DWORD NumBytesToWrite,
DWORD *NumBytesWritten, OVERLAPPED* o = NULL)
```
Cela signifie que le .NET prototype devrait être plutôt ceci:
```
[DllImport("SiUSBXp.dll")]
static extern int SI_Write(IntPtr Handle, byte[] Buffer,
   uint NumBytesToWrite, out uint NumBytesWritten, IntPtr o);
```
o est facultatif, de sorte que vous pouvez passer IntPtr.Zéro.
- Malheureusement, ce doenst travail non plus... 🙁
- étrange. Peut-être que le C++ mise en œuvre fait quelque chose d'inhabituel. Lorsque vous dites qu'il ne fonctionne pas est-il toujours le AccessViolationException erreur?
- Vous exactement.... Je ne sais pas où est le problème. Je peux contourner le problème si j'ai un) déclarer le tampon dans SI_Write à l'extérieur ( mais comme déjà mentionné dans une autre réponse, c'est effectivement faux ) et - si-je faire si je reçois un étrange valeurs arrivant à l'appareil. et b) Si je déclare le nombre d'octets à écrire à zéro, mais bon c'est pas non plus une solution ^^ - Mais je pense que le problème se trouve à l'intérieur du tableau d'octets, depuis que je peux utiliser le IntPtr d'appeler le SI_Close fonction ( n'est pas mentionné ici ) sans problèmes!
- J'ai mis à jour ma réponse, pouvez-vous essayer le nouveau prototype?
- Bon eh bien j'ai une bonne et une mauvaise nouvelle: la bonne est que cette erreur ne se couche pas - POUR l'instant ^^ - la mauvaise, c'est que maintenant le SI_Write Fonction renvoie 12 ( 0x0C ) qui est définie dans l'en-tête comme: SI_SYSTEM_ERROR_CODE 0x0c - vais faire quelques essais et d'erreur maintenant et va rapporter ensuite.
- De la doc, SI_SYSTEM_ERROR_CODE signifie que vous pouvez maintenant utiliser le Maréchal.GetLastWin32Error et obtenir le "réel" sous-jacentes d'erreur windows. Notez que j'ai ajouté SetLastError pour le C# prototypes dans ma réponse afin de Maréchal.GetLastWin32Error fonctionne.
- Oh mon cher dieu - ça marche!!!!! J'ai effectivement fait un peu de changement - j'ai enlevé le "out" mot-clé à partir de la dernière IntPtr. --> static extern int SI_Write(IntPtr Poignée, byte[] Buffer, uint NumBytesToWrite, hors uint NumBytesWritten,IntPtr o); à présent, les données arrivent correctement à l'appareil et la fonction se ferme correctement! Donc en fait, je peux dire que c'est...? Ou y avait-il de mal à supprimer le mot-clé??! De toute façon j'ai déjà envie de vous dire -> je vous remercie beaucoup pour le temps de m'aider!!!
- heureux pour vous 🙂 en fait, vous avez raison sur le "out", il est préférable de ne pas le mettre, j'ai réédité ma réponse.
- Ce programme fait partie d'un projet pour l'université - si je reçois Un, je vais le consacrer à vous!! Je pensais que nous ne trouverons pas une réponse! Eh bien, je suis soulagé maintenant!! Merci encore!!! =)
InformationsquelleAutor Simon Mourier
1

Vous faites un classique programmeur C erreur, vous n'avez pas vérifier la valeur de retour des fonctions. Qui vous dit si oui ou non la fonction a échoué. Un scénario probable est que SI_Open() a renvoyé un code d'erreur. Vous l'ignorez et l'utilisation de la non initialisée poignée de la valeur de toute façon. Un kaboom n'est pas inhabituel.

La prochaine erreur, c'est que vous n'utilisez pas le CallingConvention propriété dans la [DllImport] déclaration. Il est assez probable, Cdecl est la valeur par défaut, à moins que la fonction native est déclarée auprès de __stdcall. Aussi une excellente façon d'invoquer un kaboom. Si vous avez encore des problèmes, alors vous allez avoir à déboguer le code natif.

Btw, vous vous débarrasser de l'ennui, de la syntaxe en utilisant hors au lieu de ref. Dans les deux fonctions.
```
   [DllImport("SiUSBXp.dll", CallingConvention = CallingConvention.Cdecl)]
   public static extern int SI_Open(UInt32 deviceNum, out IntPtr devHandle );
```
- J'ai fait vérifier les valeurs de retour ( et SI_Open réussit ), mais je viens d'effacer afin d'avoir une vue plus claire sur les points critiques du code source.
- Mais qu'entendez-vous par Cdecl....sa ma première fois en utilisant la dllimport...?
- N'hésitez pas à faire des recherches dans la Bibliothèque MSDN. Post mis à jour.
- Mais ne devrait-elle pas être "CallingConvention.Stdcall" au lieu de Cdecl? Parce que sur la MSDN il sais "Le destinataire de l'appel nettoie la pile. C'est le défaut de convention pour l'appel de fonctions non managées avec plate-forme de l'invoquer." ... ?
- Oui, c'est la valeur par défaut. Qui ne fonctionne que tant que responsable programmeurs C/C++ utiliser l' __stdcall mot-clé dans la déclaration. Ce qui n'est pas commun. Je ne vois pas ce code à partir d'ici, vous êtes beaucoup plus proche.
InformationsquelleAutor Hans Passant
1

essayez ceci:
```
   [DllImport("SiUSBXp.dll")]
   public static extern int SI_Open(UInt32 deviceNum, ref IntPtr devHandle);   //this function gets the HANDLE
   [DllImport("SiUSBXp.dll")]
   public static extern int SI_Write(IntPtr devHandle, ref byte[] inputByte, UInt32 size, ref UInt32 bytesWritten); //this function needs the HANDLE
```
EDIT:

@Hans Passant est droit. C'est la bonne façon de passer un byte[] dans un LPVOID paramètre. ref utilisé pour forcer un objet dans LPVOID, mais n'est pas nécessaire pour un tableau. Ce qui se passe quand vous essayez cela?
```
   [DllImport("SiUSBXp.dll")]
   public static extern int SI_Write(IntPtr devHandle, byte[] inputByte, UInt32 size, ref UInt32 bytesWritten); //this function needs the HANDLE
```
Avez-vous essayé la réponse @Simon Mourier a donné? Il a été le premier à fournir cette déclaration et sa réponse mérite d'être accepté.
- Ouais il l'a fait! Merci!!!!!!!
- Mais les octets j'essaie d'écrire ne sont pas écrites correctement sur les uC 🙁
- quelle est la valeur de bytesWritten après l'appel?
- Cette réponse ne peut pas être correct, un tableau est déjà passé comme un pointeur (LPVOID). Déclarant ref en fait un pointeur vers un pointeur (LPVOID*).
- Octets Écrits a la valeur 10 ( si c'est correct )
- ce qui est intéressant est le fait que byteArr a la valeur null ....
- Pour votre edit --> DANS ce cas, je reçois le "habituel" AccessViolation Exception.... au moins, nous avons souligné que les erreurs se trouve dans le tableau d'octets et non pas le IntPtr!
InformationsquelleAutor hsmiths
0

mauvais: static extern void DoStuff(**byte[] inputByte**);

bon: static extern void DoStuff(**[In, MarshalAs(UnmanagedType.LPArray)] byte[] inputByte**);

InformationsquelleAutor strike

Vous devez vous connecter pour publier un commentaire.