732 references to BinaryPrimitives
CodeGenerator (1)
HttpUtilities\HttpUtilities.cs (1)
312return BinaryPrimitives.ReadUInt64LittleEndian(bytes);
GenerateDocumentationAndConfigFiles (10)
src\Compilers\Core\Portable\Hashing\XxHash128.cs (5)
225low = BinaryPrimitives.ReverseEndianness(low); 226high = BinaryPrimitives.ReverseEndianness(high); 270uint combinedh = RuntimeBitOperations.RotateLeft(BinaryPrimitives.ReverseEndianness(combinedl), 13); 286seed ^= (ulong)BinaryPrimitives.ReverseEndianness((uint)seed) << 32; 324m128Low ^= BinaryPrimitives.ReverseEndianness(m128High);
src\Compilers\Core\Portable\Hashing\XxHashShared.cs (4)
161static ulong ReadLE64(ulong data) => BitConverter.IsLittleEndian ? data : BinaryPrimitives.ReverseEndianness(data); 795BinaryPrimitives.ReverseEndianness(Unsafe.ReadUnaligned<uint>(data)); 801BinaryPrimitives.ReverseEndianness(Unsafe.ReadUnaligned<ulong>(data)); 808value = BinaryPrimitives.ReverseEndianness(value);
src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\InterceptsLocationUtilities.cs (1)
104var position = BinaryPrimitives.ReadInt32LittleEndian(bytes[PositionIndex..]);
http2cat (10)
src\Shared\Http2cat\Http2Utilities.cs (4)
427BinaryPrimitives.WriteUInt16BigEndian(destination, (ushort)setting.Parameter); 428BinaryPrimitives.WriteUInt32BigEndian(destination.Slice(2), setting.Value); 765BinaryPrimitives.WriteUInt32BigEndian(payload, (uint)Http2ErrorCode.CANCEL); 807BinaryPrimitives.WriteUInt32BigEndian(buffer, (uint)sizeIncrement);
src\Shared\ServerInfrastructure\Http2\Bitshifter.cs (2)
34return BinaryPrimitives.ReadUInt32BigEndian(source) & 0x7F_FF_FF_FF; 53BinaryPrimitives.WriteUInt32BigEndian(destination, value);
src\Shared\ServerInfrastructure\Http2\Http2FrameReader.cs (4)
154frame.GoAwayErrorCode = (Http2ErrorCode)BinaryPrimitives.ReadUInt32BigEndian(extendedHeaders.Slice(4)); 175frame.RstStreamErrorCode = (Http2ErrorCode)BinaryPrimitives.ReadUInt32BigEndian(extendedHeaders); 243var id = (Http2SettingsParameter)BinaryPrimitives.ReadUInt16BigEndian(payload); 244var value = BinaryPrimitives.ReadUInt32BigEndian(payload.Slice(2));
IIS.FunctionalTests (10)
src\Shared\Http2cat\Http2Utilities.cs (4)
427BinaryPrimitives.WriteUInt16BigEndian(destination, (ushort)setting.Parameter); 428BinaryPrimitives.WriteUInt32BigEndian(destination.Slice(2), setting.Value); 765BinaryPrimitives.WriteUInt32BigEndian(payload, (uint)Http2ErrorCode.CANCEL); 807BinaryPrimitives.WriteUInt32BigEndian(buffer, (uint)sizeIncrement);
src\Shared\ServerInfrastructure\Http2\Bitshifter.cs (2)
34return BinaryPrimitives.ReadUInt32BigEndian(source) & 0x7F_FF_FF_FF; 53BinaryPrimitives.WriteUInt32BigEndian(destination, value);
src\Shared\ServerInfrastructure\Http2\Http2FrameReader.cs (4)
154frame.GoAwayErrorCode = (Http2ErrorCode)BinaryPrimitives.ReadUInt32BigEndian(extendedHeaders.Slice(4)); 175frame.RstStreamErrorCode = (Http2ErrorCode)BinaryPrimitives.ReadUInt32BigEndian(extendedHeaders); 243var id = (Http2SettingsParameter)BinaryPrimitives.ReadUInt16BigEndian(payload); 244var value = BinaryPrimitives.ReadUInt32BigEndian(payload.Slice(2));
IIS.LongTests (10)
src\Shared\Http2cat\Http2Utilities.cs (4)
427BinaryPrimitives.WriteUInt16BigEndian(destination, (ushort)setting.Parameter); 428BinaryPrimitives.WriteUInt32BigEndian(destination.Slice(2), setting.Value); 765BinaryPrimitives.WriteUInt32BigEndian(payload, (uint)Http2ErrorCode.CANCEL); 807BinaryPrimitives.WriteUInt32BigEndian(buffer, (uint)sizeIncrement);
src\Shared\ServerInfrastructure\Http2\Bitshifter.cs (2)
34return BinaryPrimitives.ReadUInt32BigEndian(source) & 0x7F_FF_FF_FF; 53BinaryPrimitives.WriteUInt32BigEndian(destination, value);
src\Shared\ServerInfrastructure\Http2\Http2FrameReader.cs (4)
154frame.GoAwayErrorCode = (Http2ErrorCode)BinaryPrimitives.ReadUInt32BigEndian(extendedHeaders.Slice(4)); 175frame.RstStreamErrorCode = (Http2ErrorCode)BinaryPrimitives.ReadUInt32BigEndian(extendedHeaders); 243var id = (Http2SettingsParameter)BinaryPrimitives.ReadUInt16BigEndian(payload); 244var value = BinaryPrimitives.ReadUInt32BigEndian(payload.Slice(2));
IIS.NewHandler.FunctionalTests (10)
src\Shared\Http2cat\Http2Utilities.cs (4)
427BinaryPrimitives.WriteUInt16BigEndian(destination, (ushort)setting.Parameter); 428BinaryPrimitives.WriteUInt32BigEndian(destination.Slice(2), setting.Value); 765BinaryPrimitives.WriteUInt32BigEndian(payload, (uint)Http2ErrorCode.CANCEL); 807BinaryPrimitives.WriteUInt32BigEndian(buffer, (uint)sizeIncrement);
src\Shared\ServerInfrastructure\Http2\Bitshifter.cs (2)
34return BinaryPrimitives.ReadUInt32BigEndian(source) & 0x7F_FF_FF_FF; 53BinaryPrimitives.WriteUInt32BigEndian(destination, value);
src\Shared\ServerInfrastructure\Http2\Http2FrameReader.cs (4)
154frame.GoAwayErrorCode = (Http2ErrorCode)BinaryPrimitives.ReadUInt32BigEndian(extendedHeaders.Slice(4)); 175frame.RstStreamErrorCode = (Http2ErrorCode)BinaryPrimitives.ReadUInt32BigEndian(extendedHeaders); 243var id = (Http2SettingsParameter)BinaryPrimitives.ReadUInt16BigEndian(payload); 244var value = BinaryPrimitives.ReadUInt32BigEndian(payload.Slice(2));
IIS.NewShim.FunctionalTests (10)
src\Shared\Http2cat\Http2Utilities.cs (4)
427BinaryPrimitives.WriteUInt16BigEndian(destination, (ushort)setting.Parameter); 428BinaryPrimitives.WriteUInt32BigEndian(destination.Slice(2), setting.Value); 765BinaryPrimitives.WriteUInt32BigEndian(payload, (uint)Http2ErrorCode.CANCEL); 807BinaryPrimitives.WriteUInt32BigEndian(buffer, (uint)sizeIncrement);
src\Shared\ServerInfrastructure\Http2\Bitshifter.cs (2)
34return BinaryPrimitives.ReadUInt32BigEndian(source) & 0x7F_FF_FF_FF; 53BinaryPrimitives.WriteUInt32BigEndian(destination, value);
src\Shared\ServerInfrastructure\Http2\Http2FrameReader.cs (4)
154frame.GoAwayErrorCode = (Http2ErrorCode)BinaryPrimitives.ReadUInt32BigEndian(extendedHeaders.Slice(4)); 175frame.RstStreamErrorCode = (Http2ErrorCode)BinaryPrimitives.ReadUInt32BigEndian(extendedHeaders); 243var id = (Http2SettingsParameter)BinaryPrimitives.ReadUInt16BigEndian(payload); 244var value = BinaryPrimitives.ReadUInt32BigEndian(payload.Slice(2));
IIS.ShadowCopy.Tests (6)
src\Shared\ServerInfrastructure\Http2\Bitshifter.cs (2)
34return BinaryPrimitives.ReadUInt32BigEndian(source) & 0x7F_FF_FF_FF; 53BinaryPrimitives.WriteUInt32BigEndian(destination, value);
src\Shared\ServerInfrastructure\Http2\Http2FrameReader.cs (4)
154frame.GoAwayErrorCode = (Http2ErrorCode)BinaryPrimitives.ReadUInt32BigEndian(extendedHeaders.Slice(4)); 175frame.RstStreamErrorCode = (Http2ErrorCode)BinaryPrimitives.ReadUInt32BigEndian(extendedHeaders); 243var id = (Http2SettingsParameter)BinaryPrimitives.ReadUInt16BigEndian(payload); 244var value = BinaryPrimitives.ReadUInt32BigEndian(payload.Slice(2));
IISExpress.FunctionalTests (10)
src\Shared\Http2cat\Http2Utilities.cs (4)
427BinaryPrimitives.WriteUInt16BigEndian(destination, (ushort)setting.Parameter); 428BinaryPrimitives.WriteUInt32BigEndian(destination.Slice(2), setting.Value); 765BinaryPrimitives.WriteUInt32BigEndian(payload, (uint)Http2ErrorCode.CANCEL); 807BinaryPrimitives.WriteUInt32BigEndian(buffer, (uint)sizeIncrement);
src\Shared\ServerInfrastructure\Http2\Bitshifter.cs (2)
34return BinaryPrimitives.ReadUInt32BigEndian(source) & 0x7F_FF_FF_FF; 53BinaryPrimitives.WriteUInt32BigEndian(destination, value);
src\Shared\ServerInfrastructure\Http2\Http2FrameReader.cs (4)
154frame.GoAwayErrorCode = (Http2ErrorCode)BinaryPrimitives.ReadUInt32BigEndian(extendedHeaders.Slice(4)); 175frame.RstStreamErrorCode = (Http2ErrorCode)BinaryPrimitives.ReadUInt32BigEndian(extendedHeaders); 243var id = (Http2SettingsParameter)BinaryPrimitives.ReadUInt16BigEndian(payload); 244var value = BinaryPrimitives.ReadUInt32BigEndian(payload.Slice(2));
InMemory.FunctionalTests (2)
Http2\Http2TestBase.cs (1)
1147BinaryPrimitives.WriteUInt32BigEndian(payload, (uint)Http2ErrorCode.CANCEL);
src\Servers\Kestrel\shared\test\PipeWriterHttp2FrameExtensions.cs (1)
102BinaryPrimitives.WriteUInt32BigEndian(writer.GetSpan(4), (uint)sizeIncrement);
Metrics (10)
src\Compilers\Core\Portable\Hashing\XxHash128.cs (5)
225low = BinaryPrimitives.ReverseEndianness(low); 226high = BinaryPrimitives.ReverseEndianness(high); 270uint combinedh = RuntimeBitOperations.RotateLeft(BinaryPrimitives.ReverseEndianness(combinedl), 13); 286seed ^= (ulong)BinaryPrimitives.ReverseEndianness((uint)seed) << 32; 324m128Low ^= BinaryPrimitives.ReverseEndianness(m128High);
src\Compilers\Core\Portable\Hashing\XxHashShared.cs (4)
161static ulong ReadLE64(ulong data) => BitConverter.IsLittleEndian ? data : BinaryPrimitives.ReverseEndianness(data); 795BinaryPrimitives.ReverseEndianness(Unsafe.ReadUnaligned<uint>(data)); 801BinaryPrimitives.ReverseEndianness(Unsafe.ReadUnaligned<ulong>(data)); 808value = BinaryPrimitives.ReverseEndianness(value);
src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\InterceptsLocationUtilities.cs (1)
104var position = BinaryPrimitives.ReadInt32LittleEndian(bytes[PositionIndex..]);
Metrics.Legacy (10)
src\Compilers\Core\Portable\Hashing\XxHash128.cs (5)
225low = BinaryPrimitives.ReverseEndianness(low); 226high = BinaryPrimitives.ReverseEndianness(high); 270uint combinedh = RuntimeBitOperations.RotateLeft(BinaryPrimitives.ReverseEndianness(combinedl), 13); 286seed ^= (ulong)BinaryPrimitives.ReverseEndianness((uint)seed) << 32; 324m128Low ^= BinaryPrimitives.ReverseEndianness(m128High);
src\Compilers\Core\Portable\Hashing\XxHashShared.cs (4)
161static ulong ReadLE64(ulong data) => BitConverter.IsLittleEndian ? data : BinaryPrimitives.ReverseEndianness(data); 795BinaryPrimitives.ReverseEndianness(Unsafe.ReadUnaligned<uint>(data)); 801BinaryPrimitives.ReverseEndianness(Unsafe.ReadUnaligned<ulong>(data)); 808value = BinaryPrimitives.ReverseEndianness(value);
src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\InterceptsLocationUtilities.cs (1)
104var position = BinaryPrimitives.ReadInt32LittleEndian(bytes[PositionIndex..]);
Microsoft.AspNetCore.Components.Server (3)
src\submodules\MessagePack-CSharp\src\MessagePack.UnityClient\Assets\Scripts\MessagePack\SequenceReaderExtensions.cs (3)
164value = BinaryPrimitives.ReverseEndianness(value); 205value = BinaryPrimitives.ReverseEndianness(value); 246value = BinaryPrimitives.ReverseEndianness(value);
Microsoft.AspNetCore.Components.Server.Tests (1)
Circuits\RenderBatchWriterTest.cs (1)
356=> BinaryPrimitives.ReadInt32LittleEndian(bytes.Slice(startOffset, 4));
Microsoft.AspNetCore.DataProtection (2)
KeyManagement\KeyRingBasedDataProtector.cs (2)
388BinaryPrimitives.WriteUInt32BigEndian(targetSpan.Slice(0), MAGIC_HEADER_V0); 391BinaryPrimitives.WriteInt32BigEndian(targetSpan.Slice(4 + keySize), targetLength);
Microsoft.AspNetCore.Identity (2)
Passkeys\AttestedCredentialData.cs (1)
64var credentialIdLength = BinaryPrimitives.ReadUInt16BigEndian(data.Slice(offset, CredentialIdLengthLength).Span);
Passkeys\AuthenticatorData.cs (1)
113var signCount = BinaryPrimitives.ReadUInt32BigEndian(bytes.Slice(offset, SignCountLength).Span);
Microsoft.AspNetCore.Identity.Test (2)
Passkeys\CredentialHelpers.cs (2)
22BinaryPrimitives.WriteUInt16BigEndian(result.AsSpan(offset, CredentialIdLengthLength), (ushort)args.CredentialId.Length); 59BinaryPrimitives.WriteUInt32BigEndian(result.AsSpan(offset, SignCountLength), args.SignCount);
Microsoft.AspNetCore.Server.HttpSys.FunctionalTests (10)
src\Shared\Http2cat\Http2Utilities.cs (4)
427BinaryPrimitives.WriteUInt16BigEndian(destination, (ushort)setting.Parameter); 428BinaryPrimitives.WriteUInt32BigEndian(destination.Slice(2), setting.Value); 765BinaryPrimitives.WriteUInt32BigEndian(payload, (uint)Http2ErrorCode.CANCEL); 807BinaryPrimitives.WriteUInt32BigEndian(buffer, (uint)sizeIncrement);
src\Shared\ServerInfrastructure\Http2\Bitshifter.cs (2)
34return BinaryPrimitives.ReadUInt32BigEndian(source) & 0x7F_FF_FF_FF; 53BinaryPrimitives.WriteUInt32BigEndian(destination, value);
src\Shared\ServerInfrastructure\Http2\Http2FrameReader.cs (4)
154frame.GoAwayErrorCode = (Http2ErrorCode)BinaryPrimitives.ReadUInt32BigEndian(extendedHeaders.Slice(4)); 175frame.RstStreamErrorCode = (Http2ErrorCode)BinaryPrimitives.ReadUInt32BigEndian(extendedHeaders); 243var id = (Http2SettingsParameter)BinaryPrimitives.ReadUInt16BigEndian(payload); 244var value = BinaryPrimitives.ReadUInt32BigEndian(payload.Slice(2));
Microsoft.AspNetCore.Server.Kestrel.Core (26)
Internal\Http\HttpHeaders.Generated.cs (3)
7489result = BinaryPrimitives.ReverseEndianness(result); 7499result = BinaryPrimitives.ReverseEndianness(result); 7509result = BinaryPrimitives.ReverseEndianness(result);
Internal\Http2\Http2FrameWriter.cs (4)
887BinaryPrimitives.WriteUInt32BigEndian(buffer, (uint)errorCode); 928BinaryPrimitives.WriteUInt16BigEndian(destination, (ushort)setting.Parameter); 929BinaryPrimitives.WriteUInt32BigEndian(destination.Slice(2), setting.Value); 1002BinaryPrimitives.WriteUInt32BigEndian(buffer, (uint)errorCode);
Internal\Infrastructure\HttpUtilities.cs (7)
61return BinaryPrimitives.ReadUInt64LittleEndian(bytes); 73return BinaryPrimitives.ReadUInt32LittleEndian(bytes); 80return BinaryPrimitives.ReadUInt64LittleEndian(bytes); 219if (BinaryPrimitives.ReadUInt32LittleEndian(span) == _httpGetMethodInt) 226var value = BinaryPrimitives.ReadUInt64LittleEndian(span); 411if (BinaryPrimitives.TryReadUInt64LittleEndian(span, out var version)) 434if (BinaryPrimitives.TryReadUInt64LittleEndian(span, out var scheme))
src\Shared\runtime\Http3\Helpers\VariableLengthIntegerHelper.cs (6)
53if (BinaryPrimitives.TryReadUInt16BigEndian(buffer, out ushort serializedShort)) 61if (BinaryPrimitives.TryReadUInt32BigEndian(buffer, out uint serializedInt)) 70if (BinaryPrimitives.TryReadUInt64BigEndian(buffer, out ulong serializedLong)) 163if (BinaryPrimitives.TryWriteUInt16BigEndian(buffer, (ushort)((uint)longToEncode | TwoByteLengthMask))) 171if (BinaryPrimitives.TryWriteUInt32BigEndian(buffer, (uint)longToEncode | FourByteLengthMask)) 179if (BinaryPrimitives.TryWriteUInt64BigEndian(buffer, (ulong)longToEncode | EightByteLengthMask))
src\Shared\ServerInfrastructure\Http2\Bitshifter.cs (2)
34return BinaryPrimitives.ReadUInt32BigEndian(source) & 0x7F_FF_FF_FF; 53BinaryPrimitives.WriteUInt32BigEndian(destination, value);
src\Shared\ServerInfrastructure\Http2\Http2FrameReader.cs (4)
154frame.GoAwayErrorCode = (Http2ErrorCode)BinaryPrimitives.ReadUInt32BigEndian(extendedHeaders.Slice(4)); 175frame.RstStreamErrorCode = (Http2ErrorCode)BinaryPrimitives.ReadUInt32BigEndian(extendedHeaders); 243var id = (Http2SettingsParameter)BinaryPrimitives.ReadUInt16BigEndian(payload); 244var value = BinaryPrimitives.ReadUInt32BigEndian(payload.Slice(2));
Microsoft.AspNetCore.Server.Kestrel.Core.Tests (1)
src\Servers\Kestrel\shared\test\PipeWriterHttp2FrameExtensions.cs (1)
102BinaryPrimitives.WriteUInt32BigEndian(writer.GetSpan(4), (uint)sizeIncrement);
Microsoft.AspNetCore.Server.Kestrel.Microbenchmarks (2)
BinaryPrimitivesBenchmark.cs (1)
39v = BinaryPrimitives.ReadUInt32BigEndian(_data.AsSpan());
src\Servers\Kestrel\shared\test\PipeWriterHttp2FrameExtensions.cs (1)
102BinaryPrimitives.WriteUInt32BigEndian(writer.GetSpan(4), (uint)sizeIncrement);
Microsoft.AspNetCore.Shared.Tests (12)
src\Shared\runtime\Http3\Helpers\VariableLengthIntegerHelper.cs (6)
53if (BinaryPrimitives.TryReadUInt16BigEndian(buffer, out ushort serializedShort)) 61if (BinaryPrimitives.TryReadUInt32BigEndian(buffer, out uint serializedInt)) 70if (BinaryPrimitives.TryReadUInt64BigEndian(buffer, out ulong serializedLong)) 163if (BinaryPrimitives.TryWriteUInt16BigEndian(buffer, (ushort)((uint)longToEncode | TwoByteLengthMask))) 171if (BinaryPrimitives.TryWriteUInt32BigEndian(buffer, (uint)longToEncode | FourByteLengthMask)) 179if (BinaryPrimitives.TryWriteUInt64BigEndian(buffer, (ulong)longToEncode | EightByteLengthMask))
src\Shared\ServerInfrastructure\Http2\Bitshifter.cs (2)
34return BinaryPrimitives.ReadUInt32BigEndian(source) & 0x7F_FF_FF_FF; 53BinaryPrimitives.WriteUInt32BigEndian(destination, value);
src\Shared\ServerInfrastructure\Http2\Http2FrameReader.cs (4)
154frame.GoAwayErrorCode = (Http2ErrorCode)BinaryPrimitives.ReadUInt32BigEndian(extendedHeaders.Slice(4)); 175frame.RstStreamErrorCode = (Http2ErrorCode)BinaryPrimitives.ReadUInt32BigEndian(extendedHeaders); 243var id = (Http2SettingsParameter)BinaryPrimitives.ReadUInt16BigEndian(payload); 244var value = BinaryPrimitives.ReadUInt32BigEndian(payload.Slice(2));
Microsoft.CodeAnalysis (16)
CryptographicHashProvider.cs (5)
262BinaryPrimitives.WriteInt32LittleEndian(span, bits[0]); 263BinaryPrimitives.WriteInt32LittleEndian(span.Slice(4), bits[1]); 264BinaryPrimitives.WriteInt32LittleEndian(span.Slice(8), bits[2]); 265BinaryPrimitives.WriteInt32LittleEndian(span.Slice(12), bits[3]); 276BinaryPrimitives.WriteUInt32LittleEndian(bytes, value);
Hashing\XxHash128.cs (5)
225low = BinaryPrimitives.ReverseEndianness(low); 226high = BinaryPrimitives.ReverseEndianness(high); 270uint combinedh = RuntimeBitOperations.RotateLeft(BinaryPrimitives.ReverseEndianness(combinedl), 13); 286seed ^= (ulong)BinaryPrimitives.ReverseEndianness((uint)seed) << 32; 324m128Low ^= BinaryPrimitives.ReverseEndianness(m128High);
Hashing\XxHashShared.cs (4)
161static ulong ReadLE64(ulong data) => BitConverter.IsLittleEndian ? data : BinaryPrimitives.ReverseEndianness(data); 795BinaryPrimitives.ReverseEndianness(Unsafe.ReadUnaligned<uint>(data)); 801BinaryPrimitives.ReverseEndianness(Unsafe.ReadUnaligned<ulong>(data)); 808value = BinaryPrimitives.ReverseEndianness(value);
InternalUtilities\LittleEndianReader.cs (1)
7using static System.Buffers.Binary.BinaryPrimitives;
Text\SourceText.cs (1)
656BinaryPrimitives.ReverseEndianness(source: shortSpan, destination: shortSpan);
Microsoft.CodeAnalysis.Analyzers (10)
src\Compilers\Core\Portable\Hashing\XxHash128.cs (5)
225low = BinaryPrimitives.ReverseEndianness(low); 226high = BinaryPrimitives.ReverseEndianness(high); 270uint combinedh = RuntimeBitOperations.RotateLeft(BinaryPrimitives.ReverseEndianness(combinedl), 13); 286seed ^= (ulong)BinaryPrimitives.ReverseEndianness((uint)seed) << 32; 324m128Low ^= BinaryPrimitives.ReverseEndianness(m128High);
src\Compilers\Core\Portable\Hashing\XxHashShared.cs (4)
161static ulong ReadLE64(ulong data) => BitConverter.IsLittleEndian ? data : BinaryPrimitives.ReverseEndianness(data); 795BinaryPrimitives.ReverseEndianness(Unsafe.ReadUnaligned<uint>(data)); 801BinaryPrimitives.ReverseEndianness(Unsafe.ReadUnaligned<ulong>(data)); 808value = BinaryPrimitives.ReverseEndianness(value);
src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\InterceptsLocationUtilities.cs (1)
104var position = BinaryPrimitives.ReadInt32LittleEndian(bytes[PositionIndex..]);
Microsoft.CodeAnalysis.AnalyzerUtilities (10)
src\Compilers\Core\Portable\Hashing\XxHash128.cs (5)
225low = BinaryPrimitives.ReverseEndianness(low); 226high = BinaryPrimitives.ReverseEndianness(high); 270uint combinedh = RuntimeBitOperations.RotateLeft(BinaryPrimitives.ReverseEndianness(combinedl), 13); 286seed ^= (ulong)BinaryPrimitives.ReverseEndianness((uint)seed) << 32; 324m128Low ^= BinaryPrimitives.ReverseEndianness(m128High);
src\Compilers\Core\Portable\Hashing\XxHashShared.cs (4)
161static ulong ReadLE64(ulong data) => BitConverter.IsLittleEndian ? data : BinaryPrimitives.ReverseEndianness(data); 795BinaryPrimitives.ReverseEndianness(Unsafe.ReadUnaligned<uint>(data)); 801BinaryPrimitives.ReverseEndianness(Unsafe.ReadUnaligned<ulong>(data)); 808value = BinaryPrimitives.ReverseEndianness(value);
src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\InterceptsLocationUtilities.cs (1)
104var position = BinaryPrimitives.ReadInt32LittleEndian(bytes[PositionIndex..]);
Microsoft.CodeAnalysis.BannedApiAnalyzers (10)
src\Compilers\Core\Portable\Hashing\XxHash128.cs (5)
225low = BinaryPrimitives.ReverseEndianness(low); 226high = BinaryPrimitives.ReverseEndianness(high); 270uint combinedh = RuntimeBitOperations.RotateLeft(BinaryPrimitives.ReverseEndianness(combinedl), 13); 286seed ^= (ulong)BinaryPrimitives.ReverseEndianness((uint)seed) << 32; 324m128Low ^= BinaryPrimitives.ReverseEndianness(m128High);
src\Compilers\Core\Portable\Hashing\XxHashShared.cs (4)
161static ulong ReadLE64(ulong data) => BitConverter.IsLittleEndian ? data : BinaryPrimitives.ReverseEndianness(data); 795BinaryPrimitives.ReverseEndianness(Unsafe.ReadUnaligned<uint>(data)); 801BinaryPrimitives.ReverseEndianness(Unsafe.ReadUnaligned<ulong>(data)); 808value = BinaryPrimitives.ReverseEndianness(value);
src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\InterceptsLocationUtilities.cs (1)
104var position = BinaryPrimitives.ReadInt32LittleEndian(bytes[PositionIndex..]);
Microsoft.CodeAnalysis.CodeStyle (10)
src\Compilers\Core\Portable\Hashing\XxHash128.cs (5)
225low = BinaryPrimitives.ReverseEndianness(low); 226high = BinaryPrimitives.ReverseEndianness(high); 270uint combinedh = RuntimeBitOperations.RotateLeft(BinaryPrimitives.ReverseEndianness(combinedl), 13); 286seed ^= (ulong)BinaryPrimitives.ReverseEndianness((uint)seed) << 32; 324m128Low ^= BinaryPrimitives.ReverseEndianness(m128High);
src\Compilers\Core\Portable\Hashing\XxHashShared.cs (4)
161static ulong ReadLE64(ulong data) => BitConverter.IsLittleEndian ? data : BinaryPrimitives.ReverseEndianness(data); 795BinaryPrimitives.ReverseEndianness(Unsafe.ReadUnaligned<uint>(data)); 801BinaryPrimitives.ReverseEndianness(Unsafe.ReadUnaligned<ulong>(data)); 808value = BinaryPrimitives.ReverseEndianness(value);
src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\InterceptsLocationUtilities.cs (1)
104var position = BinaryPrimitives.ReadInt32LittleEndian(bytes[PositionIndex..]);
Microsoft.CodeAnalysis.CSharp (4)
Compilation\CSharpCompilation.cs (1)
2468BinaryPrimitives.ReadInt32LittleEndian(obj.ContentHash.AsSpan()),
Utilities\ContentHashComparer.cs (1)
28return BinaryPrimitives.ReadInt32LittleEndian(obj.Span);
Utilities\InterceptableLocation.cs (2)
150var position = BinaryPrimitives.ReadInt32LittleEndian(bytes.AsSpan(start: positionIndex)); 180BinaryPrimitives.ReadInt32LittleEndian(_checksum.AsSpan()),
Microsoft.CodeAnalysis.PerformanceSensitiveAnalyzers (10)
src\Compilers\Core\Portable\Hashing\XxHash128.cs (5)
225low = BinaryPrimitives.ReverseEndianness(low); 226high = BinaryPrimitives.ReverseEndianness(high); 270uint combinedh = RuntimeBitOperations.RotateLeft(BinaryPrimitives.ReverseEndianness(combinedl), 13); 286seed ^= (ulong)BinaryPrimitives.ReverseEndianness((uint)seed) << 32; 324m128Low ^= BinaryPrimitives.ReverseEndianness(m128High);
src\Compilers\Core\Portable\Hashing\XxHashShared.cs (4)
161static ulong ReadLE64(ulong data) => BitConverter.IsLittleEndian ? data : BinaryPrimitives.ReverseEndianness(data); 795BinaryPrimitives.ReverseEndianness(Unsafe.ReadUnaligned<uint>(data)); 801BinaryPrimitives.ReverseEndianness(Unsafe.ReadUnaligned<ulong>(data)); 808value = BinaryPrimitives.ReverseEndianness(value);
src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\InterceptsLocationUtilities.cs (1)
104var position = BinaryPrimitives.ReadInt32LittleEndian(bytes[PositionIndex..]);
Microsoft.CodeAnalysis.PublicApiAnalyzers (10)
src\Compilers\Core\Portable\Hashing\XxHash128.cs (5)
225low = BinaryPrimitives.ReverseEndianness(low); 226high = BinaryPrimitives.ReverseEndianness(high); 270uint combinedh = RuntimeBitOperations.RotateLeft(BinaryPrimitives.ReverseEndianness(combinedl), 13); 286seed ^= (ulong)BinaryPrimitives.ReverseEndianness((uint)seed) << 32; 324m128Low ^= BinaryPrimitives.ReverseEndianness(m128High);
src\Compilers\Core\Portable\Hashing\XxHashShared.cs (4)
161static ulong ReadLE64(ulong data) => BitConverter.IsLittleEndian ? data : BinaryPrimitives.ReverseEndianness(data); 795BinaryPrimitives.ReverseEndianness(Unsafe.ReadUnaligned<uint>(data)); 801BinaryPrimitives.ReverseEndianness(Unsafe.ReadUnaligned<ulong>(data)); 808value = BinaryPrimitives.ReverseEndianness(value);
src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\InterceptsLocationUtilities.cs (1)
104var position = BinaryPrimitives.ReadInt32LittleEndian(bytes[PositionIndex..]);
Microsoft.CodeAnalysis.Remote.Workspaces (1)
RemoteHostAssetWriter.cs (1)
186BinaryPrimitives.WriteInt32LittleEndian(span, (int)length);
Microsoft.CodeAnalysis.ResxSourceGenerator (10)
src\Compilers\Core\Portable\Hashing\XxHash128.cs (5)
225low = BinaryPrimitives.ReverseEndianness(low); 226high = BinaryPrimitives.ReverseEndianness(high); 270uint combinedh = RuntimeBitOperations.RotateLeft(BinaryPrimitives.ReverseEndianness(combinedl), 13); 286seed ^= (ulong)BinaryPrimitives.ReverseEndianness((uint)seed) << 32; 324m128Low ^= BinaryPrimitives.ReverseEndianness(m128High);
src\Compilers\Core\Portable\Hashing\XxHashShared.cs (4)
161static ulong ReadLE64(ulong data) => BitConverter.IsLittleEndian ? data : BinaryPrimitives.ReverseEndianness(data); 795BinaryPrimitives.ReverseEndianness(Unsafe.ReadUnaligned<uint>(data)); 801BinaryPrimitives.ReverseEndianness(Unsafe.ReadUnaligned<ulong>(data)); 808value = BinaryPrimitives.ReverseEndianness(value);
src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\InterceptsLocationUtilities.cs (1)
104var position = BinaryPrimitives.ReadInt32LittleEndian(bytes[PositionIndex..]);
Microsoft.CodeAnalysis.Workspaces (10)
src\Compilers\Core\Portable\Hashing\XxHash128.cs (5)
225low = BinaryPrimitives.ReverseEndianness(low); 226high = BinaryPrimitives.ReverseEndianness(high); 270uint combinedh = RuntimeBitOperations.RotateLeft(BinaryPrimitives.ReverseEndianness(combinedl), 13); 286seed ^= (ulong)BinaryPrimitives.ReverseEndianness((uint)seed) << 32; 324m128Low ^= BinaryPrimitives.ReverseEndianness(m128High);
src\Compilers\Core\Portable\Hashing\XxHashShared.cs (4)
161static ulong ReadLE64(ulong data) => BitConverter.IsLittleEndian ? data : BinaryPrimitives.ReverseEndianness(data); 795BinaryPrimitives.ReverseEndianness(Unsafe.ReadUnaligned<uint>(data)); 801BinaryPrimitives.ReverseEndianness(Unsafe.ReadUnaligned<ulong>(data)); 808value = BinaryPrimitives.ReverseEndianness(value);
src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\InterceptsLocationUtilities.cs (1)
104var position = BinaryPrimitives.ReadInt32LittleEndian(bytes[PositionIndex..]);
Microsoft.CodeAnalysis.Workspaces.MSBuild.BuildHost (1)
src\Compilers\Core\Portable\InternalUtilities\LittleEndianReader.cs (1)
7using static System.Buffers.Binary.BinaryPrimitives;
Microsoft.CodeAnalysis.Workspaces.UnitTests (2)
XxHash128Tests.cs (2)
141var high = BinaryPrimitives.ReadUInt64BigEndian(span); 142var low = BinaryPrimitives.ReadUInt64BigEndian(span.Slice(8));
Microsoft.DotNet.Build.Tasks.Installers (36)
src\RpmHeader.cs (28)
78Tag = BinaryPrimitives.ReadInt32BigEndian(bytes), 79Type = (RpmHeaderEntryType)BinaryPrimitives.ReadInt32BigEndian(bytes.Slice(4)), 80Offset = BinaryPrimitives.ReadInt32BigEndian(bytes.Slice(8)), 81Count = BinaryPrimitives.ReadInt32BigEndian(bytes.Slice(12)) 87BinaryPrimitives.WriteInt32BigEndian(bytes, entry.Tag); 88BinaryPrimitives.WriteInt32BigEndian(bytes.Slice(4), (int)entry.Type); 89BinaryPrimitives.WriteInt32BigEndian(bytes.Slice(8), entry.Offset); 90BinaryPrimitives.WriteInt32BigEndian(bytes.Slice(12), entry.Count); 112int numIndexEntries = BinaryPrimitives.ReadInt32BigEndian(stream.ReadExactly(4)); 113int numHeaderBytes = BinaryPrimitives.ReadInt32BigEndian(stream.ReadExactly(4)); 210contents.SetValue(BinaryPrimitives.ReadInt16BigEndian(store.AsSpan().Slice(offset.AlignUp(2), 2)), i); 215contents.SetValue(BinaryPrimitives.ReadInt32BigEndian(store.AsSpan().Slice(offset.AlignUp(4), 4)), i); 220contents.SetValue(BinaryPrimitives.ReadInt64BigEndian(store.AsSpan().Slice(offset.AlignUp(8), 8)), i); 240BinaryPrimitives.WriteInt32BigEndian(numIndexEntries, Entries.Count + 1); 251BinaryPrimitives.WriteInt32BigEndian(indexInfoBytes, Convert.ToInt32(entry.Tag)); 252BinaryPrimitives.WriteInt32BigEndian(indexInfoBytes.AsSpan(4), (int)entry.Type); 255BinaryPrimitives.WriteInt32BigEndian(indexInfoBytes.AsSpan(8), (int)storeStream.Length); 260BinaryPrimitives.WriteInt32BigEndian(indexInfoBytes.AsSpan(12), binary.Count); 268BinaryPrimitives.WriteInt32BigEndian(indexInfoBytes.AsSpan(8), (int)storeStream.Length); 269BinaryPrimitives.WriteInt32BigEndian(indexInfoBytes.AsSpan(12), 1); 278BinaryPrimitives.WriteInt32BigEndian(indexInfoBytes.AsSpan(8), (int)storeStream.Length); 282BinaryPrimitives.WriteInt32BigEndian(indexInfoBytes.AsSpan(12), strings.Length); 304BinaryPrimitives.WriteInt32BigEndian(indexInfoBytes.AsSpan(8), (int)storeStream.Length); 308BinaryPrimitives.WriteInt32BigEndian(indexInfoBytes.AsSpan(12), contents.Length); 322BinaryPrimitives.WriteInt16BigEndian(tempBeBytes, (short)contents.GetValue(i)!); 326BinaryPrimitives.WriteInt32BigEndian(tempBeBytes, (int)contents.GetValue(i)!); 330BinaryPrimitives.WriteInt64BigEndian(tempBeBytes, (long)contents.GetValue(i)!); 365BinaryPrimitives.WriteInt32BigEndian(numHeaderBytes, (int)storeStream.Length);
src\RpmLead.cs (8)
36lead.Type = BinaryPrimitives.ReadInt16BigEndian(stream.ReadExactly(2)); 37lead.Architecture = BinaryPrimitives.ReadInt16BigEndian(stream.ReadExactly(2)); 41lead.OperatingSystem = BinaryPrimitives.ReadInt16BigEndian(stream.ReadExactly(2)); 42lead.SignatureType = BinaryPrimitives.ReadInt16BigEndian(stream.ReadExactly(2)); 53BinaryPrimitives.WriteInt16BigEndian(beBytes, Type); 55BinaryPrimitives.WriteInt16BigEndian(beBytes, Architecture); 62BinaryPrimitives.WriteInt16BigEndian(beBytes, OperatingSystem); 64BinaryPrimitives.WriteInt16BigEndian(beBytes, SignatureType);
Microsoft.Extensions.AI.AzureAIInference (1)
AzureAIInferenceEmbeddingGenerator.cs (1)
154ints[i] = BinaryPrimitives.ReverseEndianness(ints[i]);
Microsoft.Extensions.Caching.Hybrid (10)
Internal\DefaultHybridCache.L2.cs (2)
115BinaryPrimitives.WriteInt64LittleEndian(oversized, timestamp); 154timestamp = BinaryPrimitives.ReadInt64LittleEndian(buffer.AsSpan());
Internal\HybridCachePayload.cs (8)
108BinaryPrimitives.WriteUInt16LittleEndian(destination.AsSpan(0, 2), UInt16SentinelPrefixPair); 109BinaryPrimitives.WriteUInt16LittleEndian(destination.AsSpan(2, 2), (ushort)_entropySource.Next(0, 0x010000)); // Next is exclusive at RHS 110BinaryPrimitives.WriteInt64LittleEndian(destination.AsSpan(4, 8), creationTime); 142BinaryPrimitives.WriteUInt16LittleEndian(destination.AsSpan(len, 2), UInt16SentinelPrefixPair); 202switch (BinaryPrimitives.ReadUInt16LittleEndian(bytes)) 205entropy = BinaryPrimitives.ReadUInt16LittleEndian(bytes.Slice(2)); 206long creationTime = BinaryPrimitives.ReadInt64LittleEndian(bytes.Slice(4)); 299|| BinaryPrimitives.ReadUInt16LittleEndian(bytes.Slice(payloadLength)) != UInt16SentinelPrefixPair)
Microsoft.Extensions.ServiceDiscovery.Dns (26)
Resolver\DnsDataReader.cs (2)
61value = BinaryPrimitives.ReadUInt16BigEndian(MessageBuffer.AsSpan(_position)); 74value = BinaryPrimitives.ReadUInt32BigEndian(MessageBuffer.AsSpan(_position));
Resolver\DnsDataWriter.cs (2)
93BinaryPrimitives.WriteUInt16BigEndian(_buffer.Span.Slice(_position), value); 105BinaryPrimitives.WriteUInt32BigEndian(_buffer.Span.Slice(_position), value);
Resolver\DnsPrimitives.cs (20)
28TransactionId = BinaryPrimitives.ReadUInt16BigEndian(buffer), 29QueryFlags = (QueryFlags)BinaryPrimitives.ReadUInt16BigEndian(buffer.Slice(2)), 30QueryCount = BinaryPrimitives.ReadUInt16BigEndian(buffer.Slice(4)), 31AnswerCount = BinaryPrimitives.ReadUInt16BigEndian(buffer.Slice(6)), 32AuthorityCount = BinaryPrimitives.ReadUInt16BigEndian(buffer.Slice(8)), 33AdditionalRecordCount = BinaryPrimitives.ReadUInt16BigEndian(buffer.Slice(10)) 49BinaryPrimitives.WriteUInt16BigEndian(buffer, header.TransactionId); 50BinaryPrimitives.WriteUInt16BigEndian(buffer.Slice(2), (ushort)header.QueryFlags); 51BinaryPrimitives.WriteUInt16BigEndian(buffer.Slice(4), header.QueryCount); 52BinaryPrimitives.WriteUInt16BigEndian(buffer.Slice(6), header.AnswerCount); 53BinaryPrimitives.WriteUInt16BigEndian(buffer.Slice(8), header.AuthorityCount); 54BinaryPrimitives.WriteUInt16BigEndian(buffer.Slice(10), header.AdditionalRecordCount); 276if (!BinaryPrimitives.TryReadUInt16BigEndian(buffer.Span, out priority) || 277!BinaryPrimitives.TryReadUInt16BigEndian(buffer.Span.Slice(2), out weight) || 278!BinaryPrimitives.TryReadUInt16BigEndian(buffer.Span.Slice(4), out port) || 298!BinaryPrimitives.TryReadUInt32BigEndian(buffer.Span.Slice(w1 + w2), out serial) || 299!BinaryPrimitives.TryReadUInt32BigEndian(buffer.Span.Slice(w1 + w2 + 4), out refresh) || 300!BinaryPrimitives.TryReadUInt32BigEndian(buffer.Span.Slice(w1 + w2 + 8), out retry) || 301!BinaryPrimitives.TryReadUInt32BigEndian(buffer.Span.Slice(w1 + w2 + 12), out expire) || 302!BinaryPrimitives.TryReadUInt32BigEndian(buffer.Span.Slice(w1 + w2 + 16), out minimum))
Resolver\DnsResolver.cs (2)
774BinaryPrimitives.WriteUInt16BigEndian(buffer, (ushort)length); 795responseLength = BinaryPrimitives.ReadUInt16BigEndian(buffer.AsSpan(0, 2));
Microsoft.Extensions.ServiceDiscovery.Dns.Tests (10)
Resolver\LoopbackDnsServer.cs (10)
99length = BinaryPrimitives.ReadUInt16BigEndian(buffer.AsSpan(0, 2)); 104BinaryPrimitives.WriteUInt16BigEndian(buffer.AsSpan(0, 2), (ushort)bytesWritten); 258if (!BinaryPrimitives.TryWriteUInt16BigEndian(buff, priority) || 259!BinaryPrimitives.TryWriteUInt16BigEndian(buff.AsSpan(2), weight) || 260!BinaryPrimitives.TryWriteUInt16BigEndian(buff.AsSpan(4), port) || 279!BinaryPrimitives.TryWriteUInt32BigEndian(buff.AsSpan(w1 + w2), serial) || 280!BinaryPrimitives.TryWriteUInt32BigEndian(buff.AsSpan(w1 + w2 + 4), refresh) || 281!BinaryPrimitives.TryWriteUInt32BigEndian(buff.AsSpan(w1 + w2 + 8), retry) || 282!BinaryPrimitives.TryWriteUInt32BigEndian(buff.AsSpan(w1 + w2 + 12), expire) || 283!BinaryPrimitives.TryWriteUInt32BigEndian(buff.AsSpan(w1 + w2 + 16), minimum))
mscorlib (1)
mscorlib.cs (1)
49[assembly:System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Buffers.Binary.BinaryPrimitives))]
netstandard (1)
netstandard.cs (1)
61[assembly: System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Buffers.Binary.BinaryPrimitives))]
Roslyn.Diagnostics.Analyzers (10)
src\Compilers\Core\Portable\Hashing\XxHash128.cs (5)
225low = BinaryPrimitives.ReverseEndianness(low); 226high = BinaryPrimitives.ReverseEndianness(high); 270uint combinedh = RuntimeBitOperations.RotateLeft(BinaryPrimitives.ReverseEndianness(combinedl), 13); 286seed ^= (ulong)BinaryPrimitives.ReverseEndianness((uint)seed) << 32; 324m128Low ^= BinaryPrimitives.ReverseEndianness(m128High);
src\Compilers\Core\Portable\Hashing\XxHashShared.cs (4)
161static ulong ReadLE64(ulong data) => BitConverter.IsLittleEndian ? data : BinaryPrimitives.ReverseEndianness(data); 795BinaryPrimitives.ReverseEndianness(Unsafe.ReadUnaligned<uint>(data)); 801BinaryPrimitives.ReverseEndianness(Unsafe.ReadUnaligned<ulong>(data)); 808value = BinaryPrimitives.ReverseEndianness(value);
src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\InterceptsLocationUtilities.cs (1)
104var position = BinaryPrimitives.ReadInt32LittleEndian(bytes[PositionIndex..]);
System.Diagnostics.DiagnosticSource (3)
System\Diagnostics\Activity.cs (3)
1983span[0] = BinaryPrimitives.ReverseEndianness(span[0]); 1984span[1] = BinaryPrimitives.ReverseEndianness(span[1]); 2166id = BinaryPrimitives.ReverseEndianness(id);
System.Formats.Asn1 (4)
System\Formats\Asn1\AsnCharacterStringEncodings.cs (1)
377char c = (char)BinaryPrimitives.ReadInt16BigEndian(bytes.Slice(i));
System\Formats\Asn1\AsnDecoder.Integer.cs (1)
409if (BinaryPrimitives.TryReadUInt16BigEndian(contents, out ushort bigEndianValue))
System\Formats\Asn1\AsnDecoder.Oid.cs (1)
201BinaryPrimitives.WriteInt64LittleEndian(accumValueBytes, accum);
System\Formats\Asn1\AsnWriter.Integer.cs (1)
258if (BinaryPrimitives.TryReadUInt16BigEndian(value, out ushort bigEndianValue))
System.Formats.Cbor (14)
System\Formats\Cbor\CborHelpers.netcoreapp.cs (5)
45=> BinaryPrimitives.ReadHalfBigEndian(source); 49=> BinaryPrimitives.ReadSingleBigEndian(source); 53=> BinaryPrimitives.ReadDoubleBigEndian(source); 57=> BinaryPrimitives.WriteSingleBigEndian(destination, value); 61=> BinaryPrimitives.WriteDoubleBigEndian(destination, value);
System\Formats\Cbor\Reader\CborReader.Integer.cs (3)
181result = BinaryPrimitives.ReadUInt16BigEndian(data.Slice(1)); 193result = BinaryPrimitives.ReadUInt32BigEndian(data.Slice(1)); 205result = BinaryPrimitives.ReadUInt64BigEndian(data.Slice(1));
System\Formats\Cbor\Reader\CborReader.Simple.netcoreapp.cs (1)
32result = BinaryPrimitives.ReadHalfBigEndian(buffer.Slice(1));
System\Formats\Cbor\Writer\CborWriter.Integer.cs (3)
102BinaryPrimitives.WriteUInt16BigEndian(_buffer.AsSpan(_offset), (ushort)value); 109BinaryPrimitives.WriteUInt32BigEndian(_buffer.AsSpan(_offset), (uint)value); 116BinaryPrimitives.WriteUInt64BigEndian(_buffer.AsSpan(_offset), value);
System\Formats\Cbor\Writer\CborWriter.Simple.netcoreapp.cs (2)
26BinaryPrimitives.WriteUInt16BigEndian(_buffer.AsSpan(_offset), PositiveQNaNBitsHalf); 30BinaryPrimitives.WriteHalfBigEndian(_buffer.AsSpan(_offset), value);
System.Formats.Nrbf (3)
System\Formats\Nrbf\ArraySinglePrimitiveRecord.cs (3)
166BinaryPrimitives.ReverseEndianness(span, span); 178BinaryPrimitives.ReverseEndianness(span, span); 190BinaryPrimitives.ReverseEndianness(span, span);
System.Formats.Tar (3)
System\Formats\Tar\TarHeader.Write.cs (3)
1115BinaryPrimitives.WriteInt64BigEndian(destination, destinationValue); 1139BinaryPrimitives.WriteUInt32BigEndian(destination, value < 0 ? 0xffffffff : 0x80000000); 1140BinaryPrimitives.WriteInt64BigEndian(destination.Slice(Offset), value);
System.IO.Hashing (37)
System\IO\Hashing\Crc32.cs (5)
78BinaryPrimitives.WriteUInt32LittleEndian(destination, ~_crc); 87BinaryPrimitives.WriteUInt32LittleEndian(destination, ~_crc); 120BinaryPrimitives.WriteUInt32LittleEndian(ret, hash); 145BinaryPrimitives.WriteUInt32LittleEndian(destination, hash); 166BinaryPrimitives.WriteUInt32LittleEndian(destination, hash);
System\IO\Hashing\Crc64.cs (5)
76BinaryPrimitives.WriteUInt64BigEndian(destination, _crc); 85BinaryPrimitives.WriteUInt64BigEndian(destination, _crc); 118BinaryPrimitives.WriteUInt64BigEndian(ret, hash); 143BinaryPrimitives.WriteUInt64BigEndian(destination, hash); 164BinaryPrimitives.WriteUInt64BigEndian(destination, hash);
System\IO\Hashing\XxHash128.cs (5)
221low = BinaryPrimitives.ReverseEndianness(low); 222high = BinaryPrimitives.ReverseEndianness(high); 266uint combinedh = BitOperations.RotateLeft(BinaryPrimitives.ReverseEndianness(combinedl), 13); 282seed ^= (ulong)BinaryPrimitives.ReverseEndianness((uint)seed) << 32; 320m128Low ^= BinaryPrimitives.ReverseEndianness(m128High);
System\IO\Hashing\XxHash3.cs (5)
76BinaryPrimitives.WriteUInt64BigEndian(result, hash); 110hash = BinaryPrimitives.ReverseEndianness(hash); 169BinaryPrimitives.WriteUInt64BigEndian(destination, hash); 246seed ^= (ulong)BinaryPrimitives.ReverseEndianness((uint)seed) << 32; 273BinaryPrimitives.ReverseEndianness(inputLow) +
System\IO\Hashing\XxHash32.cs (4)
135BinaryPrimitives.WriteUInt32BigEndian(destination, hash); 195BinaryPrimitives.WriteUInt32BigEndian(ret, hash); 221BinaryPrimitives.WriteUInt32BigEndian(destination, hash); 243BinaryPrimitives.WriteUInt32BigEndian(destination, hash);
System\IO\Hashing\XxHash32.State.cs (2)
62acc += BinaryPrimitives.ReadUInt32LittleEndian(lane) * Prime32_2; 77uint lane = BinaryPrimitives.ReadUInt32LittleEndian(remaining);
System\IO\Hashing\XxHash64.cs (4)
135BinaryPrimitives.WriteUInt64BigEndian(destination, hash); 195BinaryPrimitives.WriteUInt64BigEndian(ret, hash); 221BinaryPrimitives.WriteUInt64BigEndian(destination, hash); 243BinaryPrimitives.WriteUInt64BigEndian(destination, hash);
System\IO\Hashing\XxHash64.State.cs (3)
88return ApplyRound(acc, BinaryPrimitives.ReadUInt64LittleEndian(lane)); 112ulong lane = BinaryPrimitives.ReadUInt64LittleEndian(remaining); 124ulong lane = BinaryPrimitives.ReadUInt32LittleEndian(remaining);
System\IO\Hashing\XxHashShared.cs (4)
156static ulong ReadLE64(ulong data) => BitConverter.IsLittleEndian ? data : BinaryPrimitives.ReverseEndianness(data); 786BinaryPrimitives.ReverseEndianness(Unsafe.ReadUnaligned<uint>(data)); 792BinaryPrimitives.ReverseEndianness(Unsafe.ReadUnaligned<ulong>(data)); 799value = BinaryPrimitives.ReverseEndianness(value);
System.Memory (4)
artifacts\obj\System.Memory\Debug\net10.0\System.Memory.Forwards.cs (1)
3[assembly: System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Buffers.Binary.BinaryPrimitives))]
System\Buffers\SequenceReaderExtensions.Binary.cs (3)
88value = BinaryPrimitives.ReverseEndianness(value); 127value = BinaryPrimitives.ReverseEndianness(value); 166value = BinaryPrimitives.ReverseEndianness(value);
System.Private.CoreLib (172)
src\libraries\System.Private.CoreLib\src\System\Buffers\Text\Utf8Parser\Utf8Parser.Boolean.cs (1)
34int dw = BinaryPrimitives.ReadInt32LittleEndian(source) & ~0x20202020;
src\libraries\System.Private.CoreLib\src\System\Buffers\Text\Utf8Parser\Utf8Parser.Float.cs (2)
159int diff = (BinaryPrimitives.ReadInt32LittleEndian(source.Slice(srcIndex)) ^ infi); 164diff = (BinaryPrimitives.ReadInt32LittleEndian(source.Slice(srcIndex + 4)) ^ nity);
src\libraries\System.Private.CoreLib\src\System\Char.cs (4)
1246result = BinaryPrimitives.ReverseEndianness(result); 1294result = BinaryPrimitives.ReverseEndianness(result); 1317if (BinaryPrimitives.TryWriteUInt16BigEndian(destination, m_value)) 1330if (BinaryPrimitives.TryWriteUInt16LittleEndian(destination, m_value))
src\libraries\System.Private.CoreLib\src\System\Collections\BitArray.cs (4)
98BinaryPrimitives.ReverseEndianness(array, MemoryMarshal.Cast<byte, int>((Span<byte>)_array)); 252BinaryPrimitives.ReverseEndianness(values, MemoryMarshal.Cast<byte, int>((Span<byte>)_array)); 687BinaryPrimitives.ReverseEndianness(source, intArray.AsSpan(index)); 973BitConverter.IsLittleEndian ? value : BinaryPrimitives.ReverseEndianness(value);
src\libraries\System.Private.CoreLib\src\System\Decimal.cs (12)
632BinaryPrimitives.WriteInt32LittleEndian(buffer, (int)d.Low); 633BinaryPrimitives.WriteInt32LittleEndian(buffer.Slice(4), (int)d.Mid); 634BinaryPrimitives.WriteInt32LittleEndian(buffer.Slice(8), (int)d.High); 635BinaryPrimitives.WriteInt32LittleEndian(buffer.Slice(12), d._flags); 641int lo = BinaryPrimitives.ReadInt32LittleEndian(span); 642int mid = BinaryPrimitives.ReadInt32LittleEndian(span.Slice(4)); 643int hi = BinaryPrimitives.ReadInt32LittleEndian(span.Slice(8)); 644int flags = BinaryPrimitives.ReadInt32LittleEndian(span.Slice(12)); 1182hi32 = BinaryPrimitives.ReverseEndianness(hi32); 1183lo64 = BinaryPrimitives.ReverseEndianness(lo64); 1211lo64 = BinaryPrimitives.ReverseEndianness(lo64); 1212hi32 = BinaryPrimitives.ReverseEndianness(hi32);
src\libraries\System.Private.CoreLib\src\System\Diagnostics\Tracing\EventPipePayloadDecoder.cs (11)
33decodedFields[i] = BinaryPrimitives.ReadIntPtrLittleEndian(payload); 38decodedFields[i] = BinaryPrimitives.ReadInt32LittleEndian(payload); 43decodedFields[i] = BinaryPrimitives.ReadUInt32LittleEndian(payload); 48decodedFields[i] = BinaryPrimitives.ReadInt64LittleEndian(payload); 53decodedFields[i] = BinaryPrimitives.ReadUInt64LittleEndian(payload); 68decodedFields[i] = BinaryPrimitives.ReadInt16LittleEndian(payload); 73decodedFields[i] = BinaryPrimitives.ReadUInt16LittleEndian(payload); 78decodedFields[i] = BinaryPrimitives.ReadSingleLittleEndian(payload); 83decodedFields[i] = BinaryPrimitives.ReadDoubleLittleEndian(payload); 89decodedFields[i] = (BinaryPrimitives.ReadInt32LittleEndian(payload) == 1); 100decodedFields[i] = (char)BinaryPrimitives.ReadUInt16LittleEndian(payload);
src\libraries\System.Private.CoreLib\src\System\Double.cs (4)
725if (BinaryPrimitives.TryWriteInt16BigEndian(destination, Exponent)) 738if (BinaryPrimitives.TryWriteInt16LittleEndian(destination, Exponent)) 751if (BinaryPrimitives.TryWriteUInt64BigEndian(destination, Significand)) 764if (BinaryPrimitives.TryWriteUInt64LittleEndian(destination, Significand))
src\libraries\System.Private.CoreLib\src\System\Globalization\CharUnicodeInfo.cs (7)
247temp = BinaryPrimitives.ReverseEndianness(temp); 262int delta = (BitConverter.IsLittleEndian) ? rsDelta : BinaryPrimitives.ReverseEndianness(rsDelta); 281int delta = (BitConverter.IsLittleEndian) ? rsDelta : BinaryPrimitives.ReverseEndianness(rsDelta); 297int delta = (BitConverter.IsLittleEndian) ? rsDelta : BinaryPrimitives.ReverseEndianness(rsDelta); 316int delta = (BitConverter.IsLittleEndian) ? rsDelta : BinaryPrimitives.ReverseEndianness(rsDelta); 470index = BinaryPrimitives.ReverseEndianness(Unsafe.ReadUnaligned<ushort>(ref level2Ref)); 507index = BinaryPrimitives.ReverseEndianness(Unsafe.ReadUnaligned<ushort>(ref level2Ref));
src\libraries\System.Private.CoreLib\src\System\Globalization\CompareInfo.Invariant.cs (4)
51BinaryPrimitives.WriteUInt16BigEndian(sortKey, (ushort)source[i]); 70BinaryPrimitives.WriteUInt16BigEndian(tmp, hr); 71BinaryPrimitives.WriteUInt16BigEndian(tmp.Slice(sizeof(ushort)), lr); 79BinaryPrimitives.WriteUInt16BigEndian(sortKey, (ushort)InvariantModeCasing.ToUpper(c));
src\libraries\System.Private.CoreLib\src\System\Guid.cs (12)
76_a = BinaryPrimitives.ReverseEndianness(_a); 77_b = BinaryPrimitives.ReverseEndianness(_b); 78_c = BinaryPrimitives.ReverseEndianness(_c); 93_a = BinaryPrimitives.ReverseEndianness(_a); 94_b = BinaryPrimitives.ReverseEndianness(_b); 95_c = BinaryPrimitives.ReverseEndianness(_c); 253_a = BinaryPrimitives.ReverseEndianness(_a); 254_b = BinaryPrimitives.ReverseEndianness(_b); 255_c = BinaryPrimitives.ReverseEndianness(_c); 574result._de = BitConverter.IsLittleEndian ? BinaryPrimitives.ReverseEndianness((ushort)uintTmp) : (ushort)uintTmp; 577result._fg = BitConverter.IsLittleEndian ? BinaryPrimitives.ReverseEndianness((ushort)uintTmp) : (ushort)uintTmp; 582result._hijk = BitConverter.IsLittleEndian ? BinaryPrimitives.ReverseEndianness(uintTmp) : uintTmp;
src\libraries\System.Private.CoreLib\src\System\Half.cs (2)
1396if (BinaryPrimitives.TryWriteUInt16BigEndian(destination, Significand)) 1409if (BinaryPrimitives.TryWriteUInt16LittleEndian(destination, Significand))
src\libraries\System.Private.CoreLib\src\System\Int128.cs (5)
807result = BinaryPrimitives.ReverseEndianness(result); 887result = BinaryPrimitives.ReverseEndianness(result); 905result = BinaryPrimitives.ReverseEndianness(result); 939if (BinaryPrimitives.TryWriteInt128BigEndian(destination, this)) 952if (BinaryPrimitives.TryWriteInt128LittleEndian(destination, this))
src\libraries\System.Private.CoreLib\src\System\Int16.cs (4)
355result = BinaryPrimitives.ReverseEndianness(result); 428result = BinaryPrimitives.ReverseEndianness(result); 468if (BinaryPrimitives.TryWriteInt16BigEndian(destination, m_value)) 481if (BinaryPrimitives.TryWriteInt16LittleEndian(destination, m_value))
src\libraries\System.Private.CoreLib\src\System\Int32.cs (5)
375result = BinaryPrimitives.ReverseEndianness(result); 455result = BinaryPrimitives.ReverseEndianness(result); 473result = BinaryPrimitives.ReverseEndianness(result); 507if (BinaryPrimitives.TryWriteInt32BigEndian(destination, m_value)) 520if (BinaryPrimitives.TryWriteInt32LittleEndian(destination, m_value))
src\libraries\System.Private.CoreLib\src\System\Int64.cs (5)
372result = BinaryPrimitives.ReverseEndianness(result); 452result = BinaryPrimitives.ReverseEndianness(result); 470result = BinaryPrimitives.ReverseEndianness(result); 504if (BinaryPrimitives.TryWriteInt64BigEndian(destination, m_value)) 517if (BinaryPrimitives.TryWriteInt64LittleEndian(destination, m_value))
src\libraries\System.Private.CoreLib\src\System\IntPtr.cs (5)
395result = BinaryPrimitives.ReverseEndianness(result); 475result = BinaryPrimitives.ReverseEndianness(result); 493result = BinaryPrimitives.ReverseEndianness(result); 527if (BinaryPrimitives.TryWriteIntPtrBigEndian(destination, _value)) 540if (BinaryPrimitives.TryWriteIntPtrLittleEndian(destination, _value))
src\libraries\System.Private.CoreLib\src\System\IO\BinaryReader.cs (9)
214public virtual short ReadInt16() => BinaryPrimitives.ReadInt16LittleEndian(InternalRead(stackalloc byte[sizeof(short)])); 217public virtual ushort ReadUInt16() => BinaryPrimitives.ReadUInt16LittleEndian(InternalRead(stackalloc byte[sizeof(ushort)])); 219public virtual int ReadInt32() => BinaryPrimitives.ReadInt32LittleEndian(InternalRead(stackalloc byte[sizeof(int)])); 221public virtual uint ReadUInt32() => BinaryPrimitives.ReadUInt32LittleEndian(InternalRead(stackalloc byte[sizeof(uint)])); 222public virtual long ReadInt64() => BinaryPrimitives.ReadInt64LittleEndian(InternalRead(stackalloc byte[sizeof(long)])); 224public virtual ulong ReadUInt64() => BinaryPrimitives.ReadUInt64LittleEndian(InternalRead(stackalloc byte[sizeof(ulong)])); 225public virtual unsafe Half ReadHalf() => BinaryPrimitives.ReadHalfLittleEndian(InternalRead(stackalloc byte[sizeof(Half)])); 226public virtual unsafe float ReadSingle() => BinaryPrimitives.ReadSingleLittleEndian(InternalRead(stackalloc byte[sizeof(float)])); 227public virtual unsafe double ReadDouble() => BinaryPrimitives.ReadDoubleLittleEndian(InternalRead(stackalloc byte[sizeof(double)]));
src\libraries\System.Private.CoreLib\src\System\IO\BinaryWriter.cs (9)
247BinaryPrimitives.WriteDoubleLittleEndian(buffer, value); 264BinaryPrimitives.WriteInt16LittleEndian(buffer, value); 275BinaryPrimitives.WriteUInt16LittleEndian(buffer, value); 285BinaryPrimitives.WriteInt32LittleEndian(buffer, value); 296BinaryPrimitives.WriteUInt32LittleEndian(buffer, value); 306BinaryPrimitives.WriteInt64LittleEndian(buffer, value); 317BinaryPrimitives.WriteUInt64LittleEndian(buffer, value); 327BinaryPrimitives.WriteSingleLittleEndian(buffer, value); 337BinaryPrimitives.WriteHalfLittleEndian(buffer, value);
src\libraries\System.Private.CoreLib\src\System\IO\StreamReader.cs (1)
476ushort firstTwoBytes = BinaryPrimitives.ReadUInt16LittleEndian(byteBuffer);
src\libraries\System.Private.CoreLib\src\System\Net\WebUtility.cs (2)
948ulong key = BinaryPrimitives.ReadUInt64LittleEndian(tableData); 949char value = (char)BinaryPrimitives.ReadUInt16LittleEndian(tableData.Slice(sizeof(ulong)));
src\libraries\System.Private.CoreLib\src\System\Number.NumberToFloatingPointBits.cs (1)
960val = BinaryPrimitives.ReverseEndianness(val);
src\libraries\System.Private.CoreLib\src\System\Reflection\AssemblyNameHelpers.StrongName.cs (3)
48uint sigAlgID = BinaryPrimitives.ReadUInt32LittleEndian(publicKeyBlob); 49uint hashAlgID = BinaryPrimitives.ReadUInt32LittleEndian(publicKeyBlob.Slice(4)); 50uint cbPublicKey = BinaryPrimitives.ReadUInt32LittleEndian(publicKeyBlob.Slice(8));
src\libraries\System.Private.CoreLib\src\System\Resources\ResourceReader.cs (2)
177return BinaryPrimitives.ReadInt32LittleEndian(new ReadOnlySpan<byte>(p, sizeof(int))); 411arr[i] = (char)BinaryPrimitives.ReverseEndianness((short)charPtr[i]);
src\libraries\System.Private.CoreLib\src\System\Runtime\InteropServices\NFloat.cs (4)
1049exponent = BinaryPrimitives.ReverseEndianness(exponent); 1073exponent = BinaryPrimitives.ReverseEndianness(exponent); 1097significand = BinaryPrimitives.ReverseEndianness(significand); 1121significand = BinaryPrimitives.ReverseEndianness(significand);
src\libraries\System.Private.CoreLib\src\System\Single.cs (2)
748if (BinaryPrimitives.TryWriteUInt32BigEndian(destination, Significand)) 761if (BinaryPrimitives.TryWriteUInt32LittleEndian(destination, Significand))
src\libraries\System.Private.CoreLib\src\System\SpanHelpers.Byte.cs (4)
1433Unsafe.WriteUnaligned(ref Unsafe.Add(ref buf, offset), BinaryPrimitives.ReverseEndianness(tempLast)); 1434Unsafe.WriteUnaligned(ref Unsafe.Add(ref buf, lastOffset), BinaryPrimitives.ReverseEndianness(tempFirst)); 1452Unsafe.WriteUnaligned(ref Unsafe.Add(ref buf, offset), BinaryPrimitives.ReverseEndianness(tempLast)); 1453Unsafe.WriteUnaligned(ref Unsafe.Add(ref buf, lastOffset), BinaryPrimitives.ReverseEndianness(tempFirst));
src\libraries\System.Private.CoreLib\src\System\Text\Unicode\Utf8Utility.Helpers.cs (3)
117uint tempA = BinaryPrimitives.ReverseEndianness(value & 0x003F_0700u); // = [ 00000000 00000uuu 00xxxxxx 00000000 ] 223return BinaryPrimitives.ReverseEndianness((ushort)(temp + value + 0xC080u)); // [ 00000000 00000000 10xxxxxx 110yyyyy ] 441return BinaryPrimitives.ReverseEndianness(value);
src\libraries\System.Private.CoreLib\src\System\TimeZoneInfo.Unix.cs (4)
1115=> BinaryPrimitives.ReadInt16BigEndian(value); 1120=> BinaryPrimitives.ReadInt32BigEndian(value.AsSpan(startIndex)); 1125=> BinaryPrimitives.ReadInt32BigEndian(value); 1130=> BinaryPrimitives.ReadInt64BigEndian(value.AsSpan(startIndex));
src\libraries\System.Private.CoreLib\src\System\UInt128.cs (4)
858result = BinaryPrimitives.ReverseEndianness(result); 913result = BinaryPrimitives.ReverseEndianness(result); 949if (BinaryPrimitives.TryWriteUInt128BigEndian(destination, this)) 962if (BinaryPrimitives.TryWriteUInt128LittleEndian(destination, this))
src\libraries\System.Private.CoreLib\src\System\UInt16.cs (4)
329result = BinaryPrimitives.ReverseEndianness(result); 377result = BinaryPrimitives.ReverseEndianness(result); 400if (BinaryPrimitives.TryWriteUInt16BigEndian(destination, m_value)) 413if (BinaryPrimitives.TryWriteUInt16LittleEndian(destination, m_value))
src\libraries\System.Private.CoreLib\src\System\UInt32.cs (4)
350result = BinaryPrimitives.ReverseEndianness(result); 405result = BinaryPrimitives.ReverseEndianness(result); 438if (BinaryPrimitives.TryWriteUInt32BigEndian(destination, m_value)) 451if (BinaryPrimitives.TryWriteUInt32LittleEndian(destination, m_value))
src\libraries\System.Private.CoreLib\src\System\UInt64.cs (4)
349result = BinaryPrimitives.ReverseEndianness(result); 404result = BinaryPrimitives.ReverseEndianness(result); 437if (BinaryPrimitives.TryWriteUInt64BigEndian(destination, m_value)) 450if (BinaryPrimitives.TryWriteUInt64LittleEndian(destination, m_value))
src\libraries\System.Private.CoreLib\src\System\UIntPtr.cs (4)
371result = BinaryPrimitives.ReverseEndianness(result); 426result = BinaryPrimitives.ReverseEndianness(result); 459if (BinaryPrimitives.TryWriteUIntPtrBigEndian(destination, _value)) 472if (BinaryPrimitives.TryWriteUIntPtrLittleEndian(destination, _value))
src\System\Reflection\Emit\CustomAttributeBuilder.cs (2)
362writer.Write(BinaryPrimitives.ReverseEndianness((short)(length | 0x80_00))); 366writer.Write(BinaryPrimitives.ReverseEndianness(length | 0xC0_00_00_00));
src\System\Reflection\Emit\RuntimeILGenerator.cs (8)
123BinaryPrimitives.WriteInt16BigEndian(m_ILStream.AsSpan(m_length), opcodeValue); 226BinaryPrimitives.WriteInt32LittleEndian(newBytes.AsSpan(fixupData.m_fixupPos), updateAddr); 269BinaryPrimitives.WriteInt32LittleEndian(m_ILStream.AsSpan(m_length), value); 393BinaryPrimitives.WriteInt16LittleEndian(m_ILStream.AsSpan(m_length), arg); 732BinaryPrimitives.WriteInt64LittleEndian(m_ILStream.AsSpan(m_length), arg); 740BinaryPrimitives.WriteInt32LittleEndian(m_ILStream.AsSpan(m_length), BitConverter.SingleToInt32Bits(arg)); 748BinaryPrimitives.WriteInt64LittleEndian(m_ILStream.AsSpan(m_length), BitConverter.DoubleToInt64Bits(arg)); 892BinaryPrimitives.WriteInt16LittleEndian(m_ILStream.AsSpan(m_length), (short)tempVal);
src\System\Reflection\Emit\SignatureHelper.cs (2)
477BinaryPrimitives.WriteInt16BigEndian(m_signature.AsSpan(m_currSig), (short)(data | 0x80_00)); 482BinaryPrimitives.WriteInt32BigEndian(m_signature.AsSpan(m_currSig), (int)(data | 0xC0_00_00_00));
src\System\Reflection\RuntimeCustomAttributeData.cs (6)
946return BinaryPrimitives.ReadUInt16LittleEndian(tmp); 954return BinaryPrimitives.ReadUInt32LittleEndian(tmp); 962return BinaryPrimitives.ReadUInt64LittleEndian(tmp); 970return BinaryPrimitives.ReadSingleLittleEndian(tmp); 981return BinaryPrimitives.ReadDoubleLittleEndian(tmp); 1545data = BinaryPrimitives.ReverseEndianness(data);
src\System\Runtime\CompilerServices\RuntimeHelpers.CoreCLR.cs (3)
67BinaryPrimitives.ReverseEndianness( 72BinaryPrimitives.ReverseEndianness( 77BinaryPrimitives.ReverseEndianness(
System.Private.DataContractSerialization (39)
System\Runtime\Serialization\DataContract.cs (1)
1843b = unchecked(a + f + sines[j] + BinaryPrimitives.ReadUInt32LittleEndian(block.AsSpan(g)));
System\Xml\XmlBinaryWriter.cs (19)
134=> WriteTextNodeRaw<short>(nodeType, BitConverter.IsLittleEndian ? value : BinaryPrimitives.ReverseEndianness((value))); 137=> WriteTextNodeRaw<int>(nodeType, BitConverter.IsLittleEndian ? value : BinaryPrimitives.ReverseEndianness((value))); 140=> WriteTextNodeRaw<long>(nodeType, BitConverter.IsLittleEndian ? value : BinaryPrimitives.ReverseEndianness((value))); 513=> WriteRaw<long>(BitConverter.IsLittleEndian ? value : BinaryPrimitives.ReverseEndianness(value)); 738BinaryPrimitives.WriteSingleLittleEndian(span.Slice(1), f); 763BinaryPrimitives.WriteDoubleLittleEndian(span.Slice(1), d); 783BinaryPrimitives.WriteInt32LittleEndian(span.Slice(0 + 1), bits[3]); 784BinaryPrimitives.WriteInt32LittleEndian(span.Slice(4 + 1), bits[2]); 785BinaryPrimitives.WriteInt32LittleEndian(span.Slice(8 + 1), bits[0]); 786BinaryPrimitives.WriteInt32LittleEndian(span.Slice(12 + 1), bits[1]); 876WriteRaw(BinaryPrimitives.ReverseEndianness(s)); 892WriteRaw(BinaryPrimitives.ReverseEndianness(i)); 908WriteRaw(BinaryPrimitives.ReverseEndianness(l)); 925BinaryPrimitives.WriteSingleLittleEndian(span, f); 943BinaryPrimitives.WriteDoubleLittleEndian(span, d); 965BinaryPrimitives.WriteInt32LittleEndian(span, bits[3]); 966BinaryPrimitives.WriteInt32LittleEndian(span.Slice(4), bits[2]); 967BinaryPrimitives.WriteInt32LittleEndian(span.Slice(8), bits[0]); 968BinaryPrimitives.WriteInt32LittleEndian(span.Slice(12), bits[1]);
System\Xml\XmlBufferReader.cs (18)
356=> BitConverter.IsLittleEndian ? ReadRawBytes<ushort>() : BinaryPrimitives.ReverseEndianness(ReadRawBytes<ushort>()); 362=> BitConverter.IsLittleEndian ? ReadRawBytes<int>() : BinaryPrimitives.ReverseEndianness(ReadRawBytes<int>()); 373=> BitConverter.IsLittleEndian ? ReadRawBytes<long>() : BinaryPrimitives.ReverseEndianness(ReadRawBytes<long>()); 377float f = BinaryPrimitives.ReadSingleLittleEndian(GetBuffer(sizeof(float), out int offset).AsSpan(offset, sizeof(float))); 384double d = BinaryPrimitives.ReadDoubleLittleEndian(GetBuffer(sizeof(double), out int offset).AsSpan(offset, sizeof(double))); 401BinaryPrimitives.ReadInt32LittleEndian(bytes.Slice(8, 4)), 402BinaryPrimitives.ReadInt32LittleEndian(bytes.Slice(12, 4)), 403BinaryPrimitives.ReadInt32LittleEndian(bytes.Slice(4, 4)), 404BinaryPrimitives.ReadInt32LittleEndian(bytes.Slice(0, 4)) 952=> BitConverter.IsLittleEndian ? ReadRawBytes<short>(offset) : BinaryPrimitives.ReverseEndianness(ReadRawBytes<short>(offset)); 955=> BitConverter.IsLittleEndian ? ReadRawBytes<int>(offset) : BinaryPrimitives.ReverseEndianness(ReadRawBytes<int>(offset)); 958=> BitConverter.IsLittleEndian ? ReadRawBytes<long>(offset) : BinaryPrimitives.ReverseEndianness(ReadRawBytes<long>(offset)); 964=> BinaryPrimitives.ReadSingleLittleEndian(_buffer.AsSpan(offset, sizeof(float))); 967=> BinaryPrimitives.ReadDoubleLittleEndian(_buffer.AsSpan(offset, sizeof(double))); 980BinaryPrimitives.ReadInt32LittleEndian(bytes.Slice(8, 4)), 981BinaryPrimitives.ReadInt32LittleEndian(bytes.Slice(12, 4)), 982BinaryPrimitives.ReadInt32LittleEndian(bytes.Slice(4, 4)), 983BinaryPrimitives.ReadInt32LittleEndian(bytes.Slice(0, 4))
System\Xml\XmlStreamNodeWriter.cs (1)
345BinaryPrimitives.ReverseEndianness(new ReadOnlySpan<short>(chars, charCount),
System.Private.Uri (1)
src\libraries\Common\src\System\Net\IPv4AddressHelper.Common.cs (1)
55return BinaryPrimitives.ReadInt32BigEndian(numbers);
System.Private.Windows.Core (3)
System\IO\BinaryReaderExtensions.cs (3)
134BinaryPrimitives.ReverseEndianness(ushorts, ushorts); 139BinaryPrimitives.ReverseEndianness(ints, ints); 144BinaryPrimitives.ReverseEndianness(longs, longs);
System.Private.Xml (15)
System\Xml\BinaryXml\SqlUtils.cs (1)
73=> BinaryPrimitives.ReadUInt32LittleEndian(data.AsSpan(offset));
System\Xml\BinaryXml\XmlBinaryReader.cs (11)
3498if (!BinaryPrimitives.TryReadUInt16LittleEndian(data, out ushort value)) 3511if (!BinaryPrimitives.TryReadUInt16LittleEndian(data, out ushort value)) 3525if (!BinaryPrimitives.TryReadUInt16LittleEndian(data, out ushort lowSurr)) 4375private short GetInt16(int pos) => BinaryPrimitives.ReadInt16LittleEndian(_data.AsSpan(pos)); 4377private ushort GetUInt16(int pos) => BinaryPrimitives.ReadUInt16LittleEndian(_data.AsSpan(pos)); 4379private int GetInt32(int pos) => BinaryPrimitives.ReadInt32LittleEndian(_data.AsSpan(pos)); 4381private uint GetUInt32(int pos) => BinaryPrimitives.ReadUInt32LittleEndian(_data.AsSpan(pos)); 4383private long GetInt64(int pos) => BinaryPrimitives.ReadInt64LittleEndian(_data.AsSpan(pos)); 4385private ulong GetUInt64(int pos) => BinaryPrimitives.ReadUInt64LittleEndian(_data.AsSpan(pos)); 4387private float GetSingle(int offset) => BinaryPrimitives.ReadSingleLittleEndian(_data.AsSpan(offset)); 4389private double GetDouble(int offset) => BinaryPrimitives.ReadDoubleLittleEndian(_data.AsSpan(offset));
System\Xml\Serialization\Compiler.cs (1)
96return BinaryPrimitives.ReadUInt32BigEndian(hash);
System\Xml\XmlEncoding.cs (2)
521code = BinaryPrimitives.ReadUInt32LittleEndian(bytes.AsSpan(i)); 562code = BinaryPrimitives.ReadUInt32BigEndian(bytes.AsSpan(i));
System.Reflection.Emit (5)
System\Reflection\Emit\CustomAttributeWrapper.cs (3)
58int numNamed = BinaryPrimitives.ReadUInt16LittleEndian(binaryAttribute.Slice(pos)); 136return BinaryPrimitives.ReadInt32LittleEndian(data.Slice(pos)); 139return BinaryPrimitives.ReadInt16LittleEndian(data.Slice(pos));
System\Reflection\Emit\FieldBuilderImpl.cs (1)
60_offset = BinaryPrimitives.ReadInt32LittleEndian(binaryAttribute.Slice(2));
System\Reflection\Emit\MethodBuilderImpl.cs (1)
178int implValue = BinaryPrimitives.ReadUInt16LittleEndian(binaryAttribute.Slice(2));
System.Reflection.Metadata (7)
System\Reflection\Internal\Utilities\BlobUtilities.cs (5)
52Unsafe.WriteUnaligned(ref buffer[start], !BitConverter.IsLittleEndian ? BinaryPrimitives.ReverseEndianness(value) : value); 55Unsafe.WriteUnaligned(ref buffer[start], BitConverter.IsLittleEndian ? BinaryPrimitives.ReverseEndianness(value) : value); 58Unsafe.WriteUnaligned(ref buffer[start], BitConverter.IsLittleEndian ? BinaryPrimitives.ReverseEndianness(value) : value); 61Unsafe.WriteUnaligned(ref buffer[start], !BitConverter.IsLittleEndian ? BinaryPrimitives.ReverseEndianness(value) : value); 64Unsafe.WriteUnaligned(ref buffer[start], !BitConverter.IsLittleEndian ? BinaryPrimitives.ReverseEndianness(value) : value);
System\Reflection\Internal\Utilities\MemoryBlock.cs (2)
131return BitConverter.IsLittleEndian ? result : BinaryPrimitives.ReverseEndianness(result); 189return BitConverter.IsLittleEndian ? result : BinaryPrimitives.ReverseEndianness(result);
System.Resources.Extensions (2)
src\libraries\System.Private.CoreLib\src\System\Resources\ResourceReader.cs (2)
177return BinaryPrimitives.ReadInt32LittleEndian(new ReadOnlySpan<byte>(p, sizeof(int))); 411arr[i] = (char)BinaryPrimitives.ReverseEndianness((short)charPtr[i]);
System.Runtime.Numerics (11)
System\Numerics\BigInteger.cs (11)
394BinaryPrimitives.ReverseEndianness(val.AsSpan(0, wholeUInt32Count), val); 1488BinaryPrimitives.WriteUInt32BigEndian(destination.Slice(curByte), dword); 1492BinaryPrimitives.WriteUInt32LittleEndian(destination.Slice(curByte), dword); 3672int value = BitConverter.IsLittleEndian ? BinaryPrimitives.ReverseEndianness(_sign) : _sign; 3688part = BinaryPrimitives.ReverseEndianness(part); 3713part = BinaryPrimitives.ReverseEndianness(part); 3730part = BinaryPrimitives.ReverseEndianness(part); 3774int value = BitConverter.IsLittleEndian ? _sign : BinaryPrimitives.ReverseEndianness(_sign); 3789part = BinaryPrimitives.ReverseEndianness(part); 3814part = BinaryPrimitives.ReverseEndianness(part); 3831part = BinaryPrimitives.ReverseEndianness(part);
System.Security.Cryptography.Cose (3)
System\Security\Cryptography\Cose\CoseHelpers.cs (3)
65BinaryPrimitives.WriteUInt16BigEndian(buffer.Slice(1), (ushort)value); 73BinaryPrimitives.WriteUInt32BigEndian(buffer.Slice(1), (uint)value); 81BinaryPrimitives.WriteUInt64BigEndian(buffer.Slice(1), value);
System.Text.Encoding.CodePages (22)
System\Text\BaseCodePageEncoding.cs (16)
117pTableName[i] = (char)BinaryPrimitives.ReverseEndianness((ushort)pTableName[i]); 122pVersion[i] = BinaryPrimitives.ReverseEndianness(pVersion[i]); 124p->CodePageCount = BinaryPrimitives.ReverseEndianness(p->CodePageCount); 155pCodePageName[i] = (char)BinaryPrimitives.ReverseEndianness((ushort)pCodePageName[i]); 157p->CodePage = BinaryPrimitives.ReverseEndianness(p->CodePage); 158p->ByteCount = BinaryPrimitives.ReverseEndianness(p->ByteCount); 159p->Offset = BinaryPrimitives.ReverseEndianness(p->Offset); 201pCodePageName[i] = (char)BinaryPrimitives.ReverseEndianness((ushort)pCodePageName[i]); 203p->VersionMajor = BinaryPrimitives.ReverseEndianness(p->VersionMajor); 204p->VersionMinor = BinaryPrimitives.ReverseEndianness(p->VersionMinor); 205p->VersionRevision = BinaryPrimitives.ReverseEndianness(p->VersionRevision); 206p->VersionBuild = BinaryPrimitives.ReverseEndianness(p->VersionBuild); 207p->CodePage = BinaryPrimitives.ReverseEndianness(p->CodePage); 208p->ByteCount = BinaryPrimitives.ReverseEndianness(p->ByteCount); 209p->UnicodeReplace = (char)BinaryPrimitives.ReverseEndianness((ushort)p->UnicodeReplace); 210p->ByteReplace = BinaryPrimitives.ReverseEndianness(p->ByteReplace);
System\Text\BaseCodePageEncoding.netcoreapp.cs (4)
28pCodePageName[i] = (char)BinaryPrimitives.ReverseEndianness((ushort)pCodePageName[i]); 30p->CodePage = BinaryPrimitives.ReverseEndianness(p->CodePage); 31p->ByteCount = BinaryPrimitives.ReverseEndianness(p->ByteCount); 32p->Offset = BinaryPrimitives.ReverseEndianness(p->Offset);
System\Text\DBCSCodePageEncoding.cs (1)
53return (char)BinaryPrimitives.ReverseEndianness((ushort)*pChar);
System\Text\SBCSCodePageEncoding.cs (1)
44return BinaryPrimitives.ReverseEndianness(*(ushort*)pByte);
System.Text.Encodings.Web (2)
System\Text\Encodings\Web\AllowedBmpCodePointsBitmap.cs (1)
89thisAllowedCharactersBitmap[i] &= BinaryPrimitives.ReadUInt32LittleEndian(definedCharsBitmapAsLittleEndian.Slice(i * sizeof(uint)));
System\Text\Encodings\Web\OptimizedInboxTextEncoder.cs (1)
277if (BinaryPrimitives.TryWriteUInt64LittleEndian(destination.Slice(dstIdx), preescapedEntry))
System.Windows.Forms.UI.IntegrationTests (3)
Infra\ScreenRecordService.cs (3)
463=> (int)BinaryPrimitives.ReadUInt32BigEndian(memory.Span); 525BinaryPrimitives.WriteUInt16BigEndian(encoded, value); 532BinaryPrimitives.WriteUInt32BigEndian(encoded, value);
Test.Utilities (10)
src\Compilers\Core\Portable\Hashing\XxHash128.cs (5)
225low = BinaryPrimitives.ReverseEndianness(low); 226high = BinaryPrimitives.ReverseEndianness(high); 270uint combinedh = RuntimeBitOperations.RotateLeft(BinaryPrimitives.ReverseEndianness(combinedl), 13); 286seed ^= (ulong)BinaryPrimitives.ReverseEndianness((uint)seed) << 32; 324m128Low ^= BinaryPrimitives.ReverseEndianness(m128High);
src\Compilers\Core\Portable\Hashing\XxHashShared.cs (4)
161static ulong ReadLE64(ulong data) => BitConverter.IsLittleEndian ? data : BinaryPrimitives.ReverseEndianness(data); 795BinaryPrimitives.ReverseEndianness(Unsafe.ReadUnaligned<uint>(data)); 801BinaryPrimitives.ReverseEndianness(Unsafe.ReadUnaligned<ulong>(data)); 808value = BinaryPrimitives.ReverseEndianness(value);
src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\InterceptsLocationUtilities.cs (1)
104var position = BinaryPrimitives.ReadInt32LittleEndian(bytes[PositionIndex..]);
Text.Analyzers (10)
src\Compilers\Core\Portable\Hashing\XxHash128.cs (5)
225low = BinaryPrimitives.ReverseEndianness(low); 226high = BinaryPrimitives.ReverseEndianness(high); 270uint combinedh = RuntimeBitOperations.RotateLeft(BinaryPrimitives.ReverseEndianness(combinedl), 13); 286seed ^= (ulong)BinaryPrimitives.ReverseEndianness((uint)seed) << 32; 324m128Low ^= BinaryPrimitives.ReverseEndianness(m128High);
src\Compilers\Core\Portable\Hashing\XxHashShared.cs (4)
161static ulong ReadLE64(ulong data) => BitConverter.IsLittleEndian ? data : BinaryPrimitives.ReverseEndianness(data); 795BinaryPrimitives.ReverseEndianness(Unsafe.ReadUnaligned<uint>(data)); 801BinaryPrimitives.ReverseEndianness(Unsafe.ReadUnaligned<ulong>(data)); 808value = BinaryPrimitives.ReverseEndianness(value);
src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\InterceptsLocationUtilities.cs (1)
104var position = BinaryPrimitives.ReadInt32LittleEndian(bytes[PositionIndex..]);