Summary

Class:	System.Buffers.Binary.BinaryPrimitives
Assembly:	System.Memory
File(s):	C:\GitHub\corefx\src\System.Memory\src\System\Buffers\Binary\Reader.cs C:\GitHub\corefx\src\System.Memory\src\System\Buffers\Binary\ReaderBigEndian.cs C:\GitHub\corefx\src\System.Memory\src\System\Buffers\Binary\ReaderLittleEndian.cs C:\GitHub\corefx\src\System.Memory\src\System\Buffers\Binary\Writer.cs C:\GitHub\corefx\src\System.Memory\src\System\Buffers\Binary\WriterBigEndian.cs C:\GitHub\corefx\src\System.Memory\src\System\Buffers\Binary\WriterLittleEndian.cs
Covered lines:	351
Uncovered lines:	78
Coverable lines:	429
Total lines:	994
Line coverage:	81.8%
Branch coverage:	57.1%

Metrics

Method	Cyclomatic complexity	NPath complexity	Sequence coverage	Branch coverage
ReverseEndianness(...)	1	0	100	100
ReverseEndianness(...)	1	0	100	100
ReverseEndianness(...)	1	0	100	100
ReverseEndianness(...)	1	0	100	100
ReverseEndianness(...)	1	0	100	100
ReverseEndianness(...)	1	0	100	100
ReverseEndianness(...)	1	0	100	100
ReverseEndianness(...)	1	0	100	100
ReadMachineEndian(...)	3	4	81.82	100
TryReadMachineEndian(...)	3	4	91.67	100
ReadInt16BigEndian(...)	2	2	100	66.67
ReadInt32BigEndian(...)	2	2	100	66.67
ReadInt64BigEndian(...)	2	2	100	66.67
ReadUInt16BigEndian(...)	2	2	100	66.67
ReadUInt32BigEndian(...)	2	2	100	66.67
ReadUInt64BigEndian(...)	2	2	100	66.67
TryReadInt16BigEndian(...)	2	2	100	66.67
TryReadInt32BigEndian(...)	2	2	100	66.67
TryReadInt64BigEndian(...)	2	2	100	66.67
TryReadUInt16BigEndian(...)	2	2	100	66.67
TryReadUInt32BigEndian(...)	2	2	100	66.67
TryReadUInt64BigEndian(...)	2	2	100	66.67
ReadInt16LittleEndian(...)	2	2	62.5	66.67
ReadInt32LittleEndian(...)	2	2	62.5	66.67
ReadInt64LittleEndian(...)	2	2	62.5	66.67
ReadUInt16LittleEndian(...)	2	2	62.5	66.67
ReadUInt32LittleEndian(...)	2	2	62.5	66.67
ReadUInt64LittleEndian(...)	2	2	62.5	66.67
TryReadInt16LittleEndian(...)	2	2	62.5	66.67
TryReadInt32LittleEndian(...)	2	2	62.5	66.67
TryReadInt64LittleEndian(...)	2	2	62.5	66.67
TryReadUInt16LittleEndian(...)	2	2	62.5	66.67
TryReadUInt32LittleEndian(...)	2	2	62.5	66.67
TryReadUInt64LittleEndian(...)	2	2	62.5	66.67
WriteMachineEndian(...)	3	4	81.82	100
TryWriteMachineEndian(...)	3	4	90.91	100
WriteInt16BigEndian(...)	2	2	100	66.67
WriteInt32BigEndian(...)	2	2	100	66.67
WriteInt64BigEndian(...)	2	2	100	66.67
WriteUInt16BigEndian(...)	2	2	100	66.67
WriteUInt32BigEndian(...)	2	2	100	66.67
WriteUInt64BigEndian(...)	2	2	100	66.67
TryWriteInt16BigEndian(...)	2	2	100	66.67
TryWriteInt32BigEndian(...)	2	2	100	66.67
TryWriteInt64BigEndian(...)	2	2	100	66.67
TryWriteUInt16BigEndian(...)	2	2	100	66.67
TryWriteUInt32BigEndian(...)	2	2	100	66.67
TryWriteUInt64BigEndian(...)	2	2	100	66.67
WriteInt16LittleEndian(...)	2	2	57.14	66.67
WriteInt32LittleEndian(...)	2	2	57.14	66.67
WriteInt64LittleEndian(...)	2	2	57.14	66.67
WriteUInt16LittleEndian(...)	2	2	57.14	66.67
WriteUInt32LittleEndian(...)	2	2	57.14	66.67
WriteUInt64LittleEndian(...)	2	2	57.14	66.67
TryWriteInt16LittleEndian(...)	2	2	57.14	66.67
TryWriteInt32LittleEndian(...)	2	2	57.14	66.67
TryWriteInt64LittleEndian(...)	2	2	57.14	66.67
TryWriteUInt16LittleEndian(...)	2	2	57.14	66.67
TryWriteUInt32LittleEndian(...)	2	2	57.14	66.67
TryWriteUInt64LittleEndian(...)	2	2	57.14	66.67

File(s)

