public static void WriteWord(this MemoryStream myMemoryStream, UInt16 myWord, ByteOrder myByteOrder = ByteOrder.Unmodified) { Byte[] _Bytes = null; switch (myByteOrder) { case ByteOrder.Unmodified: _Bytes = BitConverter.GetBytes(myWord); break; case ByteOrder.HostToNetwork: _Bytes = BitConverter.GetBytes(IPAddress.HostToNetworkOrder(myWord)); break; case ByteOrder.NetworkToHost: _Bytes = BitConverter.GetBytes(IPAddress.NetworkToHostOrder(myWord)); break; } myMemoryStream.WriteByte(_Bytes[0]); // high byte myMemoryStream.WriteByte(_Bytes[1]); // low byte }
/// <summary> /// Applies the specified endianess to an int32 (reverse bytes if input endianess is different from system's endianess) /// </summary> /// <param name="byteOrder">the endianess to apply</param> /// <param name="value">the value to be converted</param> /// <returns>The value with applied endainess</returns> public static int ApplyInt32(ByteOrder byteOrder, int value) { if (byteOrder == NativeByteOrder) return value; return (int)((value & 0x000000FFU) << 24 | (value & 0x0000FF00U) << 8 | (value & 0x00FF0000U) >> 8 | (value & 0xFF000000U) >> 24); }
/// <summary> /// Applies the specified endianess to an uint32 (reverse bytes if input endianess is different from system's endianess) /// </summary> /// <param name="byteOrder">the endianess to apply</param> /// <param name="value">the value to be converted</param> /// <returns>The value with applied endainess</returns> public static uint ApplyUint32(ByteOrder byteOrder, uint value) { if (byteOrder == NativeByteOrder) return value; return (value & 0x000000FFU) << 24 | (value & 0x0000FF00U) << 8 | (value & 0x00FF0000U) >> 8 | (value & 0xFF000000U) >> 24; }
/// <summary> /// Applies the specified endianess to an uint64 (reverse bytes if input endianess is different from system's endianess) /// </summary> /// <param name="byteOrder">the endianess to apply</param> /// <param name="value">the value to be converted</param> /// <returns>The value with applied endainess</returns> public static ulong ApplyUint64(ByteOrder byteOrder, ulong value) { if (byteOrder == NativeByteOrder) return value; return (value & 0x00000000000000FFUL) << 56 | (value & 0x000000000000FF00UL) << 40 | (value & 0x0000000000FF0000UL) << 24 | (value & 0x00000000FF000000UL) << 8 | (value & 0x000000FF00000000UL) >> 8 | (value & 0x0000FF0000000000UL) >> 24 | (value & 0x00FF000000000000UL) >> 40 | (value & 0xFF00000000000000UL) >> 56; }
public static unsafe float ApplyFloat(ByteOrder byteOrder, float value) { if (byteOrder == NativeByteOrder) return value; int valueInt = *(int*) &value; int applied = ApplyInt32(byteOrder, valueInt); return *(float*) &applied; }
public static unsafe byte[] GetBytes(float value, ByteOrder order) { byte[] bytes = GetBytes(value); if (order != ByteOrder.LittleEndian) { //reserver order ReverseArray(bytes); } return bytes; }
public static short ToHostOrder(short value, ByteOrder inputByteOrder) { switch (inputByteOrder) { case ByteOrder.Host: return value; case ByteOrder.Network: return IPAddress.NetworkToHostOrder(value); default: throw new ArgumentOutOfRangeException("inputByteOrder"); } }
/// <summary> /// Converts the specified bytes to an Int32. Byter order is considered. /// </summary> /// <param name="byteOrder">The byte order to use during the conversion.</param> /// <param name="bytes">The source byte array from which the bytes will be taken for conversion.</param> /// <param name="srcOffset">The offset into the source array where the bytes will be taken.</param> /// <returns></returns> public static int ToInt32(ByteOrder byteOrder, byte[] bytes, int srcOffset) { if (bytes == null) { throw new ArgumentNullException("bytes"); } int value = BitConverter.ToInt32(bytes, srcOffset); if (byteOrder == ByteOrder.BigEndian) { return IPAddress.NetworkToHostOrder(value); } return value; }
public static double ToOutputOrder(double value, ByteOrder outputByteOrder) { switch (outputByteOrder) { case ByteOrder.Host: return value; case ByteOrder.Network: return LongToDouble(IPAddress.HostToNetworkOrder(DoubleToLong(value))); default: throw new ArgumentOutOfRangeException("outputByteOrder"); } }
public static float ToOutputOrder(float value, ByteOrder outputByteOrder) { switch (outputByteOrder) { case ByteOrder.Host: return value; case ByteOrder.Network: return IntegerToFloat(IPAddress.HostToNetworkOrder(FloatToInteger(value))); default: throw new ArgumentOutOfRangeException("outputByteOrder"); } }
public static long ToOutputOrder(long value, ByteOrder outputByteOrder) { switch (outputByteOrder) { case ByteOrder.Host: return value; case ByteOrder.Network: return IPAddress.HostToNetworkOrder(value); default: throw new ArgumentOutOfRangeException("outputByteOrder"); } }
public static ushort ToHostOrder(ushort value, ByteOrder inputByteOrder) { switch (inputByteOrder) { case ByteOrder.Host: return value; case ByteOrder.Network: return SignedToUnsignedShort(IPAddress.NetworkToHostOrder(UnsignedToSignedShort(value))); default: throw new ArgumentOutOfRangeException("inputByteOrder"); } }
/// <summary> /// Converts the specified bytes to a Guid. Byter order is considered. /// </summary> /// <param name="byteOrder">The byte order to use during the conversion.</param> /// <param name="bytes">The source byte array from which the bytes will be taken for conversion.</param> /// <param name="srcOffset">The offset into the source array where the bytes will be taken.</param> /// <returns></returns> public static Guid ToGuid(ByteOrder byteOrder, byte[] bytes, int srcOffset) { if (bytes == null) { throw new ArgumentNullException("bytes"); } int segmentA = BitConverter.ToInt32(bytes, srcOffset); short segmentB = BitConverter.ToInt16(bytes, srcOffset + 4); short segmentC = BitConverter.ToInt16(bytes, srcOffset + 6); if (byteOrder == ByteOrder.BigEndian) { segmentA = IPAddress.NetworkToHostOrder(segmentA); segmentB = IPAddress.NetworkToHostOrder(segmentB); segmentC = IPAddress.NetworkToHostOrder(segmentC); } byte[] resultBytes = new byte[16]; // copy the bytes around to recreate the Guid Buffer.BlockCopy(BitConverter.GetBytes(segmentA), 0, resultBytes, 0, 4); Buffer.BlockCopy(BitConverter.GetBytes(segmentB), 0, resultBytes, 4, 2); Buffer.BlockCopy(BitConverter.GetBytes(segmentC), 0, resultBytes, 6, 2); Buffer.BlockCopy(bytes, srcOffset + 8, resultBytes, 8, 8); return new Guid(resultBytes); }
public static unsafe float ToSingle(byte[] value, int index, ByteOrder order) { if (order != ByteOrder.LittleEndian) { //reserver order ReverseArray(value); } return ToSingle(value, index); }
/// <summary> /// Applies the specified endianess to an int64 (reverse bytes if input endianess is different from system's endianess) /// </summary> /// <param name="byteOrder">the endianess to apply</param> /// <param name="value">the value to be converted</param> /// <returns>The value with applied endainess</returns> public static long ApplyInt64(ByteOrder byteOrder, long value) { if (byteOrder == NativeByteOrder) return value; return IPAddress.HostToNetworkOrder(value); }
internal double ReadDouble(ByteOrder bo) { Contract.Requires(ReadBytesLeft >= sizeof(double)); if (BitConverter.IsLittleEndian == (ByteOrder.LSB == bo)) { var result = BitConverter.ToDouble(_buf, ReadPosition); ReadPosition += 8; return result; } else { _workspace[7] = _buf[ReadPosition++]; _workspace[6] = _buf[ReadPosition++]; _workspace[5] = _buf[ReadPosition++]; _workspace[4] = _buf[ReadPosition++]; _workspace[3] = _buf[ReadPosition++]; _workspace[2] = _buf[ReadPosition++]; _workspace[1] = _buf[ReadPosition++]; _workspace[0] = _buf[ReadPosition++]; return BitConverter.ToDouble(_workspace, 0); } }
/// <summary> /// Converts the specified Int64 into a byte array. Byter order is considered. /// </summary> /// <param name="byteOrder">The byte order to use during the conversion.</param> /// <param name="value">The long to convert.</param> /// <returns></returns> public static byte[] GetBytes(ByteOrder byteOrder, long value) { if (byteOrder == ByteOrder.BigEndian) { value = IPAddress.HostToNetworkOrder(value); } return BitConverter.GetBytes(value); }
/// <summary> /// Converts the specified Guid into a byte array. Byter order is considered. /// </summary> /// <param name="byteOrder">The byte order to use during the conversion.</param> /// <param name="value">The Guid to convert.</param> /// <returns></returns> public static byte[] GetBytes(ByteOrder byteOrder, Guid value) { byte[] bytes = value.ToByteArray(); if (byteOrder == ByteOrder.BigEndian) { int segmentA = BitConverter.ToInt32(bytes, 0); short segmentB = BitConverter.ToInt16(bytes, 4); short segmentC = BitConverter.ToInt16(bytes, 6); segmentA = IPAddress.HostToNetworkOrder(segmentA); segmentB = IPAddress.HostToNetworkOrder(segmentB); segmentC = IPAddress.HostToNetworkOrder(segmentC); Buffer.BlockCopy(BitConverter.GetBytes(segmentA), 0, bytes, 0, 4); Buffer.BlockCopy(BitConverter.GetBytes(segmentB), 0, bytes, 4, 2); Buffer.BlockCopy(BitConverter.GetBytes(segmentC), 0, bytes, 6, 2); } return bytes; }
/// <summary> /// Applies the specified endianess to an uint16 (reverse bytes if input endianess is different from system's endianess) /// </summary> /// <param name="byteOrder">the endianess to apply</param> /// <param name="value">the value to be converted</param> /// <returns>The value with applied endainess</returns> public static ushort ApplyUint16(ByteOrder byteOrder, ushort value) { if (byteOrder == NativeByteOrder) return value; return (ushort)((value & 0xFFU) << 8 | (value & 0xFF00U) >> 8); }
/// <summary> /// Applies the specified endianess to a double (reverse bytes if input endianess is different from system's endianess) /// </summary> /// <param name="byteOrder">the endianess to apply</param> /// <param name="value">the value to be converted</param> /// <returns>The value with applied endainess</returns> public static double ApplyDouble(ByteOrder byteOrder, double value) { if (byteOrder == NativeByteOrder) return value; return BitConverter.Int64BitsToDouble(IPAddress.HostToNetworkOrder(BitConverter.DoubleToInt64Bits(value))); }
public static ulong ToOutputOrder(ulong value, ByteOrder outputByteOrder) { switch (outputByteOrder) { case ByteOrder.Host: return value; case ByteOrder.Network: return SignedToUnsignedLong(IPAddress.HostToNetworkOrder(UnsignedToSignedLong(value))); default: throw new ArgumentOutOfRangeException("outputByteOrder"); } }
/// <summary> /// Converts the specified bytes to a Guid. Byte order is considered. /// </summary> /// <param name="byteOrder">The byte order to use during the conversion.</param> /// <param name="bytes">The source byte array from which the bytes will be taken for conversion.</param> /// <param name="srcOffset">The offset into the source array where the bytes will be taken.</param> /// <param name="numElements">The number of elements that should be returned in the final int array.</param> /// <returns></returns> public static int[] ToInt32Array(ByteOrder byteOrder, byte[] bytes, int srcOffset, int numElements) { if (bytes == null) { throw new ArgumentNullException("bytes"); } int[] values = new int[numElements]; // this will consume 4 * N bytes for (int i = 0; i < numElements; i++) { values[i] = SocketUtilities.ToInt32(byteOrder, bytes, srcOffset + 4 * i); } return values; }
internal uint ReadUInt32(ByteOrder bo) { Contract.Requires(ReadBytesLeft >= sizeof(int)); uint result; if (BitConverter.IsLittleEndian == (bo == ByteOrder.LSB)) { result = BitConverter.ToUInt32(_buf, ReadPosition); ReadPosition += 4; } else { _workspace[3] = _buf[ReadPosition++]; _workspace[2] = _buf[ReadPosition++]; _workspace[1] = _buf[ReadPosition++]; _workspace[0] = _buf[ReadPosition++]; result = BitConverter.ToUInt32(_workspace, 0); } return result; }
/// <summary> /// Returns a byte array containing 4 * N bytes where N is the number of elements in the integer array. /// </summary> /// <param name="byteOrder">The byte order to use during the conversion.</param> /// <param name="values">The array of integers that will be used to create the byte array.</param> /// <returns></returns> public static byte[] GetBytes(ByteOrder byteOrder, int[] values) { if (values == null) { throw new ArgumentNullException("values"); } int offset = 0; byte[] resultBuffer = new byte[4 * values.Length]; foreach (int value in values) { int length = value; if (byteOrder == ByteOrder.BigEndian) { length = IPAddress.HostToNetworkOrder(length); } byte[] buffer = BitConverter.GetBytes(length); Buffer.BlockCopy(buffer, 0, resultBuffer, offset, buffer.Length); offset += buffer.Length; } return resultBuffer; }