Discussion :

[BasicZX81]

Bonjour à tous, je sais que ma demande risque de ne pas être bien percu puisqu'il s'agit de traduire un code qui n'est pas de moi mais c'est une partie importante qui va déterminer la suite que je peux donner à mon programme sans autre solution que celle-çi.

Je bute en fait sur cet unique problème :
Que signifie cette astérisque après le type byte et comment traduire ca en vb.NET ? La traduction que je donne ci-dessous en vb.NET est approximative (converti par le site Telerik) et demande à être retouché pour coller au code C#.
Vous me seriez vraiment d'un grand secours si vous pouviez m'aider la dessus.

Code C# :

Code :

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

1
2
3
4
5
6
7
8
9
   [MethodImpl(MethodImplOptions.AggressiveInlining)]
        protected static unsafe int ToInt32(byte[] value, int startIndex) {
            fixed (byte* pbyte = &value[startIndex]) {
                if (startIndex % 4 == 0) return *(int*)pbyte;
                return BitConverter.IsLittleEndian
                        ? *pbyte | (*(pbyte + 1) << 8) | (*(pbyte + 2) << 16) | (*(pbyte + 3) << 24)
                        : (*pbyte << 24) | (*(pbyte + 1) << 16) | (*(pbyte + 2) << 8) | *(pbyte + 3);
            }
        }

Code vb.NET :

Code :

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

1
2
3
4
5
6
7
8
9
  <MethodImpl(MethodImplOptions.AggressiveInlining)>
        Protected Shared Function ToInt32(value As Byte(), startIndex As Integer) As Integer
            Dim pByte As Byte = value(startIndex)
            If startIndex Mod 4 = 0 Then
                Return CType(pbyte, Pointer(Of Integer)).Target
            End If
            Return If(BitConverter.IsLittleEndian, pbyte.Target Or ((pbyte + 1).Target << 8) Or ((pbyte + 2).Target << 16) Or ((pbyte + 3).Target << 24), (pbyte.Target << 24) Or ((pbyte + 1).Target << 16) Or ((pbyte + 2).Target << 8) Or (pbyte + 3).Target)
 
        End Function

En vous remerciant par avance.

[wallace1]

En c# ces asterisk correspondent à du code unsafe, en somme basé sur les pointeurs. VbNet ne gère pas le code Unsafe donc il faut que tu te tournes vers du marshalling tout simplement (la Classe Marshall).

A+

[BasicZX81]

Merci de me venir en aide wallace1 mais pour le coup je comprends encore moins
je crois que je vais avoir besoin de comprendre le fonctionnement de la fonction ToInt32 dans sa globalité et ce qu'a cherché à faire son auteur pour m'en sortir mais j'avoue que je ne comprends pas du tout la fonction et à quoi sert du code unsafe ?
En fouillant j'ai trouvé néanmoins ceci :

Code :

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

Dim MyInteger As Integer = Marshal.ReadInt32(MyPointer)

qui ressemble vaguement à la fonction ToInt32. Ça voudrais dire que je peux remplacer l'ensemble de la fonction par ce bout de code ? Je n'en suis pas sûre du tout.

[BasicZX81]

Bonjour à tous, malgré toute ma bonne volonté je n'ai pas avancé beaucoup sur le sujet.
Je me dit que je pourrais essayer de tester le code en suppriment toute la partie unsafe à condition que le code arrive à ce compiler.

Mais je suis tombé sur un autre exemple un peu similaire qui utilise l'indexation sur les variables de type byte, après vérification c'est cette astérisque qui autorise l'indexation. En vb.NET, je n'ai pas trouvé d'équivalent a ces variables numPtr(x) qui ne se compile pas.

Je sais pas si je suis très clair et je ne sais pas vraiment ce que je fait pour le coup , j’espère que vous pourrez m'aider.


Code C#

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
  [MethodImpl(MethodImplOptions.AggressiveInlining)]
        protected static unsafe long ToInt64(byte[] value, int startIndex) {
            fixed (byte* numPtr = &value[startIndex]) {
                if (startIndex % 8 == 0) return *(long*)numPtr;
                if (BitConverter.IsLittleEndian) {
                    return (uint)(*numPtr | numPtr[1] << 8 | numPtr[2] << 16 | numPtr[3] << 24) |
                            (long)(numPtr[4] | numPtr[5] << 8 | numPtr[6] << 16 | numPtr[7] << 24) << 32;
                }
 
                int num = *numPtr << 24 | numPtr[1] << 16 | numPtr[2] << 8 | numPtr[3];
                return (uint)(numPtr[4] << 24 | numPtr[5] << 16 | numPtr[6] << 8) | numPtr[7] | (long)num << 32;
            }
        }