C:\GitHub\corefx\src\System.Memory\src\System\Buffers\Binary\Reader.cs

	#	Line		Line coverage
		1		// Licensed to the .NET Foundation under one or more agreements.
		2		// The .NET Foundation licenses this file to you under the MIT license.
		3		// See the LICENSE file in the project root for more information.
		4
		5		using System.Runtime.CompilerServices;
		6		using System.Runtime.InteropServices;
		7
		8		#if !netstandard
		9		using Internal.Runtime.CompilerServices;
		10		#endif
		11
		12		namespace System.Buffers.Binary
		13		{
		14		/// <summary>
		15		/// Reads bytes as primitives with specific endianness
		16		/// </summary>
		17		/// <remarks>
		18		/// For native formats, MemoryExtensions.Read{T}; should be used.
		19		/// Use these helpers when you need to read specific endinanness.
		20		/// </remarks>
		21		public static partial class BinaryPrimitives
		22		{
		23		/// <summary>
		24		/// This is a no-op and added only for consistency.
		25		/// This allows the caller to read a struct of numeric primitives and reverse each field
		26		/// rather than having to skip sbyte fields.
		27		/// </summary>
		28		[CLSCompliant(false)]
		29		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		30		public static sbyte ReverseEndianness(sbyte value)
	1	31		{
	1	32		return value;
	1	33		}
		34
		35		/// <summary>
		36		/// Reverses a primitive value - performs an endianness swap
		37		/// </summary>
		38		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		39		public static short ReverseEndianness(short value)
	1	40		{
	1	41		return (short)((value & 0x00FF) << 8 | (value & 0xFF00) >> 8);
	1	42		}
		43
		44		/// <summary>
		45		/// Reverses a primitive value - performs an endianness swap
		46		/// </summary>
		47		[MethodImpl(MethodImplOptions.AggressiveInlining)]
	1	48		public static int ReverseEndianness(int value) => (int)ReverseEndianness((uint)value);
		49
		50		/// <summary>
		51		/// Reverses a primitive value - performs an endianness swap
		52		/// </summary>
		53		[MethodImpl(MethodImplOptions.AggressiveInlining)]
	1	54		public static long ReverseEndianness(long value) => (long)ReverseEndianness((ulong)value);
		55
		56		/// <summary>
		57		/// This is a no-op and added only for consistency.
		58		/// This allows the caller to read a struct of numeric primitives and reverse each field
		59		/// rather than having to skip byte fields.
		60		/// </summary>
		61		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		62		public static byte ReverseEndianness(byte value)
	1	63		{
	1	64		return value;
	1	65		}
		66
		67		/// <summary>
		68		/// Reverses a primitive value - performs an endianness swap
		69		/// </summary>
		70		[CLSCompliant(false)]
		71		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		72		public static ushort ReverseEndianness(ushort value)
	1	73		{
		74		// Don't need to AND with 0xFF00 or 0x00FF since the final
		75		// cast back to ushort will clear out all bits above [ 15 .. 00 ].
		76		// This is normally implemented via "movzx eax, ax" on the return.
		77		// Alternatively, the compiler could elide the movzx instruction
		78		// entirely if it knows the caller is only going to access "ax"
		79		// instead of "eax" / "rax" when the function returns.
		80
	1	81		return (ushort)((value >> 8) + (value << 8));
	1	82		}
		83
		84		/// <summary>
		85		/// Reverses a primitive value - performs an endianness swap
		86		/// </summary>
		87		[CLSCompliant(false)]
		88		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		89		public static uint ReverseEndianness(uint value)
	1	90		{
		91		// This takes advantage of the fact that the JIT can detect
		92		// ROL32 / ROR32 patterns and output the correct intrinsic.
		93		//
		94		// Input: value = [ ww xx yy zz ]
		95		//
		96		// First line generates : [ ww xx yy zz ]
		97		//                      & [ 00 FF 00 FF ]
		98		//                      = [ 00 xx 00 zz ]
		99		//             ROR32(8) = [ zz 00 xx 00 ]
		100		//
		101		// Second line generates: [ ww xx yy zz ]
		102		//                      & [ FF 00 FF 00 ]
		103		//                      = [ ww 00 yy 00 ]
		104		//             ROL32(8) = [ 00 yy 00 ww ]
		105		//
		106		//                (sum) = [ zz yy xx ww ]
		107		//
		108		// Testing shows that throughput increases if the AND
		109		// is performed before the ROL / ROR.
		110
	1	111		uint mask_xx_zz = (value & 0x00FF00FFU);
	1	112		uint mask_ww_yy = (value & 0xFF00FF00U);
	1	113		return ((mask_xx_zz >> 8) | (mask_xx_zz << 24))
	1	114		+ ((mask_ww_yy << 8) | (mask_ww_yy >> 24));
	1	115		}
		116
		117		/// <summary>
		118		/// Reverses a primitive value - performs an endianness swap
		119		/// </summary>
		120		[CLSCompliant(false)]
		121		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		122		public static ulong ReverseEndianness(ulong value)
	1	123		{
		124		// Operations on 32-bit values have higher throughput than
		125		// operations on 64-bit values, so decompose.
		126
	1	127		return ((ulong)ReverseEndianness((uint)value) << 32)
	1	128		+ ReverseEndianness((uint)(value >> 32));
	1	129		}
		130
		131		/// <summary>
		132		/// Reads a structure of type T out of a read-only span of bytes.
		133		/// </summary>
		134		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		135		public static T ReadMachineEndian<T>(ReadOnlySpan<byte> buffer)
		136		where T : struct
	1	137		{
		138		#if netstandard
		139		if (SpanHelpers.IsReferenceOrContainsReferences<T>())
		140		{
		141		ThrowHelper.ThrowArgumentException_InvalidTypeWithPointersNotSupported(typeof(T));
		142		}
		143		#else
	1	144		if (RuntimeHelpers.IsReferenceOrContainsReferences<T>())
	1	145		{
	1	146		ThrowHelper.ThrowArgumentException_InvalidTypeWithPointersNotSupported(typeof(T));
	0	147		}
		148		#endif
	1	149		if (Unsafe.SizeOf<T>() > buffer.Length)
	1	150		{
	1	151		ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.length);
	0	152		}
	1	153		return Unsafe.ReadUnaligned<T>(ref MemoryMarshal.GetReference(buffer));
	1	154		}
		155
		156		/// <summary>
		157		/// Reads a structure of type T out of a span of bytes.
		158		/// <returns>If the span is too small to contain the type T, return false.</returns>
		159		/// </summary>
		160		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		161		public static bool TryReadMachineEndian<T>(ReadOnlySpan<byte> buffer, out T value)
		162		where T : struct
	1	163		{
		164		#if netstandard
		165		if (SpanHelpers.IsReferenceOrContainsReferences<T>())
		166		{
		167		ThrowHelper.ThrowArgumentException_InvalidTypeWithPointersNotSupported(typeof(T));
		168		}
		169		#else
	1	170		if (RuntimeHelpers.IsReferenceOrContainsReferences<T>())
	1	171		{
	1	172		ThrowHelper.ThrowArgumentException_InvalidTypeWithPointersNotSupported(typeof(T));
	0	173		}
		174		#endif
	1	175		if (Unsafe.SizeOf<T>() > (uint)buffer.Length)
	1	176		{
	1	177		value = default;
	1	178		return false;
		179		}
	1	180		value = Unsafe.ReadUnaligned<T>(ref MemoryMarshal.GetReference(buffer));
	1	181		return true;
	1	182		}
		183		}
		184		}

