BitConverter

src\Workspaces\Core\Portable\Shared\Extensions\TelemetryExtensions.cs (1)

28var suffixBytes = BitConverter.GetBytes(suffix).Concat(new byte[4]).ToArray();

CompilerNuGetCheckerUtil.cs (1)

336return BitConverter.ToString(hash.ComputeHash(stream));

CompilationDiff.cs (1)

404var hashString = BitConverter.ToString(info.CompressedHash.ToArray()).Replace("-", "");

src\Compilers\Core\CommandLine\BuildProtocol.cs (4)

127var length = BitConverter.ToInt32(lengthBuffer, 0); 184await outStream.WriteAsync(BitConverter.GetBytes(length), 0, 4, 300await outStream.WriteAsync(BitConverter.GetBytes(length), 323var length = BitConverter.ToUInt32(lengthBuffer, 0);

FrameworkFork\Microsoft.Xml\Xml\XmlEncoding.cs (2)

65if (_bigEndian == BitConverter.IsLittleEndian) 128if (_bigEndian == BitConverter.IsLittleEndian)

FrameworkFork\System.Runtime.Serialization\System\Xml\XmlBinaryReader.cs (6)

1271if (IsStartArray(localName, namespaceUri, XmlBinaryNodeType.Int16TextWithEndElement) && BitConverter.IsLittleEndian) 1278if (IsStartArray(localName, namespaceUri, XmlBinaryNodeType.Int16TextWithEndElement) && BitConverter.IsLittleEndian) 1303if (IsStartArray(localName, namespaceUri, XmlBinaryNodeType.Int32TextWithEndElement) && BitConverter.IsLittleEndian) 1310if (IsStartArray(localName, namespaceUri, XmlBinaryNodeType.Int32TextWithEndElement) && BitConverter.IsLittleEndian) 1335if (IsStartArray(localName, namespaceUri, XmlBinaryNodeType.Int64TextWithEndElement) && BitConverter.IsLittleEndian) 1342if (IsStartArray(localName, namespaceUri, XmlBinaryNodeType.Int64TextWithEndElement) && BitConverter.IsLittleEndian)

src\RoslynAnalyzers\Utilities\Compiler\RoslynHashCode.cs (1)

84return BitConverter.ToUInt32(array, 0);

src\RoslynAnalyzers\Utilities\Compiler\RoslynHashCode.cs (1)

84return BitConverter.ToUInt32(array, 0);

Internal\BinaryBlob.cs (1)

74return BitConverter.ToInt32(_data, 0);

BinaryBlobTest.cs (1)

115var expectedHashCode = BitConverter.ToInt32(blobData, 0);

src\Shared\HashCode.cs (1)

75return BitConverter.ToUInt32(array, 0);

src\submodules\MessagePack-CSharp\src\MessagePack.UnityClient\Assets\Scripts\MessagePack\SequenceReaderExtensions.cs (3)

136if (!BitConverter.IsLittleEndian) 177if (!BitConverter.IsLittleEndian) 218if (!BitConverter.IsLittleEndian)

KeyManagement\KeyRingBasedDataProtectorTests.cs (1)

626.Concat(BitConverter.GetBytes(IPAddress.HostToNetworkOrder(purposes.Length))); // purposeCount

src\Shared\HashCode.cs (1)

75return BitConverter.ToUInt32(array, 0);

src\Shared\HashCode.cs (1)

75return BitConverter.ToUInt32(array, 0);

src\Identity\Extensions.Core\src\Rfc6238AuthenticationService.cs (1)

39var res = BitConverter.TryWriteBytes(timestepAsBytes, IPAddress.HostToNetworkOrder((long)timestepNumber));

Cache\DistributedCacheTagHelperService.cs (2)

168var keyLength = BitConverter.GetBytes(serializedKey.Length); 187var keyLength = BitConverter.ToInt32(keyLengthBuffer, 0);

src\Shared\HashCode.cs (1)

75return BitConverter.ToUInt32(array, 0);

OutputCacheEntryFormatterTests.cs (1)

76var hex = BitConverter.ToString(payload);

Internal\Http\HttpHeaders.cs (4)

502if (!BitConverter.IsLittleEndian) 516if (!BitConverter.IsLittleEndian) 646if (!BitConverter.IsLittleEndian) 666if (!BitConverter.IsLittleEndian)

Internal\Http\HttpHeaders.Generated.cs (3)

7487if (!BitConverter.IsLittleEndian) 7497if (!BitConverter.IsLittleEndian) 7507if (!BitConverter.IsLittleEndian)

Http2\Http2HPackEncoderTests.cs (8)

28var hex = BitConverter.ToString(result); 51var hex = BitConverter.ToString(result); 79var hex = BitConverter.ToString(result); 121hex = BitConverter.ToString(result); 162hex = BitConverter.ToString(result); 223var hex = BitConverter.ToString(result); 265hex = BitConverter.ToString(result); 306hex = BitConverter.ToString(result);

Http3\Http3QPackEncoderTests.cs (6)

25var hex = BitConverter.ToString(result); 42var hex = BitConverter.ToString(result); 91var hex = BitConverter.ToString(result); 110var hex = BitConverter.ToString(result); 129var hex = BitConverter.ToString(result); 148var hex = BitConverter.ToString(result);

KnownStringsTests.cs (1)

27static readonly byte[] _invalidMethod1 = BitConverter.GetBytes((ulong)MagicNumber);

CommunicationsUtilities.cs (4)

463byte[] bytes = BitConverter.GetBytes(value); 467if (BitConverter.IsLittleEndian) 575if (BitConverter.IsLittleEndian) 580result = BitConverter.ToInt32(bytes, 0 /* start index */);

MSBuildNameIgnoreCaseComparer.cs (2)

149if (BitConverter.IsLittleEndian) 169if (BitConverter.IsLittleEndian)

src\Compilers\Core\CommandLine\BuildProtocol.cs (4)

127var length = BitConverter.ToInt32(lengthBuffer, 0); 184await outStream.WriteAsync(BitConverter.GetBytes(length), 0, 4, 300await outStream.WriteAsync(BitConverter.GetBytes(length), 323var length = BitConverter.ToUInt32(lengthBuffer, 0);

MSBuildNameIgnoreCaseComparer.cs (2)

149if (BitConverter.IsLittleEndian) 169if (BitConverter.IsLittleEndian)

MSBuildNameIgnoreCaseComparer.cs (2)

149if (BitConverter.IsLittleEndian) 169if (BitConverter.IsLittleEndian)

CodeGen\ILBuilderEmit.cs (3)

774int int32 = BitConverter.ToInt32(BitConverter.GetBytes(floatValue), 0); 780long int64 = BitConverter.DoubleToInt64Bits(doubleValue);

Collections\Boxes.cs (1)

89return BitConverter.DoubleToInt64Bits(d) == 0 ? BoxedDoubleZero : d;

ConstantValue.cs (3)

285if (BitConverter.DoubleToInt64Bits(value) == 0) 299if (BitConverter.DoubleToInt64Bits(value) == 0) 313if (BitConverter.DoubleToInt64Bits(value) == 0)

ConstantValueSpecialized.cs (1)

26private static readonly double _s_IEEE_canonical_NaN = BitConverter.Int64BitsToDouble(unchecked((long)0xFFF8000000000000UL));

Emit\EditAndContinue\EncLocalInfo.cs (1)

82(Signature != null) ? BitConverter.ToString(Signature) : "null");

Emit\EditAndContinueMethodDebugInformation.cs (2)

84offset, (start != 0) ? "..." : "", BitConverter.ToString(left), BitConverter.ToString(right), (end != data.Length) ? "..." : ""));

Hashing\XxHash128.cs (1)

223if (BitConverter.IsLittleEndian)

Hashing\XxHashShared.cs (12)

RealParser.cs (3)

38d = BitConverter.Int64BitsToDouble((long)result); 265public override ulong Zero => (ulong)BitConverter.DoubleToInt64Bits(0.0d); 266public override ulong Infinity => (ulong)BitConverter.DoubleToInt64Bits(double.PositiveInfinity);

src\Dependencies\CodeAnalysis.Debugging\CustomDebugInfoReader.cs (1)

48size = BitConverter.ToInt32(bytes, offset + 4);

StrongName\StrongNameKeys.cs (1)

99nameof(CompilationOptions.CryptoPublicKey), BitConverter.ToString(publicKey.ToArray())));

