763 references to BinaryPrimitives
CodeGenerator (1)
HttpUtilities\HttpUtilities.cs (1)
312return BinaryPrimitives.ReadUInt64LittleEndian(bytes);
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);
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.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.Build (2)
BackEnd\Client\MSBuildClientPacketPump.cs (1)
269int packetLength = BinaryPrimitives.ReadInt32LittleEndian(new Span<byte>(headerByte, 1, 4));
BackEnd\Components\Communications\NodeProviderOutOfProcBase.cs (1)
948int packetLength = BinaryPrimitives.ReadInt32LittleEndian(new Span<byte>(_headerByte, 1, 4));
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.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)
103var position = BinaryPrimitives.ReadInt32LittleEndian(bytes[PositionIndex..]);
Microsoft.CodeAnalysis.CSharp (4)
Compilation\CSharpCompilation.cs (1)
2444BinaryPrimitives.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.Remote.Workspaces (1)
RemoteHostAssetWriter.cs (1)
186BinaryPrimitives.WriteInt32LittleEndian(span, (int)length);
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)
103var 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)
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))]
System.Collections (3)
System\Collections\BitArray.cs (3)
93m_array[i] = BinaryPrimitives.ReadInt32LittleEndian(byteSpan); 795BinaryPrimitives.WriteInt32LittleEndian(span, m_array[i]); 941bits = BinaryPrimitives.ReverseEndianness(bits);
System.Console (1)
System\TermInfo.Database.cs (1)
291=> BinaryPrimitives.ReadInt32LittleEndian(buffer.AsSpan(pos));
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)
1112BinaryPrimitives.WriteInt64BigEndian(destination, destinationValue); 1136BinaryPrimitives.WriteUInt32BigEndian(destination, value < 0 ? 0xffffffff : 0x80000000); 1137BinaryPrimitives.WriteInt64BigEndian(destination.Slice(Offset), value);
System.IO.Compression (109)
System\IO\Compression\ZipArchiveEntry.cs (38)
596BinaryPrimitives.WriteUInt16LittleEndian(cdStaticHeader[ZipCentralDirectoryFileHeader.FieldLocations.VersionNeededToExtract..], (ushort)_versionToExtract); 597BinaryPrimitives.WriteUInt16LittleEndian(cdStaticHeader[ZipCentralDirectoryFileHeader.FieldLocations.GeneralPurposeBitFlags..], (ushort)_generalPurposeBitFlag); 598BinaryPrimitives.WriteUInt16LittleEndian(cdStaticHeader[ZipCentralDirectoryFileHeader.FieldLocations.CompressionMethod..], (ushort)CompressionMethod); 599BinaryPrimitives.WriteUInt32LittleEndian(cdStaticHeader[ZipCentralDirectoryFileHeader.FieldLocations.LastModified..], ZipHelper.DateTimeToDosTime(_lastModified.DateTime)); 600BinaryPrimitives.WriteUInt32LittleEndian(cdStaticHeader[ZipCentralDirectoryFileHeader.FieldLocations.Crc32..], _crc32); 601BinaryPrimitives.WriteUInt32LittleEndian(cdStaticHeader[ZipCentralDirectoryFileHeader.FieldLocations.CompressedSize..], compressedSizeTruncated); 602BinaryPrimitives.WriteUInt32LittleEndian(cdStaticHeader[ZipCentralDirectoryFileHeader.FieldLocations.UncompressedSize..], uncompressedSizeTruncated); 603BinaryPrimitives.WriteUInt16LittleEndian(cdStaticHeader[ZipCentralDirectoryFileHeader.FieldLocations.FilenameLength..], (ushort)_storedEntryNameBytes.Length); 604BinaryPrimitives.WriteUInt16LittleEndian(cdStaticHeader[ZipCentralDirectoryFileHeader.FieldLocations.ExtraFieldLength..], extraFieldLength); 605BinaryPrimitives.WriteUInt16LittleEndian(cdStaticHeader[ZipCentralDirectoryFileHeader.FieldLocations.FileCommentLength..], (ushort)_fileComment.Length); 606BinaryPrimitives.WriteUInt16LittleEndian(cdStaticHeader[ZipCentralDirectoryFileHeader.FieldLocations.DiskNumberStart..], 0); 607BinaryPrimitives.WriteUInt16LittleEndian(cdStaticHeader[ZipCentralDirectoryFileHeader.FieldLocations.InternalFileAttributes..], 0); 608BinaryPrimitives.WriteUInt32LittleEndian(cdStaticHeader[ZipCentralDirectoryFileHeader.FieldLocations.ExternalFileAttributes..], _externalFileAttr); 609BinaryPrimitives.WriteUInt32LittleEndian(cdStaticHeader[ZipCentralDirectoryFileHeader.FieldLocations.RelativeOffsetOfLocalHeader..], offsetOfLocalHeaderTruncated); 1064BinaryPrimitives.WriteUInt16LittleEndian(lfStaticHeader[ZipLocalFileHeader.FieldLocations.VersionNeededToExtract..], (ushort)_versionToExtract); 1065BinaryPrimitives.WriteUInt16LittleEndian(lfStaticHeader[ZipLocalFileHeader.FieldLocations.GeneralPurposeBitFlags..], (ushort)_generalPurposeBitFlag); 1066BinaryPrimitives.WriteUInt16LittleEndian(lfStaticHeader[ZipLocalFileHeader.FieldLocations.CompressionMethod..], (ushort)CompressionMethod); 1067BinaryPrimitives.WriteUInt32LittleEndian(lfStaticHeader[ZipLocalFileHeader.FieldLocations.LastModified..], ZipHelper.DateTimeToDosTime(_lastModified.DateTime)); 1068BinaryPrimitives.WriteUInt32LittleEndian(lfStaticHeader[ZipLocalFileHeader.FieldLocations.Crc32..], _crc32); 1069BinaryPrimitives.WriteUInt32LittleEndian(lfStaticHeader[ZipLocalFileHeader.FieldLocations.CompressedSize..], compressedSizeTruncated); 1070BinaryPrimitives.WriteUInt32LittleEndian(lfStaticHeader[ZipLocalFileHeader.FieldLocations.UncompressedSize..], uncompressedSizeTruncated); 1071BinaryPrimitives.WriteUInt16LittleEndian(lfStaticHeader[ZipLocalFileHeader.FieldLocations.FilenameLength..], (ushort)_storedEntryNameBytes.Length); 1072BinaryPrimitives.WriteUInt16LittleEndian(lfStaticHeader[ZipLocalFileHeader.FieldLocations.ExtraFieldLength..], extraFieldLength); 1236BinaryPrimitives.WriteUInt16LittleEndian(writeBuffer[relativeVersionToExtractLocation..], (ushort)_versionToExtract); 1237BinaryPrimitives.WriteUInt16LittleEndian(writeBuffer[relativeGeneralPurposeBitFlagsLocation..], (ushort)_generalPurposeBitFlag); 1250BinaryPrimitives.WriteUInt32LittleEndian(writeBuffer[relativeCrc32Location..], _crc32); 1251BinaryPrimitives.WriteUInt32LittleEndian(writeBuffer[relativeCompressedSizeLocation..], compressedSizeTruncated); 1252BinaryPrimitives.WriteUInt32LittleEndian(writeBuffer[relativeUncompressedSizeLocation..], uncompressedSizeTruncated); 1268BinaryPrimitives.WriteInt64LittleEndian(writeBuffer[relativeUncompressedSizeLocation..], _uncompressedSize); 1269BinaryPrimitives.WriteInt64LittleEndian(writeBuffer[relativeCompressedSizeLocation..], _compressedSize); 1278BinaryPrimitives.WriteUInt32LittleEndian(writeBuffer.Slice(relativeCrc32Location), _crc32); 1279BinaryPrimitives.WriteInt64LittleEndian(writeBuffer.Slice(relativeCompressedSizeLocation), _compressedSize); 1280BinaryPrimitives.WriteInt64LittleEndian(writeBuffer.Slice(relativeUncompressedSizeLocation), _uncompressedSize); 1303BinaryPrimitives.WriteUInt32LittleEndian(dataDescriptor[ZipLocalFileHeader.ZipDataDescriptor.FieldLocations.Crc32..], _crc32); 1307BinaryPrimitives.WriteInt64LittleEndian(dataDescriptor[ZipLocalFileHeader.Zip64DataDescriptor.FieldLocations.CompressedSize..], _compressedSize); 1308BinaryPrimitives.WriteInt64LittleEndian(dataDescriptor[ZipLocalFileHeader.Zip64DataDescriptor.FieldLocations.UncompressedSize..], _uncompressedSize); 1314BinaryPrimitives.WriteUInt32LittleEndian(dataDescriptor[ZipLocalFileHeader.ZipDataDescriptor.FieldLocations.CompressedSize..], (uint)_compressedSize); 1315BinaryPrimitives.WriteUInt32LittleEndian(dataDescriptor[ZipLocalFileHeader.ZipDataDescriptor.FieldLocations.UncompressedSize..], (uint)_uncompressedSize);
System\IO\Compression\ZipBlocks.cs (71)
40BinaryPrimitives.WriteUInt16LittleEndian(extraFieldHeader[FieldLocations.Tag..], _tag); 41BinaryPrimitives.WriteUInt16LittleEndian(extraFieldHeader[FieldLocations.Size..], _size); 56field._tag = BinaryPrimitives.ReadUInt16LittleEndian(bytes[FieldLocations.Tag..]); 57field._size = BinaryPrimitives.ReadUInt16LittleEndian(bytes[FieldLocations.Size..]); 262zip64Block._uncompressedSize = BinaryPrimitives.ReadInt64LittleEndian(data); 277zip64Block._compressedSize = BinaryPrimitives.ReadInt64LittleEndian(data); 292zip64Block._localHeaderOffset = BinaryPrimitives.ReadInt64LittleEndian(data); 307zip64Block._startDiskNumber = BinaryPrimitives.ReadUInt32LittleEndian(data); 371BinaryPrimitives.WriteUInt16LittleEndian(extraFieldData[FieldLocations.Tag..], TagConstant); 372BinaryPrimitives.WriteUInt16LittleEndian(extraFieldData[FieldLocations.Size..], _size); 376BinaryPrimitives.WriteInt64LittleEndian(extraFieldData[startOffset..], _uncompressedSize.Value); 382BinaryPrimitives.WriteInt64LittleEndian(extraFieldData[startOffset..], _compressedSize.Value); 388BinaryPrimitives.WriteInt64LittleEndian(extraFieldData[startOffset..], _localHeaderOffset.Value); 394BinaryPrimitives.WriteUInt32LittleEndian(extraFieldData[startOffset..], _startDiskNumber.Value); 429NumberOfDiskWithZip64EOCD = BinaryPrimitives.ReadUInt32LittleEndian(blockContents[FieldLocations.NumberOfDiskWithZip64EOCD..]), 430OffsetOfZip64EOCD = BinaryPrimitives.ReadUInt64LittleEndian(blockContents[FieldLocations.OffsetOfZip64EOCD..]), 431TotalNumberOfDisks = BinaryPrimitives.ReadUInt32LittleEndian(blockContents[FieldLocations.TotalNumberOfDisks..]) 452BinaryPrimitives.WriteUInt32LittleEndian(blockContents[FieldLocations.NumberOfDiskWithZip64EOCD..], 0); 453BinaryPrimitives.WriteInt64LittleEndian(blockContents[FieldLocations.OffsetOfZip64EOCD..], zip64EOCDRecordStart); 455BinaryPrimitives.WriteUInt32LittleEndian(blockContents[FieldLocations.TotalNumberOfDisks..], 1); 502SizeOfThisRecord = BinaryPrimitives.ReadUInt64LittleEndian(blockContents[FieldLocations.SizeOfThisRecord..]), 503VersionMadeBy = BinaryPrimitives.ReadUInt16LittleEndian(blockContents[FieldLocations.VersionMadeBy..]), 504VersionNeededToExtract = BinaryPrimitives.ReadUInt16LittleEndian(blockContents[FieldLocations.VersionNeededToExtract..]), 505NumberOfThisDisk = BinaryPrimitives.ReadUInt32LittleEndian(blockContents[FieldLocations.NumberOfThisDisk..]), 506NumberOfDiskWithStartOfCD = BinaryPrimitives.ReadUInt32LittleEndian(blockContents[FieldLocations.NumberOfDiskWithStartOfCD..]), 507NumberOfEntriesOnThisDisk = BinaryPrimitives.ReadUInt64LittleEndian(blockContents[FieldLocations.NumberOfEntriesOnThisDisk..]), 508NumberOfEntriesTotal = BinaryPrimitives.ReadUInt64LittleEndian(blockContents[FieldLocations.NumberOfEntriesTotal..]), 509SizeOfCentralDirectory = BinaryPrimitives.ReadUInt64LittleEndian(blockContents[FieldLocations.SizeOfCentralDirectory..]), 510OffsetOfCentralDirectory = BinaryPrimitives.ReadUInt64LittleEndian(blockContents[FieldLocations.OffsetOfCentralDirectory..]) 531BinaryPrimitives.WriteUInt64LittleEndian(blockContents[FieldLocations.SizeOfThisRecord..], NormalSize); 533BinaryPrimitives.WriteUInt16LittleEndian(blockContents[FieldLocations.VersionMadeBy..], (ushort)ZipVersionNeededValues.Zip64); 535BinaryPrimitives.WriteUInt16LittleEndian(blockContents[FieldLocations.VersionNeededToExtract..], (ushort)ZipVersionNeededValues.Zip64); 537BinaryPrimitives.WriteUInt32LittleEndian(blockContents[FieldLocations.NumberOfThisDisk..], 0); 539BinaryPrimitives.WriteUInt32LittleEndian(blockContents[FieldLocations.NumberOfDiskWithStartOfCD..], 0); 541BinaryPrimitives.WriteInt64LittleEndian(blockContents[FieldLocations.NumberOfEntriesOnThisDisk..], numberOfEntries); 543BinaryPrimitives.WriteInt64LittleEndian(blockContents[FieldLocations.NumberOfEntriesTotal..], numberOfEntries); 544BinaryPrimitives.WriteInt64LittleEndian(blockContents[FieldLocations.SizeOfCentralDirectory..], sizeOfCentralDirectory); 545BinaryPrimitives.WriteInt64LittleEndian(blockContents[FieldLocations.OffsetOfCentralDirectory..], startOfCentralDirectory); 574filenameLength = BinaryPrimitives.ReadUInt16LittleEndian(fixedHeaderBuffer[relativeFilenameLengthLocation..]); 575extraFieldLength = BinaryPrimitives.ReadUInt16LittleEndian(fixedHeaderBuffer[relativeExtraFieldLengthLocation..]); 647ushort filenameLength = BinaryPrimitives.ReadUInt16LittleEndian(blockBytes[relativeFilenameLengthLocation..]); 648ushort extraFieldLength = BinaryPrimitives.ReadUInt16LittleEndian(blockBytes[relativeExtraFieldLengthLocation..]); 728VersionNeededToExtract = BinaryPrimitives.ReadUInt16LittleEndian(buffer[FieldLocations.VersionNeededToExtract..]), 729GeneralPurposeBitFlag = BinaryPrimitives.ReadUInt16LittleEndian(buffer[FieldLocations.GeneralPurposeBitFlags..]), 730CompressionMethod = BinaryPrimitives.ReadUInt16LittleEndian(buffer[FieldLocations.CompressionMethod..]), 731LastModified = BinaryPrimitives.ReadUInt32LittleEndian(buffer[FieldLocations.LastModified..]), 732Crc32 = BinaryPrimitives.ReadUInt32LittleEndian(buffer[FieldLocations.Crc32..]), 733FilenameLength = BinaryPrimitives.ReadUInt16LittleEndian(buffer[FieldLocations.FilenameLength..]), 734ExtraFieldLength = BinaryPrimitives.ReadUInt16LittleEndian(buffer[FieldLocations.ExtraFieldLength..]), 735FileCommentLength = BinaryPrimitives.ReadUInt16LittleEndian(buffer[FieldLocations.FileCommentLength..]), 736InternalFileAttributes = BinaryPrimitives.ReadUInt16LittleEndian(buffer[FieldLocations.InternalFileAttributes..]), 737ExternalFileAttributes = BinaryPrimitives.ReadUInt32LittleEndian(buffer[FieldLocations.ExternalFileAttributes..]) 740compressedSizeSmall = BinaryPrimitives.ReadUInt32LittleEndian(buffer[FieldLocations.CompressedSize..]); 741uncompressedSizeSmall = BinaryPrimitives.ReadUInt32LittleEndian(buffer[FieldLocations.UncompressedSize..]); 742diskNumberStartSmall = BinaryPrimitives.ReadUInt16LittleEndian(buffer[FieldLocations.DiskNumberStart..]); 743relativeOffsetOfLocalHeaderSmall = BinaryPrimitives.ReadUInt32LittleEndian(buffer[FieldLocations.RelativeOffsetOfLocalHeader..]); 883BinaryPrimitives.WriteUInt16LittleEndian(blockContents[FieldLocations.NumberOfThisDisk..], 0); 885BinaryPrimitives.WriteUInt16LittleEndian(blockContents[FieldLocations.NumberOfTheDiskWithTheStartOfTheCentralDirectory..], 0); 887BinaryPrimitives.WriteUInt16LittleEndian(blockContents[FieldLocations.NumberOfEntriesInTheCentralDirectoryOnThisDisk..], numberOfEntriesTruncated); 889BinaryPrimitives.WriteUInt16LittleEndian(blockContents[FieldLocations.NumberOfEntriesInTheCentralDirectory..], numberOfEntriesTruncated); 890BinaryPrimitives.WriteUInt32LittleEndian(blockContents[FieldLocations.SizeOfCentralDirectory..], sizeOfCentralDirectoryTruncated); 891BinaryPrimitives.WriteUInt32LittleEndian(blockContents[FieldLocations.OffsetOfStartOfCentralDirectoryWithRespectToTheStartingDiskNumber..], startOfCentralDirectoryTruncated); 897BinaryPrimitives.WriteUInt16LittleEndian(blockContents[FieldLocations.ArchiveCommentLength..], (ushort)archiveComment.Length); 929Signature = BinaryPrimitives.ReadUInt32LittleEndian(blockContents[FieldLocations.Signature..]), 930NumberOfThisDisk = BinaryPrimitives.ReadUInt16LittleEndian(blockContents[FieldLocations.NumberOfThisDisk..]), 931NumberOfTheDiskWithTheStartOfTheCentralDirectory = BinaryPrimitives.ReadUInt16LittleEndian(blockContents[FieldLocations.NumberOfTheDiskWithTheStartOfTheCentralDirectory..]), 932NumberOfEntriesInTheCentralDirectoryOnThisDisk = BinaryPrimitives.ReadUInt16LittleEndian(blockContents[FieldLocations.NumberOfEntriesInTheCentralDirectoryOnThisDisk..]), 933NumberOfEntriesInTheCentralDirectory = BinaryPrimitives.ReadUInt16LittleEndian(blockContents[FieldLocations.NumberOfEntriesInTheCentralDirectory..]), 934SizeOfCentralDirectory = BinaryPrimitives.ReadUInt32LittleEndian(blockContents[FieldLocations.SizeOfCentralDirectory..]), 936BinaryPrimitives.ReadUInt32LittleEndian(blockContents[FieldLocations.OffsetOfStartOfCentralDirectoryWithRespectToTheStartingDiskNumber..]) 939ushort commentLength = BinaryPrimitives.ReadUInt16LittleEndian(blockContents[FieldLocations.ArchiveCommentLength..]);
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.Net.Http (26)
src\libraries\Common\src\System\Net\Http\aspnetcore\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))
System\Net\Http\SocketsHttpHandler\Http2Connection.cs (18)
209BinaryPrimitives.WriteUInt16BigEndian(_outgoingBuffer.AvailableSpan, (ushort)SettingId.EnablePush); 211BinaryPrimitives.WriteUInt32BigEndian(_outgoingBuffer.AvailableSpan, 0); 213BinaryPrimitives.WriteUInt16BigEndian(_outgoingBuffer.AvailableSpan, (ushort)SettingId.InitialWindowSize); 215BinaryPrimitives.WriteUInt32BigEndian(_outgoingBuffer.AvailableSpan, (uint)_pool.Settings._initialHttp2StreamWindowSize); 225BinaryPrimitives.WriteUInt32BigEndian(_outgoingBuffer.AvailableSpan, windowUpdateAmount); 756if (BinaryPrimitives.TryReadUInt16BigEndian(span, out ushort originLength)) 847ushort settingId = BinaryPrimitives.ReadUInt16BigEndian(settings); 849uint settingValue = BinaryPrimitives.ReadUInt32BigEndian(settings); 996long pingContentLong = BinaryPrimitives.ReadInt64BigEndian(pingContent); 1020int amount = BinaryPrimitives.ReadInt32BigEndian(_incomingBuffer.ActiveSpan) & 0x7FFFFFFF; 1070var protocolError = (Http2ProtocolErrorCode)BinaryPrimitives.ReadInt32BigEndian(_incomingBuffer.ActiveSpan); 1128int lastStreamId = (int)(BinaryPrimitives.ReadUInt32BigEndian(_incomingBuffer.ActiveSpan) & 0x7FFFFFFF); 1129Http2ProtocolErrorCode errorCode = (Http2ProtocolErrorCode)BinaryPrimitives.ReadInt32BigEndian(_incomingBuffer.ActiveSpan.Slice(sizeof(int))); 1308BinaryPrimitives.WriteInt64BigEndian(span.Slice(FrameHeader.Size), state.pingContent); 1320BinaryPrimitives.WriteInt32BigEndian(span.Slice(FrameHeader.Size), (int)s.errorCode); 1778BinaryPrimitives.WriteInt32BigEndian(span.Slice(FrameHeader.Size), s.amount); 1936int streamId = (int)(BinaryPrimitives.ReadUInt32BigEndian(buffer.Slice(5)) & 0x7FFFFFFF); 1949BinaryPrimitives.WriteInt32BigEndian(destination.Slice(5), streamId);
System\Net\Http\SocketsHttpHandler\SocksHelper.cs (2)
182BinaryPrimitives.WriteUInt16BigEndian(buffer.AsSpan(addressLength + 4), (ushort)port); 227BinaryPrimitives.WriteUInt16BigEndian(buffer.AsSpan(2), (ushort)port);
System.Net.NetworkInformation (1)
System\Net\NetworkInformation\PhysicalAddress.cs (1)
32hash ^= BinaryPrimitives.ReadInt32LittleEndian(_address.AsSpan(i));
System.Net.Primitives (10)
src\libraries\Common\src\System\Net\IPv4AddressHelper.Common.cs (1)
55return BinaryPrimitives.ReadInt32BigEndian(numbers);
System\Net\IPAddress.cs (5)
215numbers[i] = BinaryPrimitives.ReadUInt16BigEndian(address.Slice(i * 2)); 369BinaryPrimitives.WriteUInt16BigEndian(destination.Slice(i * 2), numbers[i]); 534return BitConverter.IsLittleEndian ? BinaryPrimitives.ReverseEndianness(host) : host; 539return BitConverter.IsLittleEndian ? BinaryPrimitives.ReverseEndianness(host) : host; 544return BitConverter.IsLittleEndian ? BinaryPrimitives.ReverseEndianness(host) : host;
System\Net\IPNetwork.cs (4)
103mask = BinaryPrimitives.ReverseEndianness(mask); 121mask = BinaryPrimitives.ReverseEndianness(mask); 258mask = BinaryPrimitives.ReverseEndianness(mask); 276mask = BinaryPrimitives.ReverseEndianness(mask);
System.Net.Quic (1)
src\libraries\Common\src\System\Net\IPv4AddressHelper.Common.cs (1)
55return BinaryPrimitives.ReadInt32BigEndian(numbers);
System.Net.Security (27)
src\libraries\Common\src\System\Net\IPv4AddressHelper.Common.cs (1)
55return BinaryPrimitives.ReadInt32BigEndian(numbers);
src\libraries\Common\src\System\Net\Security\MD4.cs (2)
177BinaryPrimitives.WriteUInt32LittleEndian(output.Slice(j), input[i]); 185output[i] = BinaryPrimitives.ReadUInt32LittleEndian(input.Slice(j));
System\Net\NegotiateAuthenticationPal.ManagedNtlm.cs (11)
312return BinaryPrimitives.ReadInt16LittleEndian(span); 318return BinaryPrimitives.ReadInt16LittleEndian(span.Slice(4)); 342BinaryPrimitives.WriteInt16LittleEndian(span, (short)length); 343BinaryPrimitives.WriteInt16LittleEndian(span.Slice(2), (short)length); 344BinaryPrimitives.WriteInt32LittleEndian(span.Slice(4), offset); 442BinaryPrimitives.WriteInt32LittleEndian(prefix.Slice(sizeof(uint) * 4), cbtDataSize); 520BinaryPrimitives.WriteUInt16LittleEndian(targetInfoBuffer.AsSpan(2 + targetInfoOffset), (ushort)spnSize); 577Flags flags = BitConverter.IsLittleEndian ? challengeMessage.Flags : (Flags)BinaryPrimitives.ReverseEndianness((uint)challengeMessage.Flags); 720BinaryPrimitives.WriteInt32LittleEndian(signature, 1); 721BinaryPrimitives.WriteUInt32LittleEndian(signature.Slice(12), sequenceNumber); 736BinaryPrimitives.ReadInt32LittleEndian(signature) != 1 ||
System\Net\Security\NegotiateStream.cs (5)
373readBytes = BinaryPrimitives.ReadInt32LittleEndian(_readHeader); 544BinaryPrimitives.WriteInt32LittleEndian(_writeHeader, _writeBuffer.WrittenCount); 779BinaryPrimitives.WriteInt64LittleEndian(message, ERROR_TRUST_FAILURE); 839BinaryPrimitives.WriteInt64LittleEndian(message, errorCode); 877long error = BinaryPrimitives.ReadInt64LittleEndian(message);
System\Net\Security\TlsFrameHelper.cs (8)
439int extensionListLength = BinaryPrimitives.ReadUInt16BigEndian(p); 477int extensionListLength = BinaryPrimitives.ReadUInt16BigEndian(p); 495ExtensionType extensionType = (ExtensionType)BinaryPrimitives.ReadUInt16BigEndian(extensions); 498ushort extensionLength = BinaryPrimitives.ReadUInt16BigEndian(extensions); 568int serverNameListLength = BinaryPrimitives.ReadUInt16BigEndian(serverNameListExtension); 619int hostNameLength = BinaryPrimitives.ReadUInt16BigEndian(hostNameStruct); 689int AlpnListLength = BinaryPrimitives.ReadUInt16BigEndian(extensionData); 825ushort length = BinaryPrimitives.ReadUInt16BigEndian(bytes);
System.Net.WebSockets (8)
System\Net\WebSockets\ManagedWebSocket.cs (7)
743BinaryPrimitives.WriteUInt16BigEndian(sendBuffer.AsSpan(2), (ushort)payload.Length); 749BinaryPrimitives.WriteUInt64BigEndian(sendBuffer.AsSpan(2), (ulong)payload.Length); 1107closeStatus = (WebSocketCloseStatus)BinaryPrimitives.ReadUInt16BigEndian(_receiveBuffer.Span.Slice(_receiveBufferOffset)); 1213long pongPayload = BinaryPrimitives.ReadInt64BigEndian(_receiveBuffer.Span.Slice(_receiveBufferOffset, (int)header.PayloadLength)); 1322header.PayloadLength = BinaryPrimitives.ReadUInt16BigEndian(receiveBufferSpan.Slice(_receiveBufferOffset)); 1328header.PayloadLength = BinaryPrimitives.ReadInt64BigEndian(receiveBufferSpan.Slice(_receiveBufferOffset)); 1542BinaryPrimitives.WriteUInt16BigEndian(buffer, (ushort)closeStatus);
System\Net\WebSockets\ManagedWebSocket.KeepAlive.cs (1)
118BinaryPrimitives.WriteInt64BigEndian(pingPayloadBuffer, pingPayload);
System.Private.CoreLib (168)
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)
1213result = BinaryPrimitives.ReverseEndianness(result); 1261result = BinaryPrimitives.ReverseEndianness(result); 1284if (BinaryPrimitives.TryWriteUInt16BigEndian(destination, m_value)) 1297if (BinaryPrimitives.TryWriteUInt16LittleEndian(destination, m_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)
74_a = BinaryPrimitives.ReverseEndianness(_a); 75_b = BinaryPrimitives.ReverseEndianness(_b); 76_c = BinaryPrimitives.ReverseEndianness(_c); 91_a = BinaryPrimitives.ReverseEndianness(_a); 92_b = BinaryPrimitives.ReverseEndianness(_b); 93_c = BinaryPrimitives.ReverseEndianness(_c); 251_a = BinaryPrimitives.ReverseEndianness(_a); 252_b = BinaryPrimitives.ReverseEndianness(_b); 253_c = BinaryPrimitives.ReverseEndianness(_c); 549result._de = BitConverter.IsLittleEndian ? BinaryPrimitives.ReverseEndianness((ushort)uintTmp) : (ushort)uintTmp; 552result._fg = BitConverter.IsLittleEndian ? BinaryPrimitives.ReverseEndianness((ushort)uintTmp) : (ushort)uintTmp; 557result._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)
811result = BinaryPrimitives.ReverseEndianness(result); 891result = BinaryPrimitives.ReverseEndianness(result); 909result = BinaryPrimitives.ReverseEndianness(result); 943if (BinaryPrimitives.TryWriteInt128BigEndian(destination, this)) 956if (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)
377result = BinaryPrimitives.ReverseEndianness(result); 457result = BinaryPrimitives.ReverseEndianness(result); 475result = BinaryPrimitives.ReverseEndianness(result); 509if (BinaryPrimitives.TryWriteIntPtrBigEndian(destination, _value)) 522if (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)
353result = BinaryPrimitives.ReverseEndianness(result); 408result = BinaryPrimitives.ReverseEndianness(result); 441if (BinaryPrimitives.TryWriteUIntPtrBigEndian(destination, _value)) 454if (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)
179int implValue = BinaryPrimitives.ReadUInt16LittleEndian(binaryAttribute.Slice(2));
System.Reflection.Metadata (7)
System\Reflection\Internal\Utilities\BlobUtilities.cs (5)
46Unsafe.WriteUnaligned(ref buffer[start], !BitConverter.IsLittleEndian ? BinaryPrimitives.ReverseEndianness(value) : value); 49Unsafe.WriteUnaligned(ref buffer[start], BitConverter.IsLittleEndian ? BinaryPrimitives.ReverseEndianness(value) : value); 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);
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 (9)
System\Numerics\BigInteger.cs (9)
394BinaryPrimitives.ReverseEndianness(val.AsSpan(0, wholeUInt32Count), val); 3645int value = BitConverter.IsLittleEndian ? BinaryPrimitives.ReverseEndianness(_sign) : _sign; 3661part = BinaryPrimitives.ReverseEndianness(part); 3686part = BinaryPrimitives.ReverseEndianness(part); 3703part = BinaryPrimitives.ReverseEndianness(part); 3747int value = BitConverter.IsLittleEndian ? _sign : BinaryPrimitives.ReverseEndianness(_sign); 3762part = BinaryPrimitives.ReverseEndianness(part); 3787part = BinaryPrimitives.ReverseEndianness(part); 3804part = BinaryPrimitives.ReverseEndianness(part);
System.Security.Cryptography (9)
src\libraries\Common\src\System\Security\Cryptography\RsaPaddingProcessor.cs (1)
598BinaryPrimitives.WriteInt32BigEndian(bigEndianCount, count);
System\Security\Cryptography\DES.cs (2)
72ulong key = BinaryPrimitives.ReadUInt64BigEndian(rgbOddParityKey); 90ulong key = BinaryPrimitives.ReadUInt64BigEndian(rgbOddParityKey);
System\Security\Cryptography\PKCS1MaskGenerationMethod.cs (1)
43BinaryPrimitives.WriteUInt32BigEndian(rgbCounter, counter++);
System\Security\Cryptography\Rfc2898DeriveBytes.cs (1)
289BinaryPrimitives.WriteUInt32BigEndian(_salt.AsSpan(_salt.Length - sizeof(uint)), _block + 1);
System\Security\Cryptography\SP800108HmacCounterKdfImplementationManaged.cs (2)
49BinaryPrimitives.WriteUInt32BigEndian(lBuffer, (uint)destination.Length * 8U); 53BinaryPrimitives.WriteUInt32BigEndian(iBuffer, i);
System\Security\Cryptography\X509Certificates\UnixExportProvider.cs (1)
154BinaryPrimitives.WriteInt32LittleEndian(localKeyIdAttributeValue, localKeyIdCounter);
System\Security\Cryptography\XmlKeyHelper.cs (1)
107BinaryPrimitives.WriteInt32BigEndian(valBuf, value);
System.Security.Cryptography.Cose (3)
System\Security\Cryptography\Cose\CoseHelpers.cs (3)
62BinaryPrimitives.WriteUInt16BigEndian(buffer.Slice(1), (ushort)value); 70BinaryPrimitives.WriteUInt32BigEndian(buffer.Slice(1), (uint)value); 78BinaryPrimitives.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);