C:\GitHub\corefx\src\System.Memory\src\System\Buffers\Binary\ReaderBigEndian.cs

	#	Line		Line coverage
		1		// Licensed to the .NET Foundation under one or more agreements.
		2		// The .NET Foundation licenses this file to you under the MIT license.
		3		// See the LICENSE file in the project root for more information.
		4
		5		using System.Runtime.CompilerServices;
		6
		7		namespace System.Buffers.Binary
		8		{
		9		public static partial class BinaryPrimitives
		10		{
		11		/// <summary>
		12		/// Reads an Int16 out of a read-only span of bytes as big endian.
		13		/// </summary>
		14		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		15		public static short ReadInt16BigEndian(ReadOnlySpan<byte> buffer)
	1	16		{
	1	17		short result = ReadMachineEndian<short>(buffer);
	1	18		if (BitConverter.IsLittleEndian)
	1	19		{
	1	20		result = ReverseEndianness(result);
	1	21		}
	1	22		return result;
	1	23		}
		24
		25		/// <summary>
		26		/// Reads an Int32 out of a read-only span of bytes as big endian.
		27		/// </summary>
		28		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		29		public static int ReadInt32BigEndian(ReadOnlySpan<byte> buffer)
	1	30		{
	1	31		int result = ReadMachineEndian<int>(buffer);
	1	32		if (BitConverter.IsLittleEndian)
	1	33		{
	1	34		result = ReverseEndianness(result);
	1	35		}
	1	36		return result;
	1	37		}
		38
		39		/// <summary>
		40		/// Reads an Int64 out of a read-only span of bytes as big endian.
		41		/// </summary>
		42		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		43		public static long ReadInt64BigEndian(ReadOnlySpan<byte> buffer)
	1	44		{
	1	45		long result = ReadMachineEndian<long>(buffer);
	1	46		if (BitConverter.IsLittleEndian)
	1	47		{
	1	48		result = ReverseEndianness(result);
	1	49		}
	1	50		return result;
	1	51		}
		52
		53		/// <summary>
		54		/// Reads a UInt16 out of a read-only span of bytes as big endian.
		55		/// </summary>
		56		[CLSCompliant(false)]
		57		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		58		public static ushort ReadUInt16BigEndian(ReadOnlySpan<byte> buffer)
	1	59		{
	1	60		ushort result = ReadMachineEndian<ushort>(buffer);
	1	61		if (BitConverter.IsLittleEndian)
	1	62		{
	1	63		result = ReverseEndianness(result);
	1	64		}
	1	65		return result;
	1	66		}
		67
		68		/// <summary>
		69		/// Reads a UInt32 out of a read-only span of bytes as big endian.
		70		/// </summary>
		71		[CLSCompliant(false)]
		72		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		73		public static uint ReadUInt32BigEndian(ReadOnlySpan<byte> buffer)
	1	74		{
	1	75		uint result = ReadMachineEndian<uint>(buffer);
	1	76		if (BitConverter.IsLittleEndian)
	1	77		{
	1	78		result = ReverseEndianness(result);
	1	79		}
	1	80		return result;
	1	81		}
		82
		83		/// <summary>
		84		/// Reads a UInt64 out of a read-only span of bytes as big endian.
		85		/// </summary>
		86		[CLSCompliant(false)]
		87		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		88		public static ulong ReadUInt64BigEndian(ReadOnlySpan<byte> buffer)
	1	89		{
	1	90		ulong result = ReadMachineEndian<ulong>(buffer);
	1	91		if (BitConverter.IsLittleEndian)
	1	92		{
	1	93		result = ReverseEndianness(result);
	1	94		}
	1	95		return result;
	1	96		}
		97
		98		/// <summary>
		99		/// Reads an Int16 out of a read-only span of bytes as big endian.
		100		/// <returns>If the span is too small to contain an Int16, return false.</returns>
		101		/// </summary>
		102		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		103		public static bool TryReadInt16BigEndian(ReadOnlySpan<byte> buffer, out short value)
	1	104		{
	1	105		bool success = TryReadMachineEndian(buffer, out value);
	1	106		if (BitConverter.IsLittleEndian)
	1	107		{
	1	108		value = ReverseEndianness(value);
	1	109		}
	1	110		return success;
	1	111		}
		112
		113		/// <summary>
		114		/// Reads an Int32 out of a read-only span of bytes as big endian.
		115		/// <returns>If the span is too small to contain an Int32, return false.</returns>
		116		/// </summary>
		117		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		118		public static bool TryReadInt32BigEndian(ReadOnlySpan<byte> buffer, out int value)
	1	119		{
	1	120		bool success = TryReadMachineEndian(buffer, out value);
	1	121		if (BitConverter.IsLittleEndian)
	1	122		{
	1	123		value = ReverseEndianness(value);
	1	124		}
	1	125		return success;
	1	126		}
		127
		128		/// <summary>
		129		/// Reads an Int64 out of a read-only span of bytes as big endian.
		130		/// <returns>If the span is too small to contain an Int64, return false.</returns>
		131		/// </summary>
		132		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		133		public static bool TryReadInt64BigEndian(ReadOnlySpan<byte> buffer, out long value)
	1	134		{
	1	135		bool success = TryReadMachineEndian(buffer, out value);
	1	136		if (BitConverter.IsLittleEndian)
	1	137		{
	1	138		value = ReverseEndianness(value);
	1	139		}
	1	140		return success;
	1	141		}
		142
		143		/// <summary>
		144		/// Reads a UInt16 out of a read-only span of bytes as big endian.
		145		/// <returns>If the span is too small to contain a UInt16, return false.</returns>
		146		/// </summary>
		147		[CLSCompliant(false)]
		148		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		149		public static bool TryReadUInt16BigEndian(ReadOnlySpan<byte> buffer, out ushort value)
	1	150		{
	1	151		bool success = TryReadMachineEndian(buffer, out value);
	1	152		if (BitConverter.IsLittleEndian)
	1	153		{
	1	154		value = ReverseEndianness(value);
	1	155		}
	1	156		return success;
	1	157		}
		158
		159		/// <summary>
		160		/// Reads a UInt32 out of a read-only span of bytes as big endian.
		161		/// <returns>If the span is too small to contain a UInt32, return false.</returns>
		162		/// </summary>
		163		[CLSCompliant(false)]
		164		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		165		public static bool TryReadUInt32BigEndian(ReadOnlySpan<byte> buffer, out uint value)
	1	166		{
	1	167		bool success = TryReadMachineEndian(buffer, out value);
	1	168		if (BitConverter.IsLittleEndian)
	1	169		{
	1	170		value = ReverseEndianness(value);
	1	171		}
	1	172		return success;
	1	173		}
		174
		175		/// <summary>
		176		/// Reads a UInt64 out of a read-only span of bytes as big endian.
		177		/// <returns>If the span is too small to contain a UInt64, return false.</returns>
		178		/// </summary>
		179		[CLSCompliant(false)]
		180		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		181		public static bool TryReadUInt64BigEndian(ReadOnlySpan<byte> buffer, out ulong value)
	1	182		{
	1	183		bool success = TryReadMachineEndian(buffer, out value);
	1	184		if (BitConverter.IsLittleEndian)
	1	185		{
	1	186		value = ReverseEndianness(value);
	1	187		}
	1	188		return success;
	1	189		}
		190		}
		191		}
		192