Text\SourceText.cs (1)

649if (!BitConverter.IsLittleEndian)

src\RoslynAnalyzers\Utilities\Compiler\RoslynHashCode.cs (1)

84return BitConverter.ToUInt32(array, 0);

src\RoslynAnalyzers\Utilities\Compiler\RoslynHashCode.cs (1)

84return BitConverter.ToUInt32(array, 0);

src\RoslynAnalyzers\Utilities\Compiler\RoslynHashCode.cs (1)

84return BitConverter.ToUInt32(array, 0);

src\Compilers\Core\Portable\Collections\Boxes.cs (1)

89return BitConverter.DoubleToInt64Bits(d) == 0 ? BoxedDoubleZero : d;

src\Compilers\Core\Portable\Hashing\XxHash128.cs (1)

223if (BitConverter.IsLittleEndian)

src\Compilers\Core\Portable\Hashing\XxHashShared.cs (4)

161static ulong ReadLE64(ulong data) => BitConverter.IsLittleEndian ? data : BinaryPrimitives.ReverseEndianness(data); 793BitConverter.IsLittleEndian ? 799BitConverter.IsLittleEndian ? 806if (!BitConverter.IsLittleEndian)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Serialization\ObjectReader.cs (1)

45Debug.Assert(BitConverter.IsLittleEndian);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Serialization\ObjectWriter.cs (1)

90Debug.Assert(BitConverter.IsLittleEndian);

Utilities\ValueSetFactory.DoubleTC.cs (2)

56return (ulong)BitConverter.DoubleToInt64Bits(d); 61return BitConverter.Int64BitsToDouble((long)l);

Emit\DynamicAnalysis\DynamicAnalysisResourceTests.cs (1)

1075let hash = d.Hash.IsNil ? "" : " " + BitConverter.ToString(reader.GetBytes(d.Hash))

Emit\EditAndContinue\EditAndContinueTests.cs (3)

12662Assert.Equal("20-01-01-08", BitConverter.ToString(value0)); 12672Assert.Equal("07-02-0E-0C", BitConverter.ToString(value1)); 12677Assert.Equal("07-03-0E-0C-02", BitConverter.ToString(value2));

PDB\PDBTests.cs (3)

83<file id=""1"" name=""Foo.cs"" language=""C#"" checksumAlgorithm=""SHA1"" checksum=""" + BitConverter.ToString(hash1) + @""" /> 85<file id=""3"" name=""Bar.cs"" language=""C#"" checksumAlgorithm=""SHA1"" checksum=""" + BitConverter.ToString(hash3) + @""" /> 86<file id=""4"" name=""Baz.cs"" language=""C#"" checksumAlgorithm=""SHA1"" checksum=""" + BitConverter.ToString(hash4) + @""" />

CustomDebugInfoReader.cs (1)

48size = BitConverter.ToInt32(bytes, offset + 4);

src\Test\PdbUtilities\Shared\DateTimeUtilities.cs (1)

20var tickCount = BitConverter.DoubleToInt64Bits(raw) & TicksMask;

src\Test\PdbUtilities\Shared\DateTimeUtilities.cs (1)

20var tickCount = BitConverter.DoubleToInt64Bits(raw) & TicksMask;

src\Test\PdbUtilities\Shared\DateTimeUtilities.cs (1)

20var tickCount = BitConverter.DoubleToInt64Bits(raw) & TicksMask;

PdbSourceDocument\PdbSourceDocumentLoaderService.cs (1)

64var uncompressedSize = BitConverter.ToInt32(embeddedTextBytes, 0);

src\Dependencies\CodeAnalysis.Debugging\CustomDebugInfoReader.cs (1)

48size = BitConverter.ToInt32(bytes, offset + 4);

EditAndContinue\EditAndContinueMethodDebugInfoReaderTests.cs (1)

112Assert.Equal("21-C8-B2-D7-A3-6B-49-C7-57-DF-67-B8-1F-75-DF-6A-64-FD-59-22", BitConverter.ToString([.. actualChecksum]));

src\RoslynAnalyzers\Utilities\Compiler\RoslynHashCode.cs (1)

84return BitConverter.ToUInt32(array, 0);

CompilationOptionsReader.cs (1)

209int uncompressedSize = BitConverter.ToInt32(bytes, 0);

src\RoslynAnalyzers\Utilities\Compiler\RoslynHashCode.cs (1)

84return BitConverter.ToUInt32(array, 0);

Metadata\MetadataReaderUtils.cs (1)

284int uncompressedSize = BitConverter.ToInt32(bytes, 0);

Mocks\Silverlight.cs (1)

79Debug.Assert("7C-EC-85-D7-BE-A7-79-8E" == BitConverter.ToString(publicKeyToken.ToArray()));

Mocks\StdOle.cs (1)

66Debug.Assert("B0-3F-5F-7F-11-D5-0A-3A" == BitConverter.ToString(publicKeyToken.ToArray()));

EmbeddedTextTests.cs (4)

165AssertEx.Equal(BitConverter.GetBytes(bytes.Length), text.Blob.Take(4)); 180AssertEx.Equal(BitConverter.GetBytes(bytes.Length), text.Blob.Take(4)); 193AssertEx.Equal(BitConverter.GetBytes(Encoding.Unicode.GetPreamble().Length + LargeSource.Length * sizeof(char)), text.Blob.Take(4)); 244AssertEx.Equal(BitConverter.GetBytes(bytes.Length), text.Blob.Take(4));

RealParserTests.cs (3)

181var tenToThePow = (ulong)BitConverter.DoubleToInt64Bits(value); 382double d = BitConverter.Int64BitsToDouble((long)bits); 401CheckOneDouble(s, BitConverter.Int64BitsToDouble((long)expectedBits));

FindSymbols\FindLiterals\FindLiteralsSearchEngine.cs (2)

53_longValue = BitConverter.DoubleToInt64Bits(d); 57_longValue = BitConverter.DoubleToInt64Bits(f);

FindSymbols\SyntaxTree\SyntaxTreeIndex_Create.cs (2)

