Wie die Zuweisung von byte[] ist ein Zeiger in C#

Ich habe eine Funktion, die erzeugt einen CRC-Prüf-byte auf der Grundlage der Inhalte von jedem Paket.Das problem ist in der übersetzung die Funktion von C++ zu C#

C++ - code:

unsigned char GenerateCheckByte( char* packet, int length, unsigned long seed )
{
if( !packet ) return 0;
unsigned long checksum = 0xFFFFFFFF;
length &= 0x7FFF;
char* ptr = packet;
unsigned long moddedseed = seed << 8;
for( int i = 0; i < length; i++ )
    checksum = ( checksum >> 8 ) ^ table[moddedseed + ( ( *(ptr++) ^ checksum ) & 0xFF )];
unsigned char result = ( (checksum>>24)&0xFF ) + ( (checksum>>8)&0xFF ) + ( (checksum>>16)&0xFF ) + ( checksum&0xFF );
return result;
}

char*(Paket) kann auch definiert werden als LPBYTE,die Idee ist, dass der Wert zugewiesen *Paket zugeordnet ist, *ptr und wie Sie sehen, *ptr erhöht.Was bedeutet ein byte-array übergeben wird und durch die Erhöhung der Wert des Zeigers geht es zum nächsten byte.

Habe ich versucht, es zu tun in C# und nicht oft.Nach einiger harter Arbeit, die ich dachte, ein bisschen code,aber ich kann nicht ausgeführt werden 😕

C# - code

    public static unsafe byte GenerateCheckByte(byte *packet, int length, UInt32 seed )
    {
        if (*packet == 0)
        return 0;
        UInt32 checksum = 0xFFFFFFFF;
        length &= 0x7FFF;
        byte *ptr = packet;
        UInt32 moddedseed = seed << 8;
        for (int i = 0; i < length; i++)
            checksum = ( checksum >> 8 ) ^ Table.table[moddedseed + ( ( *(ptr++) ^ checksum ) & 0xFF )];
        byte result = (byte)(( (checksum>>24)&0xFF ) + ( (checksum>>8)&0xFF ) + ( (checksum>>16)&0xFF ) + ( checksum&0xFF ));
        return result;
    }

Sieht es nicht so schlimm,aber ich kann es nicht nennen

  unsafe
  {
      packetBuffer[5] = Functions.GenerateCheckByte(&packetBuffer[0], 18, packet.seedCRC);
  }

Fehler: "nehmen Sie nur die Adresse eines unfixierten Ausdruck in einer fixed-Anweisung Initialisierung"

Bitte beachten Sie

packetbuffer in C++ - und C# - Anwendung ist byte[] packetBuffer = new byte[18];

InformationsquelleAutor Ivan Prodanov | 2009-03-28

  1. 5

    Können Sie die Methode akzeptiert ein byte-array:

    public static unsafe byte GenerateCheckByte(byte[] packetArray, int length, UInt32 seed)
{
    fixed(byte *packet = packetArray)
    {
        ... etc
    }
}

    Es ist besser, um die unsichere Sachen versteckt, so viel wie möglich hinter verwalteten Schnittstellen.

    Rufen dann wäre es einfach:

    packetBuffer[5] = Functions.GenerateCheckByte(packetBuffer, 18, ...

    In der Tat, es wäre besser zu schreiben GenerateCheckByte zu betreiben, auf eine Reihe sowieso, anstatt eintauchen in unsafe Techniken:

    public static unsafe byte GenerateCheckByte(byte[] packet, int length, UInt32 seed )
{
    if (packet == null)
        throw new ArgumentNullException("packet"); //the right way in C#

    UInt32 checksum = 0xFFFFFFFF;
    length &= 0x7FFF;

    UInt32 moddedseed = seed << 8;
    for (int i = 0; i < length; i++)
        checksum = ( checksum >> 8 ) ^ Table.table[moddedseed + ( ( packet[i] ^ checksum ) & 0xFF )];
    byte result = (byte)(( (checksum>>24)&0xFF ) + ( (checksum>>8)&0xFF ) + ( (checksum>>16)&0xFF ) + ( checksum&0xFF ));
    return result;
}

    Schreiben die einfachste, sicherste Umsetzung können Sie, und nur Chaos mit Zeigern, wenn Sie einen Engpass bei der Profilerstellung.

    Sind Sie nur übersetzen eine Menge von vorhandenen C/C++ in C#? Es gibt wenig Sinn, zu tun, es sei denn, Sie bekommen einige neue Sicherheits - /Wartbarkeit aus. 🙂

    Danke für die bearbeiteten code,viel besser jetzt!

    InformationsquelleAutor Daniel Earwicker

  2. 2

    Sollten Sie keine Verwendung von unsicheren code. Wenn Sie senden in einem byte-array an die Funktion, es kann auf Sie zugreifen, ohne die Verwendung von Zeigern.

    Habe ich noch nicht getestet der code, aber es sollte so etwas wie dieses:

    byte GenerateCheckByte(byte[] packet, ulong seed) {
    if (packet == null) return 0;
    int length = packet.Length & 0x7FFF;
    ulong checksum = 0xFFFFFFFF;
    ulong moddedseed = seed << 8;
    for (int i = 0; i < length; i++) {
            checksum = (checksum >> 8) ^ table[moddedseed + ((packet[i] ^ checksum) & 0xFF)];
    }
    return (byte)(
        ((checksum >> 24) & 0xFF) +
        ((checksum >> 16) & 0xFF) +
        ((checksum >> 8) & 0xFF) +
        (checksum & 0xFF)
    );
}

    InformationsquelleAutor Guffa

  3. 1

    Müssen Sie 'pin' byte-array in den Speicher zu nutzen, als ein byte*. 

    byte checksum; 
fixed(byte* pPacketBuffer = packetBuffer)
{
    checksum = Functions.GenerateCheckByte(pPacketBuffer, 18, packet.seedCRC) 
}
packetBuffer[5] = checksum

    Referenzen:

    InformationsquelleAutor Phil Price

Schreibe einen Kommentar