C:\GitHub\corefx\src\System.Memory\src\System\Buffers\Binary\ReaderLittleEndian.cs

	#	Line		Line coverage
		1		// Licensed to the .NET Foundation under one or more agreements.
		2		// The .NET Foundation licenses this file to you under the MIT license.
		3		// See the LICENSE file in the project root for more information.
		4
		5		using System.Runtime.CompilerServices;
		6
		7		namespace System.Buffers.Binary
		8		{
		9		public static partial class BinaryPrimitives
		10		{
		11		/// <summary>
		12		/// Reads an Int16 out of a read-only span of bytes as little endian.
		13		/// </summary>
		14		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		15		public static short ReadInt16LittleEndian(ReadOnlySpan<byte> buffer)
	1	16		{
	1	17		short result = ReadMachineEndian<short>(buffer);
	1	18		if (!BitConverter.IsLittleEndian)
	0	19		{
	0	20		result = ReverseEndianness(result);
	0	21		}
	1	22		return result;
	1	23		}
		24
		25		/// <summary>
		26		/// Reads an Int32 out of a read-only span of bytes as little endian.
		27		/// </summary>
		28		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		29		public static int ReadInt32LittleEndian(ReadOnlySpan<byte> buffer)
	1	30		{
	1	31		int result = ReadMachineEndian<int>(buffer);
	1	32		if (!BitConverter.IsLittleEndian)
	0	33		{
	0	34		result = ReverseEndianness(result);
	0	35		}
	1	36		return result;
	1	37		}
		38
		39		/// <summary>
		40		/// Reads an Int64 out of a read-only span of bytes as little endian.
		41		/// </summary>
		42		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		43		public static long ReadInt64LittleEndian(ReadOnlySpan<byte> buffer)
	1	44		{
	1	45		long result = ReadMachineEndian<long>(buffer);
	1	46		if (!BitConverter.IsLittleEndian)
	0	47		{
	0	48		result = ReverseEndianness(result);
	0	49		}
	1	50		return result;
	1	51		}
		52
		53		/// <summary>
		54		/// Reads a UInt16 out of a read-only span of bytes as little endian.
		55		/// </summary>
		56		[CLSCompliant(false)]
		57		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		58		public static ushort ReadUInt16LittleEndian(ReadOnlySpan<byte> buffer)
	1	59		{
	1	60		ushort result = ReadMachineEndian<ushort>(buffer);
	1	61		if (!BitConverter.IsLittleEndian)
	0	62		{
	0	63		result = ReverseEndianness(result);
	0	64		}
	1	65		return result;
	1	66		}
		67
		68		/// <summary>
		69		/// Reads a UInt32 out of a read-only span of bytes as little endian.
		70		/// </summary>
		71		[CLSCompliant(false)]
		72		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		73		public static uint ReadUInt32LittleEndian(ReadOnlySpan<byte> buffer)
	1	74		{
	1	75		uint result = ReadMachineEndian<uint>(buffer);
	1	76		if (!BitConverter.IsLittleEndian)
	0	77		{
	0	78		result = ReverseEndianness(result);
	0	79		}
	1	80		return result;
	1	81		}
		82
		83		/// <summary>
		84		/// Reads a UInt64 out of a read-only span of bytes as little endian.
		85		/// </summary>
		86		[CLSCompliant(false)]
		87		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		88		public static ulong ReadUInt64LittleEndian(ReadOnlySpan<byte> buffer)
	1	89		{
	1	90		ulong result = ReadMachineEndian<ulong>(buffer);
	1	91		if (!BitConverter.IsLittleEndian)
	0	92		{
	0	93		result = ReverseEndianness(result);
	0	94		}
	1	95		return result;
	1	96		}
		97
		98		/// <summary>
		99		/// Reads an Int16 out of a read-only span of bytes as little endian.
		100		/// <returns>If the span is too small to contain an Int16, return false.</returns>
		101		/// </summary>
		102		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		103		public static bool TryReadInt16LittleEndian(ReadOnlySpan<byte> buffer, out short value)
	1	104		{
	1	105		bool success = TryReadMachineEndian(buffer, out value);
	1	106		if (!BitConverter.IsLittleEndian)
	0	107		{
	0	108		value = ReverseEndianness(value);
	0	109		}
	1	110		return success;
	1	111		}
		112
		113		/// <summary>
		114		/// Reads an Int32 out of a read-only span of bytes as little endian.
		115		/// <returns>If the span is too small to contain an Int32, return false.</returns>
		116		/// </summary>
		117		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		118		public static bool TryReadInt32LittleEndian(ReadOnlySpan<byte> buffer, out int value)
	1	119		{
	1	120		bool success = TryReadMachineEndian(buffer, out value);
	1	121		if (!BitConverter.IsLittleEndian)
	0	122		{
	0	123		value = ReverseEndianness(value);
	0	124		}
	1	125		return success;
	1	126		}
		127
		128		/// <summary>
		129		/// Reads an Int64 out of a read-only span of bytes as little endian.
		130		/// <returns>If the span is too small to contain an Int64, return false.</returns>
		131		/// </summary>
		132		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		133		public static bool TryReadInt64LittleEndian(ReadOnlySpan<byte> buffer, out long value)
	1	134		{
	1	135		bool success = TryReadMachineEndian(buffer, out value);
	1	136		if (!BitConverter.IsLittleEndian)
	0	137		{
	0	138		value = ReverseEndianness(value);
	0	139		}
	1	140		return success;
	1	141		}
		142
		143		/// <summary>
		144		/// Reads a UInt16 out of a read-only span of bytes as little endian.
		145		/// <returns>If the span is too small to contain a UInt16, return false.</returns>
		146		/// </summary>
		147		[CLSCompliant(false)]
		148		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		149		public static bool TryReadUInt16LittleEndian(ReadOnlySpan<byte> buffer, out ushort value)
	1	150		{
	1	151		bool success = TryReadMachineEndian(buffer, out value);
	1	152		if (!BitConverter.IsLittleEndian)
	0	153		{
	0	154		value = ReverseEndianness(value);
	0	155		}
	1	156		return success;
	1	157		}
		158
		159		/// <summary>
		160		/// Reads a UInt32 out of a read-only span of bytes as little endian.
		161		/// <returns>If the span is too small to contain a UInt32, return false.</returns>
		162		/// </summary>
		163		[CLSCompliant(false)]
		164		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		165		public static bool TryReadUInt32LittleEndian(ReadOnlySpan<byte> buffer, out uint value)
	1	166		{
	1	167		bool success = TryReadMachineEndian(buffer, out value);
	1	168		if (!BitConverter.IsLittleEndian)
	0	169		{
	0	170		value = ReverseEndianness(value);
	0	171		}
	1	172		return success;
	1	173		}
		174
		175		/// <summary>
		176		/// Reads a UInt64 out of a read-only span of bytes as little endian.
		177		/// <returns>If the span is too small to contain a UInt64, return false.</returns>
		178		/// </summary>
		179		[CLSCompliant(false)]
		180		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		181		public static bool TryReadUInt64LittleEndian(ReadOnlySpan<byte> buffer, out ulong value)
	1	182		{
	1	183		bool success = TryReadMachineEndian(buffer, out value);
	1	184		if (!BitConverter.IsLittleEndian)
	0	185		{
	0	186		value = ReverseEndianness(value);
	0	187		}
	1	188		return success;
	1	189		}
		190		}
		191		}