Code vb.NET :

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
    <MethodImpl(MethodImplOptions.AggressiveInlining)>
    Protected Shared Function ToInt64(value As Byte(), startIndex As Integer) As Long
        Dim numPtr As Byte = value(startIndex)
        If startIndex Mod 8 = 0 Then
            Return CType(numPtr, Pointer(Of Long)).Target
        End If
        If BitConverter.IsLittleEndian Then
            Return CUInt(numPtr.Target Or numPtr(1) << 8 Or numPtr(2) << 16 Or numPtr(3) << 24) Or
                CLng(numPtr(4) Or numPtr(5) << 8 Or numPtr(6) << 16 Or numPtr(7) << 24) << 32
        End If
 
        Dim num As Integer = numPtr.Target << 24 Or numPtr(1) << 16 Or numPtr(2) << 8 Or numPtr(3)
        Return CUInt(numPtr(4) << 24 Or numPtr(5) << 16 Or numPtr(6) << 8) Or numPtr(7) Or CLng(num) << 32
 
    End Function

[jopopmk]

Salut,

les fonctions que tu veux traduire sont vraiment ces conversions ?

[BasicZX81]

Bonjour jopopmk,
Oui ce sont bien ces 2 fonctions C# que je voudrais traduire en vb.NET. Je n'ai pas changé une virgule au code C# par contre le code vb.NET est une traduction du site Telerik, ça vaux ce que ça vaux.
Une idée pour traduire ça ? Par quoi commencer ? Déjà j'ai du mal à comprendre le code C#, je ne sais pas très bien ce qu'il fait.

[DotNetMatt]

Pourquoi ne pas conserver ces methodes dans une librairie distincte en C#, et les appeler depuis ton code VB.NET ?

Comme VB.NET ne supporte pas le code unsafe, ca me parait etre la meilleure solution pour conserver des fonctionnalites identiques.

[jopopmk]

Perso j'ai pas trop de souci avec C# (enfin les premières normes, je suis pas au courant des dernières nouveautés), et comme le montre ma signature j'ai pas non plus de problème avec les pointeurs et les décalages de bit. Par contre VB c'est une toute autre histoire ! Et je suis un peu étonné de la demande :
- le framework fourni un paquet de fonctions de conversion qui roulent au poil,
- la dernière chose qui me viendrait à l'esprit c'est de faire du unsafe en .NET, y'a les C/C++ pour le code casse-gueule ^^
- quand une conversion C#/VB semble impossible on peut toujours compartimenter.

Revenons au sujet : pour un code parfaitement identique il faudra passer par du marshalling (comme indiqué par wallace1), mais peut-être qu'on peut s'approcher du comportement sans. Après tout c'est jamais qu'une concat' de bits faite via les opérateurs binaires. Comme ton pb a l'air rigolo je tenterai quelques lignes demain et je te tiendrai au jus

Deux petites question pour terminer :
- dans quelle cadre t'a-t-on spécifié ce besoin ?
- as-tu essayé les versions VB que tu nous a présentées ?

[Pol63]

- as-tu essayé les versions VB que tu nous a présentées ?

ca ne sert à rien qu'il les essaye vu que c'est une mauvaise traduction vu que vb.net ne gère pas * (et le code unsafe)
par contre mettre des fonctions dans une dll en c# ca reste utilisable en vb.net

[BasicZX81]

Bonjour et merci à tous pour vos réponses.
@jopopmk : Je n'ai pas pu exécuter le code débarrassé de sa partie Unsafe du fait que la variable Byte dans sa version "unsafe" autorise les index (voir les numPtr(x) dans la fonction ToInt64). Impossible de trouver l'équivalent en vb.NET à mon niveau. Sinon je veux bien essayer si tu as des exemples en vb.NET pour que au moins je puisse compiler et essayer le code.

Autrement, est ce quelqu'un peux me dire à quoi ça sert le code Unsafe ou plutôt quel est son intérêt dans mon cas ou en général ? (Sans trop vous étendre, c'est juste pour avoir une idée de ce qu'a voulu faire l'auteur).

En dernier recours en effet, j’essaierais de faire une dll C# référencé dans mon projet vb.NET.

Merci à vous.