164longLiterals.Add(BitConverter.DoubleToInt64Bits(d)); 167longLiterals.Add(BitConverter.DoubleToInt64Bits(f));

Shared\Extensions\TelemetryExtensions.cs (1)

28var suffixBytes = BitConverter.GetBytes(suffix).Concat(new byte[4]).ToArray();

src\Compilers\Core\Portable\Collections\Boxes.cs (1)

89return BitConverter.DoubleToInt64Bits(d) == 0 ? BoxedDoubleZero : d;

src\Compilers\Core\Portable\Hashing\XxHash128.cs (1)

223if (BitConverter.IsLittleEndian)

src\Compilers\Core\Portable\Hashing\XxHashShared.cs (12)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Serialization\ObjectReader.cs (1)

45Debug.Assert(BitConverter.IsLittleEndian);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Serialization\ObjectWriter.cs (1)

90Debug.Assert(BitConverter.IsLittleEndian);

DataFrameTests.Utils.cs (1)

66byte[] offsetValueBytes = BitConverter.GetBytes(offsetValue);

src\GenerateChecksums.cs (1)

47string checksum = BitConverter.ToString(hash).Replace("-", string.Empty);

src\GenerateSourcePackageSourceLinkTargetsFile.cs (1)

110hash = BitConverter.ToString(hashAlg.ComputeHash(Encoding.UTF8.GetBytes(packageId)), 0, 20).Replace("-", "");

src\RpmHeader.cs (1)

57builder.AppendLine($"\t\t{BitConverter.ToString(((ArraySegment<byte>)entry.Value).Array!, ((ArraySegment<byte>)entry.Value).Offset, ((ArraySegment<byte>)entry.Value).Count)}");

Vsix\FinalizeInsertionVsixFile.cs (1)

123file["sha256"] = BitConverter.ToString(partHash).Replace("-", "");

Utils.cs (12)

133int timeLow = IPAddress.HostToNetworkOrder(BitConverter.ToInt32(namespaceBytes, 0)); 135short timeMid = IPAddress.HostToNetworkOrder(BitConverter.ToInt16(namespaceBytes, 4)); 137short timeHiVersion = IPAddress.HostToNetworkOrder(BitConverter.ToInt16(namespaceBytes, 6)); 143Buffer.BlockCopy(BitConverter.GetBytes(timeLow), 0, hashBuffer, 0, 4); 144Buffer.BlockCopy(BitConverter.GetBytes(timeMid), 0, hashBuffer, 4, 2); 145Buffer.BlockCopy(BitConverter.GetBytes(timeHiVersion), 0, hashBuffer, 6, 2); 158timeLow = IPAddress.NetworkToHostOrder(BitConverter.ToInt32(hash, 0)); 159Buffer.BlockCopy(BitConverter.GetBytes(timeLow), 0, hash, 0, 4); 162timeMid = IPAddress.NetworkToHostOrder(BitConverter.ToInt16(hash, 4)); 163Buffer.BlockCopy(BitConverter.GetBytes(timeMid), 0, hash, 4, 2); 166timeHiVersion = IPAddress.NetworkToHostOrder(BitConverter.ToInt16(hash, 6)); 170Buffer.BlockCopy(BitConverter.GetBytes(timeHiVersion), 0, hash, 6, 2);

Verification\LZMAUtils.cs (1)

36long fileLength = BitConverter.ToInt64(fileLengthBytes, 0);

src\ContentUtil.cs (1)

51=> BitConverter.ToString(hash.ToArray()).Replace("-", "");

Signing.cs (2)

72tokenStr = BitConverter.ToString(token).Replace("-", "").ToLowerInvariant(); 224var checksumBytes = BitConverter.GetBytes(checksum);

Utils.cs (1)

95var flagBytes = BitConverter.GetBytes((uint)(peHeaders.CorHeader.Flags | CorFlags.StrongNameSigned));

AzureAIInferenceEmbeddingGenerator.cs (1)

146if (!BitConverter.IsLittleEndian)

SerializerTests.cs (1)

300return BitConverter.ToString(value.ToArray());

RedisCacheSetAndRemoveTests.cs (1)

175static string Hex(byte[] value) => BitConverter.ToString(value);

Rfc6238AuthenticationService.cs (1)

39var res = BitConverter.TryWriteBytes(timestepAsBytes, IPAddress.HostToNetworkOrder((long)timestepNumber));

Services\Crc64HashAlgorithm.cs (1)

167 protected override byte[] HashFinal() => BitConverter.GetBytes(crc ^ length);

src\Core\src\Services\Crc64HashAlgorithm.cs (1)

167 protected override byte[] HashFinal() => BitConverter.GetBytes(crc ^ length);

SseIntrinsics.cs (1)

68Vector128.Create(BitConverter.Int32BitsToSingle(0x7FFFFFFF));

Utils\ToByteArrayExtensions.cs (8)

61short a = BitConverter.ToInt16(buffer, position); 83ushort a = BitConverter.ToUInt16(buffer, position); 105int a = BitConverter.ToInt32(buffer, position); 127uint a = BitConverter.ToUInt32(buffer, position); 149long a = BitConverter.ToInt64(buffer, position); 171ulong a = BitConverter.ToUInt64(buffer, position); 193float a = BitConverter.ToSingle(buffer, position); 215double a = BitConverter.ToDouble(buffer, position);

ParquetLoader.cs (2)

731ulong lo = BitConverter.ToUInt64(arr, 0); 732ulong hi = BitConverter.ToUInt64(arr, 8);

Normalizer\SentencePieceNormalizer.cs (2)

500if (!BitConverter.IsLittleEndian) 512if (!BitConverter.IsLittleEndian)

ImageClassificationTrainer.cs (4)

891featuresWriter.Write(BitConverter.GetBytes(examples), 0, sizeof(int)); 892featuresWriter.Write(BitConverter.GetBytes(featureLength), 0, sizeof(int)); 983int trainingExamples = BitConverter.ToInt32(buffer, 0); 985int featureFileRecordSize = sizeof(float) * BitConverter.ToInt32(buffer, 0);

InternableString.cs (2)

357hash ^= BitConverter.IsLittleEndian ? ((uint)*charPtr << 16) : *charPtr; 374hash = (RotateLeft(hash, 5) + hash) ^ (BitConverter.IsLittleEndian ? *((char*)ptr) : ((uint)*((char*)ptr) << 16));

Microsoft\VisualBasic\Strings.vb (2)

197If BitConverter.IsLittleEndian Then 204Return BitConverter.ToInt16(b, 0)

Microsoft\VisualBasic\VBMath.vb (9)

29rndSeed = BitConverter.ToInt32(BitConverter.GetBytes(Number), 0) 55lValue = BitConverter.ToInt32(BitConverter.GetBytes(sngTimer), 0) 78If BitConverter.IsLittleEndian Then 79lValue = BitConverter.ToInt32(BitConverter.GetBytes(Number), 4) 81lValue = BitConverter.ToInt32(BitConverter.GetBytes(Number), 0)

CodeMarkers\ManagedCodeMarkers.cs (4)

326return CodeMarkerEx(nTimerID, BitConverter.GetBytes(uintData)); 339return CodeMarkerEx(nTimerID, BitConverter.GetBytes(ulongData)); 559: this(begin, end, BitConverter.GetBytes(uintData)) 566: this(begin, end, BitConverter.GetBytes(ulongData))

