feil medlemmer rekkefølge i en C # struktur

stemmer
1

Jeg har en TCP-klient, som setter en pakke i en struktur

using System.Runtime.InteropServices;

[StructLayoutAttribute(LayoutKind.Sequential)]
public struct tPacket_5000_E
{
    public Int16 size;
    public Int16 opcode;
    public byte securityCount;
    public byte securityCRC;
    public byte flag;
    [MarshalAsAttribute(UnmanagedType.ByValArray, SizeConst = 8, ArraySubType = UnmanagedType.I1)]
    public byte[] blowfish;
    public UInt32 seedCount;
    public UInt32 seedCRC;
    [MarshalAsAttribute(UnmanagedType.ByValArray, SizeConst = 5, ArraySubType = UnmanagedType.I1)]
    public UInt32[] seedsecurity;
}

Koden Jeg bruker å sette pakken i strukturen er:

tPacket_5000_E packet = new tPacket_5000_E();
GCHandle pin = GCHandle.Alloc(data, GCHandleType.Pinned);
packet = (tPacket_5000_E)Marshal.PtrToStructure(pin.AddrOfPinnedObject(), typeof(tPacket_5000_E));
pin.Free();

Nå, før jeg fortsetter jeg må fortelle deg at jeg oversette dette prosjektet fra C ++ til C #.

Dette er problemet:

De siste 3 medlemmer av tPacket_5000_E er Int32 (i forsøkt uint32 også), som er DWORD i C ++. Verdiene før disse tre medlemmer, som er ikke Int32, er lik de i C ++. (I injisere samme pakke i både C ++ og C # prosjekt).

Men de tre medlemmene har ulike verdier.

i C ++ verdiene ( riktig ):

  1. seedCount: 0x00000079
  2. seedCRC: 0x000000D1
  3. SeedSecurity:
  4. - [0]: 0x548ac099
  5. - 1 : 0x03c4d378
  6. - [2]: 0x292e9eab
  7. - [3]: 0x4eee5ee3
  8. - [4]: ​​0x1071206e

i C # verdiene ( feil ):

  1. seedCount: 0xd1000000
  2. seedCRC: 0x99000000
  3. SeedSecurity:
  4. - [0]: 0x78548ac0
  5. - 1 : 0xab03c4d3
  6. - [2]: 0xe3292e9e
  7. - [3]: 0x6e4eee5e
  8. - [4]: ​​0x00107120

Pakken i begge søknader er lik

byte[] data = new byte[] {
0x25, 0x00, 0x00, 0x50, 0x00, 0x00, 0x0E, 0x10, 
0xCE, 0xEF, 0x47, 0xDA, 0xC3, 0xFE, 0xFF, 0x79, 
0x00, 0x00, 0x00, 0xD1, 0x00, 0x00, 0x00, 0x99, 
0xC0, 0x8A, 0x54, 0x78, 0xD3, 0xC4, 0x03, 0xAB, 
0x9E, 0x2E, 0x29, 0xE3, 0x5E, 0xEE, 0x4E, 0x6E, 
0x20, 0x71, 0x10};

Klikk her for mer informasjon

Hvorfor de siste tre medlemmer i struct er forskjellige og hvordan du løser dem?

Takk på forhånd!

Publisert på 27/03/2009 klokken 19:48
kilden bruker
På andre språk...                            


2 svar

stemmer
11

Jeg forventer at roten av problemet er at de tre byte-verdier

public byte securityCount;
public byte securityCRC;
public byte flag;

forårsaker de neste 32 bit-verdier ikke å være ord-linje, og de to sett av koden er å legge til (eller ikke tilsette) innvendig polstring på en annen måte.

Jeg forventer at de ulike pakninger se omtrent slik ut:

C ++ C #
================================ ================== ==============
[Størrelse] [opkode] [størrelse] [opkode]
[SecCnt] [secCrc] [flagg] [blow0] [secCnt] [secCrc] [flagg] [blow0]
[Blow1] [blow2] [blow3] [blow4] [blow1] [blow2] [blow3] [blow4]
[Blow5] [blow6] [blow7] [seedCou [blow5] [blow6] [blow7] .. PAD ...
nt] [seedCRC [seedCount]
                       ] [SeedSec [seedCRC]
urity0] [seedSec [seedSecurity0]
urity1] [seedSec [seedSecurity1]
urity2] [seedSec [seedSecurity2]
urity3] [seedSec [seedSecurity3]
urity4] [seedSecurity4]

... med C # innføring av en byte av stoppingen som fører til senere verdier for å være en byte av.

Du kan prøve å bruke

[StructLayout(LayoutKind.Sequential,Pack=1)]

før struct-definisjon, som skal bruke minst mulig mulig plass.

Maste Structs i C # har noen god informasjon om hvordan / hvorfor dette skjer.

Svarte 27/03/2009 kl. 19:51
kilden bruker

stemmer
1

Jeg mistenker at Daniel L er på rett spor i sitt svar.

Jeg vil prøve å legge en fjerde byte etter flagget. Min gjetning er at C ++ kompilatoren er å justere de verdiene på ordet grenser. Det ville "align" C # versjon også.

Svarte 27/03/2009 kl. 19:56
kilden bruker

Cookies help us deliver our services. By using our services, you agree to our use of cookies. Learn more