struct MonsterStruct
{
string sName;
int ID;
int HP;
int Sight;
int Speed;
bool bFriendly;
float RespawnRate;
int ObjectDropped1;
float fValue1;
int ObjectDropped2;
float fValue2;
};
MonsterStruct[] Monster;
Monster = new MonsterStruct[255];
//Pretend Monster is a MonsterStruct array of 255 and is already created and filled
FileStream fs = new FileStream("Monsters.dat", FileMode.CreateNew);
BinaryWriter w = new BinaryWriter(fs);
//What would be the easest way to write it?
w.Write(??);
public byte[] Serialize(int id) { //Declare all my Byte Arrays byte[] HP, ID, Friendly, Sight, ObjectDropped1, ObjectDropped2, RespawnRate, Speed, Strength, Value1, Value2; byte[] Total = new Byte[41]; //Convert Everything To Their Own Byte Arrays HP = System.BitConverter.GetBytes(Monster[id].HP); ID = BitConverter.GetBytes(Monster[id].ID); Friendly = BitConverter.GetBytes(Monster[id].Friendly); Sight = BitConverter.GetBytes(Monster[id].Sight); ObjectDropped1 = BitConverter.GetBytes(Monster[id].ObjectDropped1); ObjectDropped2 = BitConverter.GetBytes(Monster[id].ObjectDropped2); RespawnRate = BitConverter.GetBytes(Monster[id].RespawnRate); Speed = BitConverter.GetBytes(Monster[id].Speed); Strength = BitConverter.GetBytes(Monster[id].Strength); Value1 = BitConverter.GetBytes(Monster[id].Value1); Value2 = BitConverter.GetBytes(Monster[id].Value2); //Counter to keep track of Total Index int iCount = 0; //Add all the Bytes to One Array for (int i = 0; i <= 3; i++) { Total[iCount] = ID; iCount++; } for (int i = 0; i <= 3; i++) { Total[iCount] = HP; iCount++; } for (int i = 0; i <= 3; i++) { Total[iCount] = Sight; iCount++; } for (int i = 0; i <= 3; i++) { Total[iCount] = ObjectDropped1; iCount++; } for (int i = 0; i <= 3; i++) { Total[iCount] = ObjectDropped2; iCount++; } for (int i = 0; i <= 3; i++) { Total[iCount] = RespawnRate; iCount++; } for (int i = 0; i <= 3; i++) { Total[iCount] = Speed; iCount++; } for (int i = 0; i <= 3; i++) { Total[iCount] = Strength; iCount++; } for (int i = 0; i <= 3; i++) { Total[iCount] = Value1; iCount++; } for (int i = 0; i <= 3; i++) { Total[iCount] = Value2; iCount++; } Total[iCount] = Friendly[0]; return Total; }struct MonsterStruct{ // fields... void Serialize(BinaryWriter w) { w.Write(sName); w.Write(ID); // etc. }}FileStream fs = new FileStream("Monsters.dat", FileMode.CreateNew);BinaryWriter w = new BinaryWriter(fs);MonsterStruct s;s.Serialize(w);Quote:Original post by ArchG
Thank you Undergamer for your reply, I tried to make a Function like you said, but I couldn't find a SomeAppendFuncForByte function, so I did it a little ...
Quote:Original post by mutex
Wouldn't it be easier to just use BinaryWriter to write the individual elements of the struct?
*** Source Snippet Removed ***You can't serialize the struct with one call, I don't think, hence the need to serialize its fields individually. Additionally, the documentation is unclear about the size of the length prefix for strings, stating that it's either a byte or a word.
using System.Cryptographyvoid SomeFunc(){ //... Assuming you serialized everything already into a byte array ... SHA1CryptoProvider sha = new SHA1CryptoProvider(); byte[] myHash = sha.ComputeHash(mySerializedByteArray);}// force "nice" memory layout, marshal strings as ANSI strings[StructLayout(LayoutKind.Sequential, Pack=4, CharSet = CharSet.Ansi)]struct MonsterStruct { // marshal as a constant size array (char[128]) [MarshalAs(UnmanagedType.ByValTStr, SizeConst=128)] public string sName; public int ID; public int HP; public int Sight; public int Speed; // ... // writes this instance to disc public void Save(string fileName) { // first, get the unmanaged size of the structur int size = Marshal.SizeOf(typeof(MonsterStruct)); // allocate an unmanaged buffer of the right size IntPtr data = Marshal.AllocCoTaskMem(size); try { // marshal structure to unmanaged memory // this step will copy all blittable members // For the string-member, this will re-encode // the string to a ANSI string, truncate it to 127 // characters if necessary (buffer is 128 = 127 + zero byte) Marshal.StructureToPtr(this, data, false); // create managed buffer and copy marshalled data there byte[] buffer = new byte[size]; Marshal.Copy(data, buffer, 0, buffer.Length); // write buffer using the simple stream functions using(Stream s = File.Open(fileName, FileMode.Truncate, FileAccess.Write)) { s.Write(buffer, 0, buffer.Length); } } finally { Marshal.FreeCoTaskMem(data); } } public static MonsterStruct Load(string fileName) { // first, get the unmanaged size of the structur int size = Marshal.SizeOf(typeof(MonsterStruct)); // allocate a buffer that can hold the native image of the struct byte[] buffer = new byte[size]; // read data from file using(Stream s = File.OpenRead(fileName)) { s.Read(buffer, 0, size); } // allocate unmanaged memory IntPtr ptr = Marshal.AllocCoTaskMem(buffer.Length); try { // copy buffer to unmanaged memory Marshal.Copy(buffer, 0, ptr, buffer.Length); // marshal to MonsterStruct: object ms = Marshal.PtrToStructure(ptr, typeof(MonsterStruct)); return (MonsterStruct)ms; } finally { Marshal.FreeCoTaskMem(ptr); } }};class Program { static void Main() { // create a struct MonsterStruct ms = new MonsterStruct(); ms.sName = "This is a very simple test!"; ms.ID= 1234; ms.HP = 12; ms.Sight = 20; ms.Speed = 5; // save it ms.Save("c:\\struct.bin"); // load the same struct from disc again: MonsterStruct loadedMS = MonsterStruct.Load("c:\\struct.bin"); // show on console: Console.WriteLine(loadedMS.sName); Console.WriteLine(loadedMS.ID); Console.WriteLine(loadedMS.HP); Console.WriteLine(loadedMS.Sight); Console.WriteLine(loadedMS.Speed); Console.ReadLine(); }}public void Save(string fileName) { // first, get the unmanaged size of the structur int size = Marshal.SizeOf(typeof(MonsterStruct)); // allocate a memory buffer byte[] buffer = new byte[size]; unsafe { // pin the data array and get a pointer to the first element fixed(byte * ptrBuffer = &buffer[0]) { // marshal structure to memory Marshal.StructureToPtr(this, new IntPtr(ptrBuffer), false); } } // write buffer using the simple stream functions using(Stream s = File.Open(fileName, FileMode.Truncate, FileAccess.Write)) { s.Write(buffer, 0, buffer.Length); } } public static MonsterStruct Load(string fileName) { // first, get the unmanaged size of the structur int size = Marshal.SizeOf(typeof(MonsterStruct)); // allocate a buffer that can hold the whole file byte[] buffer = new byte[size]; // read data from file using(Stream s = File.OpenRead(fileName)) { s.Read(buffer, 0, size); } unsafe { // pin the data array and get a pointer to the first element fixed(byte * ptrBuffer = &buffer[0]) { // marshal the structure to the byte array object ms = Marshal.PtrToStructure(new IntPtr(ptrBuffer), typeof(MonsterStruct)); // all done :) return (MonsterStruct)ms; } } }struct MonsterStruct { char sName[128]; int ID; int HP; int Sight; int Speed;};Quote:Original post by mutex
Wouldn't it be easier to just use BinaryWriter to write the individual elements of the struct?
*** Source Snippet Removed ***You can't serialize the struct with one call, I don't think, hence the need to serialize its fields individually. Additionally, the documentation is unclear about the size of the length prefix for strings, stating that it's either a byte or a word.
Quote:Original post by UndergamerHow about using MemoryStream and writing to it using BinaryWriter? Then you can access the byte array via MemoryStream.GetBuffer. Of course, this might be more inefficient than other methods, but for plain simplicity it looks good to me.
Thats fine and well, and I think your approach is simpler for this; however, what I was getting at was generating the data and keeping it in memory. That way if you needed to transfer that info over say a network or you needed to encrypt or hash the information you could do it directly from that byte array without the need of having to read it back from the file:
Essentially its this:
Class -> Serialize -> Byte array of Serialized Data -> Hash/Crypto/Network -> File
Instead of:
Class -> Serialize -> File -> Read Byte Array -> Hash/Crypto/Network -> File