CommunicationsUtilities.cs (4)

463byte[] bytes = BitConverter.GetBytes(value); 467if (BitConverter.IsLittleEndian) 575if (BitConverter.IsLittleEndian) 580result = BitConverter.ToInt32(bytes, 0 /* start index */);

MSBuildNameIgnoreCaseComparer.cs (2)

149if (BitConverter.IsLittleEndian) 169if (BitConverter.IsLittleEndian)

CommunicationsUtilities.cs (4)

463byte[] bytes = BitConverter.GetBytes(value); 467if (BitConverter.IsLittleEndian) 575if (BitConverter.IsLittleEndian) 580result = BitConverter.ToInt32(bytes, 0 /* start index */);

src\libraries\shims\mscorlib\ref\mscorlib.cs (1)

63[assembly: System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.BitConverter))]

netstandard.cs (1)

56[assembly: System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.BitConverter))]

MS\Internal\WindowsRuntime\Generated\WinRT\GuidGenerator.cs (1)

105if (BitConverter.IsLittleEndian)

System\Windows\Markup\Baml2006\Baml2006Reader.cs (1)

1810value = BitConverter.GetBytes(valueId);

src\Compilers\Core\CommandLine\BuildProtocol.cs (4)

127var length = BitConverter.ToInt32(lengthBuffer, 0); 184await outStream.WriteAsync(BitConverter.GetBytes(length), 0, 4, 300await outStream.WriteAsync(BitConverter.GetBytes(length), 323var length = BitConverter.ToUInt32(lengthBuffer, 0);

src\RoslynAnalyzers\Utilities\Compiler\RoslynHashCode.cs (1)

84return BitConverter.ToUInt32(array, 0);

Reader\MockSymUnmanagedReader.cs (2)

402var shortBytes = BitConverter.GetBytes(s); 409var intBytes = BitConverter.GetBytes(i);

Reader\Token2SourceLineExporter.cs (2)

235float result = BitConverter.ToSingle(_buffer, _offset); 242double result = BitConverter.ToDouble(_buffer, _offset);

Shared\DateTimeUtilities.cs (1)

20var tickCount = BitConverter.DoubleToInt64Bits(raw) & TicksMask;

Panels\WorkspacePanel.xaml.cs (2)

102output.AppendLine($"{document.FilePath}: {BitConverter.ToString([.. snapshotChecksum])} : {BitConverter.ToString([.. fileChecksum])}");

UnifiedSettings\UnifiedSettingsTests.cs (1)

283var expectedTags = BitConverter.ToInt64([.. XxHash128.Hash(fileBytes).Take(8)], 0).ToString("X16");

GenerateFilteredReferenceAssembliesTask.cs (3)

471Debug.Assert(BitConverter.IsLittleEndian); 505Debug.Assert(BitConverter.IsLittleEndian); 539Debug.Assert(BitConverter.IsLittleEndian);

System\Collections\BitArray.cs (3)

893Vector128<byte> bitMask128 = BitConverter.IsLittleEndian ? 919Vector128<byte> bitMask128 = BitConverter.IsLittleEndian ? 939if (!BitConverter.IsLittleEndian)

System\Data\Common\ObjectStorage.cs (10)

Common\System\Data\ProviderBase\DbBuffer.cs (8)

206return BitConverter.Int64BitsToDouble(value); 368return BitConverter.Int32BitsToSingle(value); 486WriteInt64(offset, BitConverter.DoubleToInt64Bits(value)); 639WriteInt32(offset, BitConverter.SingleToInt32Bits(value)); 753buffer[0] = BitConverter.ToInt32(bits, 4); // low 754buffer[1] = BitConverter.ToInt32(bits, 8); // mid 755buffer[2] = BitConverter.ToInt32(bits, 12); // high 756if (0 != BitConverter.ToInt32(bits, 16))

System\Data\Odbc\OdbcConnection.cs (6)

399value = (BitConverter.IsLittleEndian ? Encoding.Unicode : Encoding.BigEndianUnicode).GetString(buffer, 0, Math.Min(cbActual, buffer.Length)); 425retval = BitConverter.ToInt32(buffer, 0); 458resultValue = BitConverter.ToInt16(buffer, 0); 466resultValue = BitConverter.ToInt32(buffer, 0); 474return BitConverter.ToInt32(buffer, 0); 501value = (BitConverter.IsLittleEndian ? Encoding.Unicode : Encoding.BigEndianUnicode).GetString(buffer, 0, Math.Min(cbActual, buffer.Length));

System\Diagnostics\Activity.cs (2)

1981if (BitConverter.IsLittleEndian) 2164if (BitConverter.IsLittleEndian)

System\Diagnostics\Metrics\ExponentialHistogramAggregator.cs (2)

183ulong bits = (ulong)BitConverter.DoubleToInt64Bits(measurement); 209return BitConverter.Int64BitsToDouble(bits);

System\Drawing\Imaging\ImageCodecInfoTests.cs (3)

107Assert.Equal(mask, BitConverter.ToString(codecInfo.SignatureMasks[i])); 111Assert.Equal(pattern, BitConverter.ToString(codecInfo.SignaturePatterns[0])); 113Assert.Equal(pattern2, BitConverter.ToString(codecInfo.SignaturePatterns[1]));

System\Formats\Cbor\Writer\CborWriter.Simple.cs (2)

137return double.IsNaN(value) || BitConverter.DoubleToInt64Bits(result) == BitConverter.DoubleToInt64Bits(value);

System\Formats\Cbor\Writer\CborWriter.Simple.netcoreapp.cs (2)

40return float.IsNaN(value) || BitConverter.SingleToInt32Bits((float)result) == BitConverter.SingleToInt32Bits(value);

System\Formats\Nrbf\ArraySinglePrimitiveRecord.cs (1)

160if (!BitConverter.IsLittleEndian)

System\IO\FileSystemWatcher.Linux.cs (4)

834readEvent.wd = BitConverter.ToInt32(_buffer, _bufferPos); 835readEvent.mask = BitConverter.ToUInt32(_buffer, _bufferPos + 4); // +4 to get past wd 836readEvent.cookie = BitConverter.ToUInt32(_buffer, _bufferPos + 8); // +8 to get past wd, mask 837int nameLength = (int)BitConverter.ToUInt32(_buffer, _bufferPos + 12); // +12 to get past wd, mask, cookie

System\IO\Hashing\Crc32.Vectorized.cs (1)

19BitConverter.IsLittleEndian

System\IO\Hashing\Crc64.Vectorized.cs (1)

19if (BitConverter.IsLittleEndian)

System\IO\Hashing\XxHash128.cs (1)

219if (BitConverter.IsLittleEndian)

System\IO\Hashing\XxHash3.cs (1)

108if (BitConverter.IsLittleEndian)

System\IO\Hashing\XxHashShared.cs (12)

System\Buffers\SequenceReaderExtensions.Binary.cs (6)

62if (BitConverter.IsLittleEndian) 76if (!BitConverter.IsLittleEndian) 101if (BitConverter.IsLittleEndian) 115if (!BitConverter.IsLittleEndian) 140if (BitConverter.IsLittleEndian) 154if (!BitConverter.IsLittleEndian)

System\Net\Http\HttpContent.cs (2)

63$"Expected (constant): {BitConverter.ToString(preamble.ToArray())}, Actual (Encoding.GetPreamble()): {BitConverter.ToString(actualPreamble)}");

System\Net\Http\SocketsHttpHandler\ChunkedEncodingReadStream.cs (2)

335throw new HttpIOException(HttpRequestError.InvalidResponse, SR.Format(SR.net_http_invalid_response_chunk_header_invalid, BitConverter.ToString(currentLine.ToArray()))); 452throw new HttpIOException(HttpRequestError.InvalidResponse, SR.Format(SR.net_http_invalid_response_chunk_extension_invalid, BitConverter.ToString(lineAfterChunkSize.ToArray())));

System\Net\Http\SocketsHttpHandler\HttpConnection.cs (3)

42private static readonly ulong s_http10Bytes = BitConverter.ToUInt64("HTTP/1.0"u8); 43private static readonly ulong s_http11Bytes = BitConverter.ToUInt64("HTTP/1.1"u8); 1068ulong first8Bytes = BitConverter.ToUInt64(line);

System\Net\NetworkInformation\StringParsingHelpers.Connections.cs (1)

362if (isNetworkOrder || !BitConverter.IsLittleEndian)

System\Net\IPAddress.cs (5)

204if (Vector128.IsHardwareAccelerated && BitConverter.IsLittleEndian) 357if (BitConverter.IsLittleEndian) 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)

