[C#] Parse/Convert single(float) to byte array

[Wilde]

Ik ben in C# bezig met een applicatie, maar ik loop even tegen een probleem op waar ik geen antwoord op kan vinden. Misschien kunnen jullie me helpen.

Ik heb de volgende declaratie om een API op te roepen:

code:

        [DllImport("kernel32.dll")] public static extern Int32 WriteProcessMemory(int hProcess, int lpBaseAddress, [In, Out] byte[] buffer, int size, out int lpNumberOfBytesWritten);

Ik wil een single wegschrijven naar een lokatie in het geheugen. Een single is 32 bits (4 bytes) lang dus ik bedacht het volgende. Ik maak een byte[] aan van 4 lang. Als ik die array handmatig vul met waarden en ik geef die array op als parameter in de writeprocessmemory lukt het prima.
Echter nu moet ik een single (of float) omzetten naar 4 losse bytes, zodat ik ze via de buffer kan wegschrijven. Iemand die weet hoe dit moet ?
De andere kant op (van Byte[] naar single) kan wel dmv "BitConverter.ToSingle(buf,0)".

Ik heb al geprobeerd de API declaratie parameter naar Single te veranderen en dan de single direct als parameter mee te geven, maar dan geeft de api een error terug.

[Verwijderd]

Zoiets? Tip: zoek 's op bit shift in C#.

C#:

byte[] byteArray = new byte[4];
byteArray[0] = (single & 0xFF000000) >> 24;
byteArray[1] = (single & 0x00FF0000) >> 16;
byteArray[2] = (single & 0x0000FF00) >> 8;
byteArray[3] = (single & 0x000000FF);

[Wilde]

Tuurlijk ! Dit ziet er goed uit.. had ik moeten weten met mijn asm kennis..

Ik krijg wel een compilerfout:

code:

byteArray[0] = (value & (Single)0xFF000000) >> 24;
Error   1   Operator '&' cannot be applied to operands of type 'float' and 'float'

Het idee lijkt me dus perfect maar ik vraag me af of je een bitwise and uit mag voeren op een float?

[ Voor 61% gewijzigd door Wilde op 28-07-2007 13:10 ]

[Verwijderd]

>> 24 is bij veel assemblers SHR 24, oftewel je schuift de bits 24 posities naar rechts. Je hoogste byte van een 32-bits single past dan opeens in een byte, en daar is de byte array weer blij mee.

Hoe je een float/double in een byte[4] moet zetten weet ik overigens niet, want dat is afhankelijk van of je op een 32 of 64-bits OS werkt, en 't .NET framework schermt dat nogal af.
En ik heb 't ook nooit nodig gehad, dus nooit uitgezocht.

edit: bovenstaande had ik ingetikt voordat ik je foutmelding had gelezen...

[ Voor 8% gewijzigd door Verwijderd op 28-07-2007 13:19 ]

[ACM]

Hoe wil je een bruikbaar resultaat krijgen uit een bitshift of een bitand met een float? Het is niet alsof alle bits dezelfde betekenis hebben en dat een and of een shift je een bruikbare nieuwe waarde oplevert?

Maar het is eigenlijk wel erg slordig dat iemand wel BitConverter.ToSingle kan vinden, maar niet even wat verder dan zijn neus lang is kijkt en de functie BitConverter.getBytes ziet staan? Nou heb ik verder nooit wat met C# gedaan, dus ik kan het verkeerd hebben... maar volgens mij is dat precies de functie die je niet over het hoofd had moeten zien

[Wilde]

Je hebt inderdaad gelijk.. Die functie doet precies hetgeen ik wil.. Dat wordt gebak uitdelen

Ik kwam er zelf zojuist ook achter door deze pagina te bestuderen, is ERG interessant voor mij en de overigen die nog wel eens stoeien met bitwise operations:

http://www.visualbuilder....type=1&id=464&group_id=13

[Verwijderd]

Kan het hier niet testen, maar volgens ACM's link (en dan even doorklikken naar de .NET 2 link) ondersteunt BitConverter.GetBytes geen floats.
En de conclusie in jouw link wekt ook niet echt veel hoop:

quote: http://www.visualbuilder....type=1&id=464&group_id=13

But that reversed number doesn't represent the one that Ricardo stated in his post. What am I doing wrong? Is anything wrong in my point of view or is the expected number wrong? I'm really curious about why there is one bit less in the expected number and how the sign bit changed.

Edit: Oeps, foutje...
Hij ondersteunt wel doubles, maar zo te zien geen decimals. En die laatste gebruik ik 't meest...

[ Voor 9% gewijzigd door Verwijderd op 28-07-2007 13:49 ]

[Wilde]

Ik heb het nu als volgt geimplementeerd:

code:

//schrijft 4 bytes vanaf index:
 public void writeProcess_Single(int index, Single value)
 {
  byte[] buf = new byte[4];
  int byteswritten = 0;
  buf = BitConverter.GetBytes(value);

  Win32.WriteProcessMemory(ProcessHandle, index, buf, 4, out byteswritten);
 }

Voor mij is het simpel om te testen. Ik lees daarna met readprocessmemory het geheugen uit en ik heb men single weer terug !