Hey People
I am trying to send a byte-steam over the WWW. utility using something like this…
outMemStream = new MemoryStream();
outStream = new BinaryWriter(outMemStream,System.Text.UTF8Encoding.UTF8);
It sems that c# is using small endian and my server exspects BIG endian order of ints. Do anyone have a solution for this?
If you convert your data into byte-arrays, you can reverse them before sending:
byte[ ] WriteBuffer = BitConverter.GetBytes(integer);
Array.Reverse(WriteBuffer);
stream.Write(WriteBuffer, 0, WriteBuffer.Length);
You have to revert what’s coming from your server as well.
Hey
My protocol is rather advanced and consists of chunks of int,bytes texts and stuff. Reversing would produce nonsense. I made the following solution free of use.
WagBinaryReader
using UnityEngine;
using System.Collections;
using System.IO;
public class WagBinaryReader : BinaryReader {
public WagBinaryReader(Stream stream)
:base(stream){}
public WagBinaryReader(Stream s , System.Text.Encoding e)
: base(s, e){}
public short ReadInt16BE()
{
return Endian.IsBigEndian ?
ReadInt16() :
Endian.SwapInt16(ReadInt16());
}
public short ReadInt16LE()
{
return Endian.IsLittleEndian ?
ReadInt16() :
Endian.SwapInt16(ReadInt16());
}
public int ReadInt32BE()
{
return Endian.IsBigEndian ?
ReadInt32() :
Endian.SwapInt32(ReadInt32());
}
public int ReadInt32LE()
{
return Endian.IsLittleEndian ?
ReadInt32() :
Endian.SwapInt32(ReadInt32());
}
public long ReadInt64BE()
{
return Endian.IsBigEndian ?
ReadInt64() :
Endian.SwapInt64(ReadInt64());
}
public long ReadInt64LE()
{
return Endian.IsLittleEndian ?
ReadInt64() :
Endian.SwapInt64(ReadInt64());
}
public ushort ReadUInt16BE()
{
return Endian.IsBigEndian ?
ReadUInt16() :
Endian.SwapUInt16(ReadUInt16());
}
public ushort ReadUInt16LE()
{
return Endian.IsLittleEndian ?
ReadUInt16() :
Endian.SwapUInt16(ReadUInt16());
}
public uint ReadUInt32BE()
{
return Endian.IsBigEndian ?
ReadUInt32() :
Endian.SwapUInt32(ReadUInt32());
}
public uint ReadUInt32LE()
{
return Endian.IsLittleEndian ?
ReadUInt32() :
Endian.SwapUInt32(ReadUInt32());
}
public ulong ReadUInt64BE()
{
return Endian.IsBigEndian ?
ReadUInt64() :
Endian.SwapUInt64(ReadUInt64());
}
public ulong ReadUInt64LE()
{
return Endian.IsLittleEndian ?
ReadUInt64() :
Endian.SwapUInt64(ReadUInt64());
}
}
WagBinaryWriter
using UnityEngine;
using System.Collections;
using System.IO;
public class WagBinaryWriter: BinaryWriter {
public WagBinaryWriter(Stream stream)
:base(stream){}
public WagBinaryWriter(Stream s , System.Text.Encoding e)
: base(s, e){}
public void WriteInt16BE(short i )
{
Write(Endian.IsBigEndian ? i :Endian.SwapInt16(i));
}
public void WriteInt16LE(short i)
{
Write(Endian.IsLittleEndian ? i :Endian.SwapInt16(i));
}
public void WriteInt32BE(int i)
{
Write(Endian.IsBigEndian ? i :Endian.SwapInt32(i));
}
public void WriteInt32LE(int i)
{
Write(Endian.IsLittleEndian ? i :Endian.SwapInt32(i));
}
public void ReadInt64BE(long l)
{
Write(Endian.IsBigEndian ? l :Endian.SwapInt64(l));
}
public void WriteInt64LE(long l)
{
Write(Endian.IsLittleEndian ? l :Endian.SwapInt64(l));
}
public void WriteUInt16BE(ushort l)
{
Write(Endian.IsBigEndian ? l :Endian.SwapUInt16(l));
}
public void WriteUInt16LE(ushort s)
{
Write(Endian.IsLittleEndian ? s :Endian.SwapUInt16(s));
}
public void WriteUInt32BE(uint i )
{
Write(Endian.IsBigEndian ? i :Endian.SwapUInt32(i));
}
public void WriteUInt32LE(uint i)
{
Write(Endian.IsLittleEndian ? i :Endian.SwapUInt32(i));
}
public void WriteUInt64BE(ulong l)
{
Write(Endian.IsBigEndian ? l :Endian.SwapUInt64(l));
}
public void WriteUInt64LE(ulong l)
{
Write(Endian.IsLittleEndian ? l :Endian.SwapUInt64(l));
}
}
using System;
using System.Net;
public class Endian
{
static Endian()
{
_LittleEndian = BitConverter.IsLittleEndian;
}
public static short SwapInt16(short v)
{
return (short)(((v 0xff) << 8) | ((v >> 8) 0xff));
}
public static ushort SwapUInt16(ushort v)
{
return (ushort)(((v 0xff) << 8) | ((v >> 8) 0xff));
}
public static int SwapInt32(int v)
{
return (int)(((SwapInt16((short)v) 0xffff) << 0x10) |
(SwapInt16((short)(v >> 0x10)) 0xffff));
}
public static uint SwapUInt32(uint v)
{
return (uint)(((SwapUInt16((ushort)v) 0xffff) << 0x10) |
(SwapUInt16((ushort)(v >> 0x10)) 0xffff));
}
public static long SwapInt64(long v)
{
return (long)(((SwapInt32((int)v) 0xffffffffL) << 0x20) |
(SwapInt32((int)(v >> 0x20)) 0xffffffffL));
}
public static ulong SwapUInt64(ulong v)
{
return (ulong)(((SwapUInt32((uint)v) 0xffffffffL) << 0x20) |
(SwapUInt32((uint)(v >> 0x20)) 0xffffffffL));
}
public static bool IsBigEndian
{
get
{
return !_LittleEndian;
}
}
public static bool IsLittleEndian
{
get
{
return _LittleEndian;
}
}
private static readonly bool _LittleEndian;
}