101if (BitConverter.IsLittleEndian) 119if (BitConverter.IsLittleEndian) 256if (BitConverter.IsLittleEndian) 274if (BitConverter.IsLittleEndian)

System\Net\NegotiateAuthenticationPal.ManagedNtlm.cs (2)

489time = DateTime.FromFileTimeUtc(BitConverter.ToInt64(info.Slice(4, 8))); 577Flags flags = BitConverter.IsLittleEndian ? challengeMessage.Flags : (Flags)BinaryPrimitives.ReverseEndianness((uint)challengeMessage.Flags);

System\Net\Sockets\SocketPal.Unix.cs (1)

1411BitConverter.TryWriteBytes(optionOutValue, result);

System\Net\WebSockets\ManagedWebSocket.cs (2)

1647BitConverter.ToInt32(buffer.Slice(maskOffset)); 1678int rolledMask = BitConverter.IsLittleEndian ?

src\libraries\Common\src\System\HexConverter.cs (1)

247if (BitConverter.IsLittleEndian && (Ssse3.IsSupported || AdvSimd.Arm64.IsSupported || PackedSimd.IsSupported) &&

src\libraries\System.Private.CoreLib\src\System\Buffers\Binary\BinaryPrimitives.ReadBigEndian.cs (32)

src\libraries\System.Private.CoreLib\src\System\Buffers\Binary\BinaryPrimitives.ReadLittleEndian.cs (32)

src\libraries\System.Private.CoreLib\src\System\Buffers\Binary\BinaryPrimitives.WriteBigEndian.cs (32)

src\libraries\System.Private.CoreLib\src\System\Buffers\Binary\BinaryPrimitives.WriteLittleEndian.cs (32)

src\libraries\System.Private.CoreLib\src\System\Buffers\Text\Base64Helper\Base64DecoderHelper.cs (3)

88if ((Ssse3.IsSupported || AdvSimd.Arm64.IsSupported) && BitConverter.IsLittleEndian && (end >= src)) 828Debug.Assert((Ssse3.IsSupported || AdvSimd.Arm64.IsSupported) && BitConverter.IsLittleEndian); 991Debug.Assert((Ssse3.IsSupported || AdvSimd.Arm64.IsSupported) && BitConverter.IsLittleEndian);

src\libraries\System.Private.CoreLib\src\System\Buffers\Text\Base64Helper\Base64EncoderHelper.cs (2)

73if ((Ssse3.IsSupported || AdvSimd.Arm64.IsSupported) && BitConverter.IsLittleEndian && (end >= src)) 659if (BitConverter.IsLittleEndian)

src\libraries\System.Private.CoreLib\src\System\Buffers\Text\Base64Url\Base64UrlEncoder.cs (3)

257if (BitConverter.IsLittleEndian) 351if (BitConverter.IsLittleEndian) 440if (BitConverter.IsLittleEndian)

src\libraries\System.Private.CoreLib\src\System\Char.cs (2)

1211if (BitConverter.IsLittleEndian) 1259if (!BitConverter.IsLittleEndian)

src\libraries\System.Private.CoreLib\src\System\Decimal.cs (2)

1180if (BitConverter.IsLittleEndian) 1209if (!BitConverter.IsLittleEndian)

src\libraries\System.Private.CoreLib\src\System\Decimal.DecCalc.cs (2)

168return (byte)(BitConverter.SingleToUInt32Bits(f) >> 23); 179return (uint)(BitConverter.DoubleToUInt64Bits(d) >> 52) & 0x7FFu;

src\libraries\System.Private.CoreLib\src\System\Diagnostics\Tracing\EventPipeEventProvider.cs (1)

31id = BitConverter.ToUInt64(new ReadOnlySpan<byte>(additionalData, sizeof(ulong)));

src\libraries\System.Private.CoreLib\src\System\Diagnostics\Tracing\EventPipePayloadDecoder.cs (1)

129decodedFields[i] = BitConverter.IsLittleEndian ? new string(charPayload) : Encoding.Unicode.GetString(MemoryMarshal.Cast<char, byte>(charPayload));

src\libraries\System.Private.CoreLib\src\System\Double.cs (42)

src\libraries\System.Private.CoreLib\src\System\Enum.cs (3)

784result = BitConverter.SingleToInt32Bits(localResult); 791result = BitConverter.DoubleToInt64Bits(localResult); 2258if (!BitConverter.IsLittleEndian)

src\libraries\System.Private.CoreLib\src\System\Globalization\CharUnicodeInfo.cs (8)

240if (BitConverter.IsLittleEndian) 248return BitConverter.UInt64BitsToDouble(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); 464if (BitConverter.IsLittleEndian) 501if (BitConverter.IsLittleEndian)

src\libraries\System.Private.CoreLib\src\System\Guid.cs (13)

src\libraries\System.Private.CoreLib\src\System\Half.cs (22)

575ulong doubleInt = BitConverter.DoubleToUInt64Bits(value); 745uint bitValue = BitConverter.SingleToUInt32Bits(value); 755uint exponentOffset0 = BitConverter.SingleToUInt32Bits(float.Max(value, BitConverter.UInt32BitsToSingle(MinExp))); 761value += BitConverter.UInt32BitsToSingle(exponentOffset0); 762bitValue = BitConverter.SingleToUInt32Bits(value); 780return BitConverter.UInt16BitsToHalf((ushort)bitValue); 1012return BitConverter.UInt64BitsToDouble(sign ? double.SignMask : 0); // Positive / Negative zero 1070short valueInInt16Bits = BitConverter.HalfToInt16Bits(value); 1092uint absoluteValue = BitConverter.SingleToUInt32Bits(BitConverter.UInt32BitsToSingle(bitValueInProcess) - BitConverter.UInt32BitsToSingle(maskedExponentLowerBound)); 1094return BitConverter.UInt32BitsToSingle(absoluteValue | sign); 1120return BitConverter.UInt16BitsToHalf((ushort)(signInt | NaNBits | sigInt)); 1167return BitConverter.UInt32BitsToSingle(signInt | NaNBits | sigInt); 1177return BitConverter.UInt64BitsToDouble(signInt | NaNBits | sigInt); 1180private static float CreateSingle(bool sign, byte exp, uint sig) => BitConverter.UInt32BitsToSingle(((sign ? 1U : 0U) << float.SignShift) + ((uint)exp << float.BiasedExponentShift) + sig); 1182private static double CreateDouble(bool sign, ushort exp, ulong sig) => BitConverter.UInt64BitsToDouble(((sign ? 1UL : 0UL) << double.SignShift) + ((ulong)exp << double.BiasedExponentShift) + sig); 1205static Half IBinaryNumber<Half>.AllBitsSet => BitConverter.UInt16BitsToHalf(0xFFFF); 1210ushort bits = BitConverter.HalfToUInt16Bits(value); 2359static Half IBinaryFloatParseAndFormatInfo<Half>.BitsToFloat(ulong bits) => BitConverter.UInt16BitsToHalf((ushort)(bits)); 2361static ulong IBinaryFloatParseAndFormatInfo<Half>.FloatToBits(Half value) => BitConverter.HalfToUInt16Bits(value);

src\libraries\System.Private.CoreLib\src\System\Int16.cs (6)

353if (BitConverter.IsLittleEndian) 426if (!BitConverter.IsLittleEndian) 971result = (actualValue >= BitConverter.UInt16BitsToHalf(0x7800)) ? MaxValue : 972(actualValue <= BitConverter.UInt16BitsToHalf(0xF800)) ? MinValue : (short)actualValue; 1050result = (actualValue >= BitConverter.UInt16BitsToHalf(0x7800)) ? MaxValue : 1051(actualValue <= BitConverter.UInt16BitsToHalf(0xF800)) ? MinValue : (short)actualValue;

src\libraries\System.Private.CoreLib\src\System\Int32.cs (2)

373if (BitConverter.IsLittleEndian) 453if (!BitConverter.IsLittleEndian)

src\libraries\System.Private.CoreLib\src\System\Int64.cs (2)

370if (BitConverter.IsLittleEndian) 450if (!BitConverter.IsLittleEndian)

src\libraries\System.Private.CoreLib\src\System\IntPtr.cs (2)

375if (BitConverter.IsLittleEndian) 455if (!BitConverter.IsLittleEndian)

src\libraries\System.Private.CoreLib\src\System\IO\UnmanagedMemoryAccessor.cs (4)

258public float ReadSingle(long position) => BitConverter.Int32BitsToSingle(ReadInt32(position)); 260public double ReadDouble(long position) => BitConverter.Int64BitsToDouble(ReadInt64(position)); 490public void Write(long position, float value) => Write(position, BitConverter.SingleToInt32Bits(value)); 492public void Write(long position, double value) => Write(position, BitConverter.DoubleToInt64Bits(value));

src\libraries\System.Private.CoreLib\src\System\Marvin.cs (4)

132if (BitConverter.IsLittleEndian) 163if (BitConverter.IsLittleEndian) 184if (BitConverter.IsLittleEndian) 205if (BitConverter.IsLittleEndian)

src\libraries\System.Private.CoreLib\src\System\Marvin.OrdinalIgnoreCase.cs (2)

51if (BitConverter.IsLittleEndian) 62if (BitConverter.IsLittleEndian)

src\libraries\System.Private.CoreLib\src\System\Math.cs (12)

132ulong raw = BitConverter.DoubleToUInt64Bits(value); 134return BitConverter.UInt64BitsToDouble(raw & mask); 142uint raw = BitConverter.SingleToUInt32Bits(value); 144return BitConverter.UInt32BitsToSingle(raw & mask); 299ulong bits = BitConverter.DoubleToUInt64Bits(x); 326return BitConverter.UInt64BitsToDouble(bits); 331ulong bits = BitConverter.DoubleToUInt64Bits(x); 358return BitConverter.UInt64BitsToDouble(bits); 377ulong xbits = BitConverter.DoubleToUInt64Bits(x); 378ulong ybits = BitConverter.DoubleToUInt64Bits(y); 382return BitConverter.UInt64BitsToDouble((xbits & ~double.SignMask) | (ybits & double.SignMask)); 1550double u = BitConverter.Int64BitsToDouble(((long)(0x3ff + n) << 52));

src\libraries\System.Private.CoreLib\src\System\MathF.cs (8)

54uint bits = BitConverter.SingleToUInt32Bits(x); 81return BitConverter.UInt32BitsToSingle(bits); 86uint bits = BitConverter.SingleToUInt32Bits(x); 113return BitConverter.UInt32BitsToSingle(bits); 132uint xbits = BitConverter.SingleToUInt32Bits(x); 133uint ybits = BitConverter.SingleToUInt32Bits(y); 137return BitConverter.UInt32BitsToSingle((xbits & ~float.SignMask) | (ybits & float.SignMask)); 497float u = BitConverter.Int32BitsToSingle(((int)(0x7f + n) << 23));

src\libraries\System.Private.CoreLib\src\System\Number.NumberToFloatingPointBits.cs (1)

958if (!BitConverter.IsLittleEndian)

src\libraries\System.Private.CoreLib\src\System\Numerics\TotalOrderIeee754Comparer.cs (6)

55return CompareIntegerSemantic(BitConverter.SingleToInt32Bits((float)(object)x!), BitConverter.SingleToInt32Bits((float)(object)y!)); 59return CompareIntegerSemantic(BitConverter.DoubleToInt64Bits((double)(object)x!), BitConverter.DoubleToInt64Bits((double)(object)y!)); 63return CompareIntegerSemantic(BitConverter.HalfToInt16Bits((Half)(object)x!), BitConverter.HalfToInt16Bits((Half)(object)y!));

src\libraries\System.Private.CoreLib\src\System\Resources\ResourceReader.cs (1)

402if (BitConverter.IsLittleEndian)

src\libraries\System.Private.CoreLib\src\System\Runtime\InteropServices\NFloat.cs (16)

881get => (NFloat)BitConverter.UInt64BitsToDouble(0xFFFF_FFFF_FFFF_FFFF); 906ulong bits = BitConverter.DoubleToUInt64Bits(left._value) & BitConverter.DoubleToUInt64Bits(right._value); 907NativeType result = BitConverter.UInt64BitsToDouble(bits); 920ulong bits = BitConverter.DoubleToUInt64Bits(left._value) | BitConverter.DoubleToUInt64Bits(right._value); 921NativeType result = BitConverter.UInt64BitsToDouble(bits); 934ulong bits = BitConverter.DoubleToUInt64Bits(left._value) ^ BitConverter.DoubleToUInt64Bits(right._value); 935NativeType result = BitConverter.UInt64BitsToDouble(bits); 948ulong bits = ~BitConverter.DoubleToUInt64Bits(value._value); 949NativeType result = BitConverter.UInt64BitsToDouble(bits); 1047if (BitConverter.IsLittleEndian) 1071if (!BitConverter.IsLittleEndian) 1095if (BitConverter.IsLittleEndian) 1119if (!BitConverter.IsLittleEndian)

src\libraries\System.Private.CoreLib\src\System\Runtime\Intrinsics\Scalar.cs (16)

27return (T)(object)BitConverter.Int64BitsToDouble(-1); 55return (T)(object)BitConverter.Int32BitsToSingle(-1); 503ulong bits = BitConverter.DoubleToUInt64Bits((double)(object)value); 548uint bits = BitConverter.SingleToUInt32Bits((float)(object)value); 1289long bits = BitConverter.DoubleToInt64Bits((double)(object)value); 1290double result = BitConverter.Int64BitsToDouble(bits << shiftCount); 1319int bits = BitConverter.SingleToInt32Bits((float)(object)value); 1320float result = BitConverter.Int32BitsToSingle(bits << shiftCount); 1351long bits = BitConverter.DoubleToInt64Bits((double)(object)value); 1352double result = BitConverter.Int64BitsToDouble(bits >> shiftCount); 1381int bits = BitConverter.SingleToInt32Bits((float)(object)value); 1382float result = BitConverter.Int32BitsToSingle(bits >> shiftCount); 1413long bits = BitConverter.DoubleToInt64Bits((double)(object)value); 1414double result = BitConverter.Int64BitsToDouble(bits >>> shiftCount); 1443int bits = BitConverter.SingleToInt32Bits((float)(object)value); 1444float result = BitConverter.Int32BitsToSingle(bits >>> shiftCount);

src\libraries\System.Private.CoreLib\src\System\Single.cs (29)

src\libraries\System.Private.CoreLib\src\System\String.Comparison.cs (4)

887if (!BitConverter.IsLittleEndian) 901if (!BitConverter.IsLittleEndian) 1005if (!BitConverter.IsLittleEndian) 1031if (!BitConverter.IsLittleEndian)

src\libraries\System.Private.CoreLib\src\System\Text\Ascii.Utility.cs (21)

src\libraries\System.Private.CoreLib\src\System\Text\Ascii.Utility.Helpers.cs (1)

51if (BitConverter.IsLittleEndian)

src\libraries\System.Private.CoreLib\src\System\Text\Latin1Utility.cs (7)

185Debug.Assert(BitConverter.IsLittleEndian, "SSE2 assumes little-endian."); 550Debug.Assert(BitConverter.IsLittleEndian, "Assume little endian if SSE2 is supported."); 706if (BitConverter.IsLittleEndian) 719if (BitConverter.IsLittleEndian) 752if (!BitConverter.IsLittleEndian) 780Debug.Assert(BitConverter.IsLittleEndian); 972Debug.Assert(BitConverter.IsLittleEndian);

src\libraries\System.Private.CoreLib\src\System\Text\Latin1Utility.Helpers.cs (4)

39return (BitConverter.IsLittleEndian && (value & 0xFF00u) == 0) 40|| (!BitConverter.IsLittleEndian && (value & 0xFF000000u) == 0); 64if (BitConverter.IsLittleEndian) 97if (BitConverter.IsLittleEndian)

src\libraries\System.Private.CoreLib\src\System\Text\Unicode\Utf16Utility.Validation.cs (1)

418if (((thisChar - (BitConverter.IsLittleEndian ? 0xDC00_D800u : 0xD800_DC00u)) & 0xFC00_FC00u) != 0)

src\libraries\System.Private.CoreLib\src\System\Text\Unicode\Utf8Utility.Helpers.cs (54)

src\libraries\System.Private.CoreLib\src\System\Text\Unicode\Utf8Utility.Transcoding.cs (15)

src\libraries\System.Private.CoreLib\src\System\Text\Unicode\Utf8Utility.Validation.cs (17)

src\libraries\System.Private.CoreLib\src\System\Text\UnicodeEncoding.cs (8)

400if ((bigEndian ^ BitConverter.IsLittleEndian) && 444(BitConverter.IsLittleEndian ? (ulong)0xdc00d800dc00d800 : (ulong)0xd800dc00d800dc00)) 683if ((bigEndian ^ BitConverter.IsLittleEndian) && 731(BitConverter.IsLittleEndian ? (ulong)0xdc00d800dc00d800 : (ulong)0xd800dc00d800dc00)) 1031if ((bigEndian ^ BitConverter.IsLittleEndian) && 1075(BitConverter.IsLittleEndian ? (ulong)0xdc00d800dc00d800 : (ulong)0xd800dc00d800dc00)) 1339if ((bigEndian ^ BitConverter.IsLittleEndian) && 1387(BitConverter.IsLittleEndian ? (ulong)0xdc00d800dc00d800 : (ulong)0xd800dc00d800dc00))

src\libraries\System.Private.CoreLib\src\System\Threading\Volatile.cs (2)

50return BitConverter.Int64BitsToDouble(result); 56Write(ref Unsafe.As<double, long>(ref location), BitConverter.DoubleToInt64Bits(value));

src\libraries\System.Private.CoreLib\src\System\UInt16.cs (2)

327if (BitConverter.IsLittleEndian) 375if (!BitConverter.IsLittleEndian)

src\libraries\System.Private.CoreLib\src\System\UInt32.cs (2)

348if (BitConverter.IsLittleEndian) 403if (!BitConverter.IsLittleEndian)

src\libraries\System.Private.CoreLib\src\System\UInt64.cs (2)

347if (BitConverter.IsLittleEndian) 402if (!BitConverter.IsLittleEndian)

src\libraries\System.Private.CoreLib\src\System\UIntPtr.cs (2)

351if (BitConverter.IsLittleEndian) 406if (!BitConverter.IsLittleEndian)

src\System\Reflection\Emit\RuntimeILGenerator.cs (2)

740BinaryPrimitives.WriteInt32LittleEndian(m_ILStream.AsSpan(m_length), BitConverter.SingleToInt32Bits(arg)); 748BinaryPrimitives.WriteInt64LittleEndian(m_ILStream.AsSpan(m_length), BitConverter.DoubleToInt64Bits(arg));

src\System\Reflection\RuntimeCustomAttributeData.cs (4)

538CustomAttributeEncoding.Float => BitConverter.Int32BitsToSingle(val.Byte4), 539CustomAttributeEncoding.Double => BitConverter.Int64BitsToDouble(val.Byte8), 842arg.PrimitiveValue = new PrimitiveValue() { Byte4 = BitConverter.SingleToInt32Bits(parser.GetR4()) }; 845arg.PrimitiveValue = new PrimitiveValue() { Byte8 = BitConverter.DoubleToInt64Bits(parser.GetR8()) };

src\System\Runtime\CompilerServices\RuntimeHelpers.CoreCLR.cs (2)

55if (BitConverter.IsLittleEndian) 114if (!BitConverter.IsLittleEndian)

System\Xml\XmlBinaryReader.cs (13)

System\Xml\XmlBinaryWriter.cs (14)

System\Xml\XmlBufferReader.cs (8)

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>()); 391if (BitConverter.IsLittleEndian) 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)); 971if (BitConverter.IsLittleEndian)