C:\GitHub\corefx\src\System.Memory\src\System\Buffers\Binary\Writer.cs

	#	Line		Line coverage
		1		// Licensed to the .NET Foundation under one or more agreements.
		2		// The .NET Foundation licenses this file to you under the MIT license.
		3		// See the LICENSE file in the project root for more information.
		4
		5		using System.Runtime.CompilerServices;
		6		using System.Runtime.InteropServices;
		7
		8		#if !netstandard
		9		using Internal.Runtime.CompilerServices;
		10		#endif
		11
		12		namespace System.Buffers.Binary
		13		{
		14		public static partial class BinaryPrimitives
		15		{
		16		/// <summary>
		17		/// Writes a structure of type T into a span of bytes.
		18		/// </summary>
		19		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		20		public static void WriteMachineEndian<T>(Span<byte> buffer, ref T value)
		21		where T : struct
	1	22		{
		23		#if netstandard
		24		if (SpanHelpers.IsReferenceOrContainsReferences<T>())
		25		{
		26		ThrowHelper.ThrowArgumentException_InvalidTypeWithPointersNotSupported(typeof(T));
		27		}
		28		#else
	1	29		if (RuntimeHelpers.IsReferenceOrContainsReferences<T>())
	1	30		{
	1	31		ThrowHelper.ThrowArgumentException_InvalidTypeWithPointersNotSupported(typeof(T));
	0	32		}
		33		#endif
	1	34		if ((uint)Unsafe.SizeOf<T>() > (uint)buffer.Length)
	1	35		{
	1	36		ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.length);
	0	37		}
	1	38		Unsafe.WriteUnaligned<T>(ref MemoryMarshal.GetReference(buffer), value);
	1	39		}
		40
		41		/// <summary>
		42		/// Writes a structure of type T into a span of bytes.
		43		/// <returns>If the span is too small to contain the type T, return false.</returns>
		44		/// </summary>
		45		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		46		public static bool TryWriteMachineEndian<T>(Span<byte> buffer, ref T value)
		47		where T : struct
	1	48		{
		49		#if netstandard
		50		if (SpanHelpers.IsReferenceOrContainsReferences<T>())
		51		{
		52		ThrowHelper.ThrowArgumentException_InvalidTypeWithPointersNotSupported(typeof(T));
		53		}
		54		#else
	1	55		if (RuntimeHelpers.IsReferenceOrContainsReferences<T>())
	1	56		{
	1	57		ThrowHelper.ThrowArgumentException_InvalidTypeWithPointersNotSupported(typeof(T));
	0	58		}
		59		#endif
	1	60		if (Unsafe.SizeOf<T>() > (uint)buffer.Length)
	1	61		{
	1	62		return false;
		63		}
	1	64		Unsafe.WriteUnaligned<T>(ref MemoryMarshal.GetReference(buffer), value);
	1	65		return true;
	1	66		}
		67		}
		68		}
		69