System\Xml\XmlConverter.cs (2)

713return BitConverter.SingleToUInt32Bits(value) == 0x8000_0000U; 719return BitConverter.DoubleToUInt64Bits(value) == 0x8000_0000_0000_0000UL;

System\Xml\XmlStreamNodeWriter.cs (1)

338if (BitConverter.IsLittleEndian)

System\PercentEncodingHelper.cs (7)

64if (BitConverter.IsLittleEndian) 82Debug.Assert((fourByteBuffer & (BitConverter.IsLittleEndian ? 0x00000080 : 0x80000000)) != 0); 83Debug.Assert((fourByteBuffer & (BitConverter.IsLittleEndian ? 0x00008000 : 0x00800000)) != 0); 84Debug.Assert(bytesLeftInBuffer < 3 || (fourByteBuffer & (BitConverter.IsLittleEndian ? 0x00800000 : 0x00008000)) != 0); 85Debug.Assert(bytesLeftInBuffer < 4 || (fourByteBuffer & (BitConverter.IsLittleEndian ? 0x80000000 : 0x00000080)) != 0); 141if (BitConverter.IsLittleEndian) 152if (BitConverter.IsLittleEndian)

System\IO\BinaryReaderExtensions.cs (2)

129if (sizeof(T) != 1 && !BitConverter.IsLittleEndian) 258if (sizeof(T) == 1 || BitConverter.IsLittleEndian)