C:\GitHub\corefx\src\System.Memory\src\System\Buffers\Binary\WriterBigEndian.cs

	#	Line		Line coverage
		1		// Licensed to the .NET Foundation under one or more agreements.
		2		// The .NET Foundation licenses this file to you under the MIT license.
		3		// See the LICENSE file in the project root for more information.
		4
		5		using System.Runtime.CompilerServices;
		6
		7		namespace System.Buffers.Binary
		8		{
		9		public static partial class BinaryPrimitives
		10		{
		11		/// <summary>
		12		/// Writes an Int16 into a span of bytes as big endian.
		13		/// </summary>
		14		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		15		public static void WriteInt16BigEndian(Span<byte> buffer, short value)
	1	16		{
	1	17		if (BitConverter.IsLittleEndian)
	1	18		{
	1	19		value = ReverseEndianness(value);
	1	20		}
	1	21		WriteMachineEndian(buffer, ref value);
	1	22		}
		23
		24		/// <summary>
		25		/// Writes an Int32 into a span of bytes as big endian.
		26		/// </summary>
		27		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		28		public static void WriteInt32BigEndian(Span<byte> buffer, int value)
	1	29		{
	1	30		if (BitConverter.IsLittleEndian)
	1	31		{
	1	32		value = ReverseEndianness(value);
	1	33		}
	1	34		WriteMachineEndian(buffer, ref value);
	1	35		}
		36
		37		/// <summary>
		38		/// Writes an Int64 into a span of bytes as big endian.
		39		/// </summary>
		40		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		41		public static void WriteInt64BigEndian(Span<byte> buffer, long value)
	1	42		{
	1	43		if (BitConverter.IsLittleEndian)
	1	44		{
	1	45		value = ReverseEndianness(value);
	1	46		}
	1	47		WriteMachineEndian(buffer, ref value);
	1	48		}
		49
		50		/// <summary>
		51		/// Write a UInt16 into a span of bytes as big endian.
		52		/// </summary>
		53		[CLSCompliant(false)]
		54		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		55		public static void WriteUInt16BigEndian(Span<byte> buffer, ushort value)
	1	56		{
	1	57		if (BitConverter.IsLittleEndian)
	1	58		{
	1	59		value = ReverseEndianness(value);
	1	60		}
	1	61		WriteMachineEndian(buffer, ref value);
	1	62		}
		63
		64		/// <summary>
		65		/// Write a UInt32 into a span of bytes as big endian.
		66		/// </summary>
		67		[CLSCompliant(false)]
		68		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		69		public static void WriteUInt32BigEndian(Span<byte> buffer, uint value)
	1	70		{
	1	71		if (BitConverter.IsLittleEndian)
	1	72		{
	1	73		value = ReverseEndianness(value);
	1	74		}
	1	75		WriteMachineEndian(buffer, ref value);
	1	76		}
		77
		78		/// <summary>
		79		/// Write a UInt64 into a span of bytes as big endian.
		80		/// </summary>
		81		[CLSCompliant(false)]
		82		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		83		public static void WriteUInt64BigEndian(Span<byte> buffer, ulong value)
	1	84		{
	1	85		if (BitConverter.IsLittleEndian)
	1	86		{
	1	87		value = ReverseEndianness(value);
	1	88		}
	1	89		WriteMachineEndian(buffer, ref value);
	1	90		}
		91
		92		/// <summary>
		93		/// Writes an Int16 into a span of bytes as big endian.
		94		/// <returns>If the span is too small to contain the value, return false.</returns>
		95		/// </summary>
		96		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		97		public static bool TryWriteInt16BigEndian(Span<byte> buffer, short value)
	1	98		{
	1	99		if (BitConverter.IsLittleEndian)
	1	100		{
	1	101		value = ReverseEndianness(value);
	1	102		}
	1	103		return TryWriteMachineEndian(buffer, ref value);
	1	104		}
		105
		106		/// <summary>
		107		/// Writes an Int32 into a span of bytes as big endian.
		108		/// <returns>If the span is too small to contain the value, return false.</returns>
		109		/// </summary>
		110		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		111		public static bool TryWriteInt32BigEndian(Span<byte> buffer, int value)
	1	112		{
	1	113		if (BitConverter.IsLittleEndian)
	1	114		{
	1	115		value = ReverseEndianness(value);
	1	116		}
	1	117		return TryWriteMachineEndian(buffer, ref value);
	1	118		}
		119
		120		/// <summary>
		121		/// Writes an Int64 into a span of bytes as big endian.
		122		/// <returns>If the span is too small to contain the value, return false.</returns>
		123		/// </summary>
		124		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		125		public static bool TryWriteInt64BigEndian(Span<byte> buffer, long value)
	1	126		{
	1	127		if (BitConverter.IsLittleEndian)
	1	128		{
	1	129		value = ReverseEndianness(value);
	1	130		}
	1	131		return TryWriteMachineEndian(buffer, ref value);
	1	132		}
		133
		134		/// <summary>
		135		/// Write a UInt16 into a span of bytes as big endian.
		136		/// <returns>If the span is too small to contain the value, return false.</returns>
		137		/// </summary>
		138		[CLSCompliant(false)]
		139		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		140		public static bool TryWriteUInt16BigEndian(Span<byte> buffer, ushort value)
	1	141		{
	1	142		if (BitConverter.IsLittleEndian)
	1	143		{
	1	144		value = ReverseEndianness(value);
	1	145		}
	1	146		return TryWriteMachineEndian(buffer, ref value);
	1	147		}
		148
		149		/// <summary>
		150		/// Write a UInt32 into a span of bytes as big endian.
		151		/// <returns>If the span is too small to contain the value, return false.</returns>
		152		/// </summary>
		153		[CLSCompliant(false)]
		154		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		155		public static bool TryWriteUInt32BigEndian(Span<byte> buffer, uint value)
	1	156		{
	1	157		if (BitConverter.IsLittleEndian)
	1	158		{
	1	159		value = ReverseEndianness(value);
	1	160		}
	1	161		return TryWriteMachineEndian(buffer, ref value);
	1	162		}
		163
		164		/// <summary>
		165		/// Write a UInt64 into a span of bytes as big endian.
		166		/// <returns>If the span is too small to contain the value, return false.</returns>
		167		/// </summary>
		168		[CLSCompliant(false)]
		169		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		170		public static bool TryWriteUInt64BigEndian(Span<byte> buffer, ulong value)
	1	171		{
	1	172		if (BitConverter.IsLittleEndian)
	1	173		{
	1	174		value = ReverseEndianness(value);
	1	175		}
	1	176		return TryWriteMachineEndian(buffer, ref value);
	1	177		}
		178		}
		179		}

C:\GitHub\corefx\src\System.Memory\src\System\Buffers\Binary\WriterLittleEndian.cs

	#	Line		Line coverage
		1		// Licensed to the .NET Foundation under one or more agreements.
		2		// The .NET Foundation licenses this file to you under the MIT license.
		3		// See the LICENSE file in the project root for more information.
		4
		5		using System.Runtime.CompilerServices;
		6
		7		namespace System.Buffers.Binary
		8		{
		9		public static partial class BinaryPrimitives
		10		{
		11		/// <summary>
		12		/// Writes an Int16 into a span of bytes as little endian.
		13		/// </summary>
		14		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		15		public static void WriteInt16LittleEndian(Span<byte> buffer, short value)
	1	16		{
	1	17		if (!BitConverter.IsLittleEndian)
	0	18		{
	0	19		value = ReverseEndianness(value);
	0	20		}
	1	21		WriteMachineEndian(buffer, ref value);
	1	22		}
		23
		24		/// <summary>
		25		/// Writes an Int32 into a span of bytes as little endian.
		26		/// </summary>
		27		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		28		public static void WriteInt32LittleEndian(Span<byte> buffer, int value)
	1	29		{
	1	30		if (!BitConverter.IsLittleEndian)
	0	31		{
	0	32		value = ReverseEndianness(value);
	0	33		}
	1	34		WriteMachineEndian(buffer, ref value);
	1	35		}
		36
		37		/// <summary>
		38		/// Writes an Int64 into a span of bytes as little endian.
		39		/// </summary>
		40		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		41		public static void WriteInt64LittleEndian(Span<byte> buffer, long value)
	1	42		{
	1	43		if (!BitConverter.IsLittleEndian)
	0	44		{
	0	45		value = ReverseEndianness(value);
	0	46		}
	1	47		WriteMachineEndian(buffer, ref value);
	1	48		}
		49
		50		/// <summary>
		51		/// Write a UInt16 into a span of bytes as little endian.
		52		/// </summary>
		53		[CLSCompliant(false)]
		54		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		55		public static void WriteUInt16LittleEndian(Span<byte> buffer, ushort value)
	1	56		{
	1	57		if (!BitConverter.IsLittleEndian)
	0	58		{
	0	59		value = ReverseEndianness(value);
	0	60		}
	1	61		WriteMachineEndian(buffer, ref value);
	1	62		}
		63
		64		/// <summary>
		65		/// Write a UInt32 into a span of bytes as little endian.
		66		/// </summary>
		67		[CLSCompliant(false)]
		68		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		69		public static void WriteUInt32LittleEndian(Span<byte> buffer, uint value)
	1	70		{
	1	71		if (!BitConverter.IsLittleEndian)
	0	72		{
	0	73		value = ReverseEndianness(value);
	0	74		}
	1	75		WriteMachineEndian(buffer, ref value);
	1	76		}
		77
		78		/// <summary>
		79		/// Write a UInt64 into a span of bytes as little endian.
		80		/// </summary>
		81		[CLSCompliant(false)]
		82		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		83		public static void WriteUInt64LittleEndian(Span<byte> buffer, ulong value)
	1	84		{
	1	85		if (!BitConverter.IsLittleEndian)
	0	86		{
	0	87		value = ReverseEndianness(value);
	0	88		}
	1	89		WriteMachineEndian(buffer, ref value);
	1	90		}
		91
		92		/// <summary>
		93		/// Writes an Int16 into a span of bytes as little endian.
		94		/// <returns>If the span is too small to contain the value, return false.</returns>
		95		/// </summary>
		96		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		97		public static bool TryWriteInt16LittleEndian(Span<byte> buffer, short value)
	1	98		{
	1	99		if (!BitConverter.IsLittleEndian)
	0	100		{
	0	101		value = ReverseEndianness(value);
	0	102		}
	1	103		return TryWriteMachineEndian(buffer, ref value);
	1	104		}
		105
		106		/// <summary>
		107		/// Writes an Int32 into a span of bytes as little endian.
		108		/// <returns>If the span is too small to contain the value, return false.</returns>
		109		/// </summary>
		110		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		111		public static bool TryWriteInt32LittleEndian(Span<byte> buffer, int value)
	1	112		{
	1	113		if (!BitConverter.IsLittleEndian)
	0	114		{
	0	115		value = ReverseEndianness(value);
	0	116		}
	1	117		return TryWriteMachineEndian(buffer, ref value);
	1	118		}
		119
		120		/// <summary>
		121		/// Writes an Int64 into a span of bytes as little endian.
		122		/// <returns>If the span is too small to contain the value, return false.</returns>
		123		/// </summary>
		124		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		125		public static bool TryWriteInt64LittleEndian(Span<byte> buffer, long value)
	1	126		{
	1	127		if (!BitConverter.IsLittleEndian)
	0	128		{
	0	129		value = ReverseEndianness(value);
	0	130		}
	1	131		return TryWriteMachineEndian(buffer, ref value);
	1	132		}
		133
		134		/// <summary>
		135		/// Write a UInt16 into a span of bytes as little endian.
		136		/// <returns>If the span is too small to contain the value, return false.</returns>
		137		/// </summary>
		138		[CLSCompliant(false)]
		139		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		140		public static bool TryWriteUInt16LittleEndian(Span<byte> buffer, ushort value)
	1	141		{
	1	142		if (!BitConverter.IsLittleEndian)
	0	143		{
	0	144		value = ReverseEndianness(value);
	0	145		}
	1	146		return TryWriteMachineEndian(buffer, ref value);
	1	147		}
		148
		149		/// <summary>
		150		/// Write a UInt32 into a span of bytes as little endian.
		151		/// <returns>If the span is too small to contain the value, return false.</returns>
		152		/// </summary>
		153		[CLSCompliant(false)]
		154		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		155		public static bool TryWriteUInt32LittleEndian(Span<byte> buffer, uint value)
	1	156		{
	1	157		if (!BitConverter.IsLittleEndian)
	0	158		{
	0	159		value = ReverseEndianness(value);
	0	160		}
	1	161		return TryWriteMachineEndian(buffer, ref value);
	1	162		}
		163
		164		/// <summary>
		165		/// Write a UInt64 into a span of bytes as little endian.
		166		/// <returns>If the span is too small to contain the value, return false.</returns>
		167		/// </summary>
		168		[CLSCompliant(false)]
		169		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		170		public static bool TryWriteUInt64LittleEndian(Span<byte> buffer, ulong value)
	1	171		{
	1	172		if (!BitConverter.IsLittleEndian)
	0	173		{
	0	174		value = ReverseEndianness(value);
	0	175		}
	1	176		return TryWriteMachineEndian(buffer, ref value);
	1	177		}
		178		}
		179		}