Windows\Win32\Graphics\Gdi\ARGB.cs (2)

27Debug.Assert(BitConverter.IsLittleEndian); 37Debug.Assert(BitConverter.IsLittleEndian);

System\Xml\XmlConvert.cs (2)

1382if (value == 0 && BitConverter.DoubleToInt64Bits(value) == BitConverter.DoubleToInt64Bits(-0e0))

System\Xml\XmlEncoding.cs (2)

62if (_bigEndian == BitConverter.IsLittleEndian) 126if (_bigEndian == BitConverter.IsLittleEndian)

System\Xml\Xsl\XPathConvert.cs (14)

24return (uint)(BitConverter.DoubleToUInt64Bits(dbl) >> 32); 29return unchecked((uint)BitConverter.DoubleToUInt64Bits(dbl)); 58bits = BitConverter.DoubleToInt64Bits(y) & 1L << 63; 59return BitConverter.Int64BitsToDouble(bits | 1); 67bits = BitConverter.DoubleToInt64Bits(x); 76return BitConverter.Int64BitsToDouble(bits); 663return BitConverter.UInt64BitsToDouble((ulong)dblHi << 32 | dblLo); 1106dblT = BitConverter.Int64BitsToDouble(0x4FF00000L << 32); 1116dblT = BitConverter.UInt64BitsToDouble((ulong)dblHi << 32 | DblLo(dblT)); 1127dblT = BitConverter.UInt64BitsToDouble((ulong)dblHi << 32 | dblLo); 2789dbl = BitConverter.Int64BitsToDouble(BitConverter.DoubleToInt64Bits(dbl) - 1); 2814dbl = BitConverter.Int64BitsToDouble(BitConverter.DoubleToInt64Bits(dbl) + 1);

System\Reflection\Internal\Utilities\BlobUtilities.cs (7)

24WriteUInt64(buffer, start, BitConverter.DoubleToUInt64Bits(value)); 33WriteUInt32(buffer, start, BitConverter.SingleToUInt32Bits(value)); 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 (5)

68string result = BitConverter.ToString(PeekBytes(0, displayedBytes)); 131return BitConverter.IsLittleEndian ? result : BinaryPrimitives.ReverseEndianness(result); 189return BitConverter.IsLittleEndian ? result : BinaryPrimitives.ReverseEndianness(result); 246if (BitConverter.IsLittleEndian) 268if (BitConverter.IsLittleEndian)

System\Reflection\Metadata\BlobBuilder.cs (4)

1001if (BitConverter.IsLittleEndian) 1178BitConverter.ToString(bytes, 0, length) : 1179BitConverter.ToString(bytes, 0, MaxDisplaySize / 2) + "-...-" + BitConverter.ToString(bytes, length - MaxDisplaySize / 2, MaxDisplaySize / 2);

System\Reflection\Metadata\BlobReader.cs (1)

316if (BitConverter.IsLittleEndian)

System\Reflection\Metadata\BlobWriter.cs (1)

398if (BitConverter.IsLittleEndian)

System\Reflection\Metadata\Ecma335\Encoding\ControlFlowBuilder.cs (1)

323BitConverter.ToUInt32(srcBlob.Buffer, srcBlobOffset) == 0xffffffff));

System\Reflection\Metadata\Ecma335\MetadataBuilder.Heaps.cs (1)

279if (BitConverter.IsLittleEndian)

src\libraries\System.Private.CoreLib\src\System\Resources\ResourceReader.cs (1)

402if (BitConverter.IsLittleEndian)

artifacts\obj\System.Runtime\Debug\net10.0\System.Runtime.Forwards.cs (1)

51[assembly: System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.BitConverter))]

System.Runtime.Extensions.cs (1)

11[assembly:System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.BitConverter))]

System\Number.BigInteger.cs (1)

1274if (BitConverter.IsLittleEndian)

System\Numerics\BigInteger.cs (9)

System\Numerics\NumericsHelpers.cs (2)

16ulong bits = BitConverter.DoubleToUInt64Bits(dbl); 95return BitConverter.UInt64BitsToDouble(bits);

System\Text\BaseCodePageEncoding.cs (3)

109if (!BitConverter.IsLittleEndian) 147if (!BitConverter.IsLittleEndian) 193if (!BitConverter.IsLittleEndian)

System\Text\BaseCodePageEncoding.netcoreapp.cs (1)

20if (!BitConverter.IsLittleEndian)

System\Text\DBCSCodePageEncoding.cs (1)

47if (BitConverter.IsLittleEndian)

System\Text\SBCSCodePageEncoding.cs (1)

38if (BitConverter.IsLittleEndian)

System\Text\Encodings\Web\AllowedBmpCodePointsBitmap.cs (1)

73if (Vector.IsHardwareAccelerated && BitConverter.IsLittleEndian)

System\Text\Json\Serialization\Metadata\PropertyRef.cs (1)

72if (BitConverter.IsLittleEndian)

System\ComponentModel\Design\BinaryEditor.cs (1)

87value = BitConverter.ToString(bytes);

src\RoslynAnalyzers\Utilities\Compiler\RoslynHashCode.cs (1)

84return BitConverter.ToUInt32(array, 0);

src\RoslynAnalyzers\Utilities\Compiler\RoslynHashCode.cs (1)

84return BitConverter.ToUInt32(array, 0);

src\Compilers\Core\CommandLine\BuildProtocol.cs (4)

127var length = BitConverter.ToInt32(lengthBuffer, 0); 184await outStream.WriteAsync(BitConverter.GetBytes(length), 0, 4, 300await outStream.WriteAsync(BitConverter.GetBytes(length), 323var length = BitConverter.ToUInt32(lengthBuffer, 0);

src\Compilers\Core\CommandLine\BuildProtocol.cs (4)

127var length = BitConverter.ToInt32(lengthBuffer, 0); 184await outStream.WriteAsync(BitConverter.GetBytes(length), 0, 4, 300await outStream.WriteAsync(BitConverter.GetBytes(length), 323var length = BitConverter.ToUInt32(lengthBuffer, 0);