BitConverter

Telemetry\MachineInformationProviderBase.cs (1)

83return BitConverter.ToString(hashInput).Replace("-", string.Empty).ToLowerInvariant();

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

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

CompilerNuGetCheckerUtil.cs (1)

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

CompilationDiff.cs (1)

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

src\Compilers\Shared\BuildProtocol.cs (4)

129var length = BitConverter.ToInt32(lengthBuffer, 0); 186await outStream.WriteAsync(BitConverter.GetBytes(length), 0, 4, 302await outStream.WriteAsync(BitConverter.GetBytes(length), 325var 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\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\RoslynAnalyzers\Utilities\Compiler\RoslynHashCode.cs (1)

84return BitConverter.ToUInt32(array, 0);

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

45Debug.Assert(BitConverter.IsLittleEndian);

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

92Debug.Assert(BitConverter.IsLittleEndian);

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\RoslynAnalyzers\Utilities\Compiler\RoslynHashCode.cs (1)

84return BitConverter.ToUInt32(array, 0);

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

45Debug.Assert(BitConverter.IsLittleEndian);

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

92Debug.Assert(BitConverter.IsLittleEndian);

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\RoslynAnalyzers\Utilities\Compiler\RoslynHashCode.cs (1)

84return BitConverter.ToUInt32(array, 0);

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

45Debug.Assert(BitConverter.IsLittleEndian);

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

92Debug.Assert(BitConverter.IsLittleEndian);

Internal\BinaryBlob.cs (1)

76return 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)

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

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)

469byte[] bytes = BitConverter.GetBytes(value); 473if (BitConverter.IsLittleEndian) 634if (BitConverter.IsLittleEndian) 639result = HandshakeResult.Success(BitConverter.ToInt32(bytes, 0 /* start index */));

MSBuildNameIgnoreCaseComparer.cs (2)

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

src\Compilers\Shared\BuildProtocol.cs (4)

129var length = BitConverter.ToInt32(lengthBuffer, 0); 186await outStream.WriteAsync(BitConverter.GetBytes(length), 0, 4, 302await outStream.WriteAsync(BitConverter.GetBytes(length), 325var length = BitConverter.ToUInt32(lengthBuffer, 0);

src\Compilers\Shared\BuildProtocol.cs (4)

129var length = BitConverter.ToInt32(lengthBuffer, 0); 186await outStream.WriteAsync(BitConverter.GetBytes(length), 0, 4, 302await outStream.WriteAsync(BitConverter.GetBytes(length), 325var length = BitConverter.ToUInt32(lengthBuffer, 0);

CommunicationsUtilities.cs (4)

469byte[] bytes = BitConverter.GetBytes(value); 473if (BitConverter.IsLittleEndian) 634if (BitConverter.IsLittleEndian) 639result = HandshakeResult.Success(BitConverter.ToInt32(bytes, 0 /* start index */));

CodeGen\ILBuilderEmit.cs (3)

828int int32 = BitConverter.ToInt32(BitConverter.GetBytes(floatValue), 0); 834long 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)

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

StrongName\StrongNameKeys.cs (1)

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

Text\SourceText.cs (1)

649if (!BitConverter.IsLittleEndian)

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\RoslynAnalyzers\Utilities\Compiler\RoslynHashCode.cs (1)

84return BitConverter.ToUInt32(array, 0);

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

45Debug.Assert(BitConverter.IsLittleEndian);

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

92Debug.Assert(BitConverter.IsLittleEndian);

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\RoslynAnalyzers\Utilities\Compiler\RoslynHashCode.cs (1)

84return BitConverter.ToUInt32(array, 0);

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

45Debug.Assert(BitConverter.IsLittleEndian);

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

92Debug.Assert(BitConverter.IsLittleEndian);

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\RoslynAnalyzers\Utilities\Compiler\RoslynHashCode.cs (1)

84return BitConverter.ToUInt32(array, 0);

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

45Debug.Assert(BitConverter.IsLittleEndian);

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

92Debug.Assert(BitConverter.IsLittleEndian);

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)

92Debug.Assert(BitConverter.IsLittleEndian);

Symbols\Source\SourceNamedTypeSymbol_Extension.cs (4)

972int i2 = BitConverter.ToInt32(BitConverter.GetBytes(f), startIndex: 0); 978long l2 = BitConverter.DoubleToInt64Bits(d); 1152if (!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 (6)

13510Assert.Equal("20-01-01-08", BitConverter.ToString(value0)); 13520Assert.Equal("07-02-0E-0C", BitConverter.ToString(value1)); 13525Assert.Equal("07-03-0E-0C-02", BitConverter.ToString(value2)); 21040AFB1C33C5229BFF7EF739BA44DA795A2B68A49E06001C07C5B026CAA6C6322BB: {BitConverter.ToString(Encoding.UTF8.GetBytes("0123456789X"))}-00-00-00-00-00-00-00 21139ACE59E7D984CCEB2D860A056A3386344236CE5C42C978E26ECE3F35956DAC3AD: {BitConverter.ToString(Encoding.UTF8.GetBytes("0123456789X"))}-00 2129884D89877F0D4041EFB6BF91A16F0248F2FD573E6AF05C19F96BEDB9F882F7882: {BitConverter.ToString(Encoding.UTF8.GetBytes("0123456789"))}-00-00

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)

50size = 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)

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

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

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

EditAndContinue\EditAndContinueMethodDebugInfoReaderTests.cs (1)

114Assert.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\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\RoslynAnalyzers\Utilities\Compiler\RoslynHashCode.cs (1)

84return BitConverter.ToUInt32(array, 0);

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

45Debug.Assert(BitConverter.IsLittleEndian);

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

92Debug.Assert(BitConverter.IsLittleEndian);

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\RoslynAnalyzers\Utilities\Compiler\RoslynHashCode.cs (1)

84return BitConverter.ToUInt32(array, 0);

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

45Debug.Assert(BitConverter.IsLittleEndian);

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

92Debug.Assert(BitConverter.IsLittleEndian);

CompilationOptionsReader.cs (1)

214int uncompressedSize = BitConverter.ToInt32(bytes, 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\RoslynAnalyzers\Utilities\Compiler\RoslynHashCode.cs (1)

84return BitConverter.ToUInt32(array, 0);

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

45Debug.Assert(BitConverter.IsLittleEndian);

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

92Debug.Assert(BitConverter.IsLittleEndian);

Metadata\ILValidation.cs (1)

356result.AppendLine($"{name}: {BitConverter.ToString(il[startRva..endRva].ToArray())}");

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)

169longLiterals.Add(BitConverter.DoubleToInt64Bits(d)); 172longLiterals.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)

92Debug.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 (2)

52=> BitConverter.ToString(hash.ToArray()).Replace("-", ""); 133uint magic = BitConverter.ToUInt32(buffer, 0);

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));

ImageGeneratingChatClientIntegrationTests.cs (1)

420BitConverter.GetBytes(++ImageCounter).CopyTo(imageData, _testImageData.Length);

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));

src\Shared\HashCode.cs (1)

75return BitConverter.ToUInt32(array, 0);

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)

SentencepieceModel.cs (3)

93if (BitConverter.IsLittleEndian) 95value = BitConverter.ToSingle(data, pos); 105value = BitConverter.ToSingle(buffer, 0);

SentencePieceTests.cs (6)

889byte[] bytes = BitConverter.GetBytes(value); 890if (!BitConverter.IsLittleEndian) 907byte[] bytes = BitConverter.GetBytes(value); 908if (!BitConverter.IsLittleEndian) 918byte[] bytes = BitConverter.GetBytes(value); 919if (!BitConverter.IsLittleEndian)

ImageClassificationTrainer.cs (4)

875featuresWriter.Write(BitConverter.GetBytes(examples), 0, sizeof(int)); 876featuresWriter.Write(BitConverter.GetBytes(featureLength), 0, sizeof(int)); 967int trainingExamples = BitConverter.ToInt32(buffer, 0); 969int 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)

469byte[] bytes = BitConverter.GetBytes(value); 473if (BitConverter.IsLittleEndian) 634if (BitConverter.IsLittleEndian) 639result = HandshakeResult.Success(BitConverter.ToInt32(bytes, 0 /* start index */));

CommunicationsUtilities.cs (4)

472byte[] bytes = BitConverter.GetBytes(value); 476if (BitConverter.IsLittleEndian) 579if (BitConverter.IsLittleEndian) 584result = HandshakeResult.Success(BitConverter.ToInt32(bytes, startIndex: 0));

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\Shared\BuildProtocol.cs (4)

129var length = BitConverter.ToInt32(lengthBuffer, 0); 186await outStream.WriteAsync(BitConverter.GetBytes(length), 0, 4, 302await outStream.WriteAsync(BitConverter.GetBytes(length), 325var length = BitConverter.ToUInt32(lengthBuffer, 0);

CreateFrameworkListFile.cs (1)

101publicKeyTokenHex = BitConverter.ToString(publicKeyToken)

Uuid.cs (12)

28int timeLow = IPAddress.HostToNetworkOrder(BitConverter.ToInt32(namespaceBytes, 0)); 30short timeMid = IPAddress.HostToNetworkOrder(BitConverter.ToInt16(namespaceBytes, 4)); 32short timeHiVersion = IPAddress.HostToNetworkOrder(BitConverter.ToInt16(namespaceBytes, 6)); 38Buffer.BlockCopy(BitConverter.GetBytes(timeLow), 0, hashBuffer, 0, 4); 39Buffer.BlockCopy(BitConverter.GetBytes(timeMid), 0, hashBuffer, 4, 2); 40Buffer.BlockCopy(BitConverter.GetBytes(timeHiVersion), 0, hashBuffer, 6, 2); 53timeLow = IPAddress.NetworkToHostOrder(BitConverter.ToInt32(hash, 0)); 54Buffer.BlockCopy(BitConverter.GetBytes(timeLow), 0, hash, 0, 4); 57timeMid = IPAddress.NetworkToHostOrder(BitConverter.ToInt16(hash, 4)); 58Buffer.BlockCopy(BitConverter.GetBytes(timeMid), 0, hash, 4, 2); 61timeHiVersion = IPAddress.NetworkToHostOrder(BitConverter.ToInt16(hash, 6)); 65Buffer.BlockCopy(BitConverter.GetBytes(timeHiVersion), 0, hash, 6, 2);

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\RoslynAnalyzers\Utilities\Compiler\RoslynHashCode.cs (1)

84return BitConverter.ToUInt32(array, 0);

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

45Debug.Assert(BitConverter.IsLittleEndian);

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

92Debug.Assert(BitConverter.IsLittleEndian);

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)

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

GenerateFilteredReferenceAssembliesTask.cs (3)

486Debug.Assert(BitConverter.IsLittleEndian); 520Debug.Assert(BitConverter.IsLittleEndian); 554Debug.Assert(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)

1993if (BitConverter.IsLittleEndian) 2162if (BitConverter.IsLittleEndian)

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

129_scalingFactor = BitConverter.Int64BitsToDouble(0x71547652B82FEL | ((0x3FFL + value) << FractionWidth)); 239var bits = BitConverter.DoubleToInt64Bits(value);

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

181ulong bits = (ulong)BitConverter.DoubleToInt64Bits(measurement); 207return BitConverter.Int64BitsToDouble(bits);

System\Drawing\Icon.cs (2)

772int iconSignature1 = BitConverter.ToInt32(_iconData, (int)_bestImageOffset); 773int iconSignature2 = BitConverter.ToInt32(_iconData, (int)_bestImageOffset + 4);

System\Drawing\ImageInfo.cs (2)

68int delay = BitConverter.ToInt32(values, i) * 10; 94_loopCount = BitConverter.ToInt16(values);

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)

885readEvent.wd = BitConverter.ToInt32(_buffer, _bufferPos); 886readEvent.mask = BitConverter.ToUInt32(_buffer, _bufferPos + 4); // +4 to get past wd 887readEvent.cookie = BitConverter.ToUInt32(_buffer, _bufferPos + 8); // +8 to get past wd, mask 888int nameLength = (int)BitConverter.ToUInt32(_buffer, _bufferPos + 12); // +12 to get past wd, mask, cookie

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

195if (BitConverter.IsLittleEndian &&

System\IO\Hashing\Crc32ParameterSet.Vectorized.cs (3)

34if (!BitConverter.IsLittleEndian || !VectorHelper.IsSupported) 158if (!BitConverter.IsLittleEndian || !VectorHelper.IsSupported) 190if (BitConverter.IsLittleEndian)

System\IO\Hashing\Crc64ParameterSet.Vectorized.cs (3)

24if (!BitConverter.IsLittleEndian || !VectorHelper.IsSupported) 167if (!BitConverter.IsLittleEndian || !VectorHelper.IsSupported) 193if (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)

64$"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); 1070ulong first8Bytes = BitConverter.ToUInt64(line);

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

362if (isNetworkOrder || !BitConverter.IsLittleEndian)

System\Net\IPAddress.cs (5)

202if (Vector128.IsHardwareAccelerated && BitConverter.IsLittleEndian) 356if (BitConverter.IsLittleEndian) 538return BitConverter.IsLittleEndian ? BinaryPrimitives.ReverseEndianness(host) : host; 543return BitConverter.IsLittleEndian ? BinaryPrimitives.ReverseEndianness(host) : host; 548return BitConverter.IsLittleEndian ? BinaryPrimitives.ReverseEndianness(host) : host;

System\Net\IPNetwork.cs (4)

84if (BitConverter.IsLittleEndian) 102if (BitConverter.IsLittleEndian) 243if (BitConverter.IsLittleEndian) 267if (BitConverter.IsLittleEndian)

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

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

1411BitConverter.TryWriteBytes(optionOutValue, result);

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

1640BitConverter.ToInt32(buffer.Slice(maskOffset)); 1671int rolledMask = BitConverter.IsLittleEndian ?

System\Numerics\Tensors\netcore\TensorPrimitives.BitDecrement.cs (8)

57Vector128<uint> specialValue = Vector128.Create(BitConverter.SingleToUInt32Bits(-float.Epsilon)) & isPositiveZero; 79Vector128<ulong> specialValue = Vector128.Create(BitConverter.DoubleToUInt64Bits(-double.Epsilon)) & isPositiveZero; 108Vector256<uint> specialValue = Vector256.Create(BitConverter.SingleToUInt32Bits(-float.Epsilon)) & isPositiveZero; 130Vector256<ulong> specialValue = Vector256.Create(BitConverter.DoubleToUInt64Bits(-double.Epsilon)) & isPositiveZero; 159Vector512<uint> specialValue = Vector512.Create(BitConverter.SingleToUInt32Bits(-float.Epsilon)) & isPositiveZero; 181Vector512<ulong> specialValue = Vector512.Create(BitConverter.DoubleToUInt64Bits(-double.Epsilon)) & isPositiveZero; 205public static short Invoke(short x) => BitConverter.HalfToInt16Bits(Half.BitDecrement(BitConverter.Int16BitsToHalf(x)));

System\Numerics\Tensors\netcore\TensorPrimitives.BitIncrement.cs (2)

205public static short Invoke(short x) => BitConverter.HalfToInt16Bits(Half.BitIncrement(BitConverter.Int16BitsToHalf(x)));

System\Numerics\Tensors\netcore\TensorPrimitives.Half.cs (25)

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

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

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

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

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

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

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

89if ((Ssse3.IsSupported || AdvSimd.Arm64.IsSupported) && BitConverter.IsLittleEndian && (end >= src)) 969Debug.Assert((Ssse3.IsSupported || AdvSimd.Arm64.IsSupported) && BitConverter.IsLittleEndian); 1128Debug.Assert((Ssse3.IsSupported || AdvSimd.Arm64.IsSupported) && BitConverter.IsLittleEndian);

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

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

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

257if (BitConverter.IsLittleEndian)

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

1263if (BitConverter.IsLittleEndian) 1311if (!BitConverter.IsLittleEndian)

src\libraries\System.Private.CoreLib\src\System\Collections\BitArray.cs (6)

93if (BitConverter.IsLittleEndian) 163if (!BitConverter.IsLittleEndian || values.Length < Vector256<byte>.Count) 249if (BitConverter.IsLittleEndian) 686if (BitConverter.IsLittleEndian) 732if (!BitConverter.IsLittleEndian || _bitLength < BitsPerInt32) 954BitConverter.IsLittleEndian ? value : BinaryPrimitives.ReverseEndianness(value);

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

1181if (BitConverter.IsLittleEndian) 1210if (!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 (43)

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

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

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

267if (BitConverter.IsLittleEndian) 275return BitConverter.UInt64BitsToDouble(temp); 289int delta = (BitConverter.IsLittleEndian) ? rsDelta : BinaryPrimitives.ReverseEndianness(rsDelta); 308int delta = (BitConverter.IsLittleEndian) ? rsDelta : BinaryPrimitives.ReverseEndianness(rsDelta); 324int delta = (BitConverter.IsLittleEndian) ? rsDelta : BinaryPrimitives.ReverseEndianness(rsDelta); 343int delta = (BitConverter.IsLittleEndian) ? rsDelta : BinaryPrimitives.ReverseEndianness(rsDelta); 490if (BitConverter.IsLittleEndian) 527if (BitConverter.IsLittleEndian)

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

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

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); 1201static Half IBinaryNumber<Half>.AllBitsSet => BitConverter.UInt16BitsToHalf(0xFFFF); 1206ushort bits = BitConverter.HalfToUInt16Bits(value); 2367static Half IBinaryFloatParseAndFormatInfo<Half>.BitsToFloat(ulong bits) => BitConverter.UInt16BitsToHalf((ushort)(bits)); 2369static ulong IBinaryFloatParseAndFormatInfo<Half>.FloatToBits(Half value) => BitConverter.HalfToUInt16Bits(value);

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

550ulong bits = BitConverter.DoubleToUInt64Bits(value); 805if (BitConverter.IsLittleEndian) 885if (!BitConverter.IsLittleEndian)

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)

393if (BitConverter.IsLittleEndian) 473if (!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)

133if (BitConverter.IsLittleEndian) 164if (BitConverter.IsLittleEndian) 185if (BitConverter.IsLittleEndian) 206if (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); 289ulong bits = BitConverter.DoubleToUInt64Bits(x); 316return BitConverter.UInt64BitsToDouble(bits); 321ulong bits = BitConverter.DoubleToUInt64Bits(x); 348return BitConverter.UInt64BitsToDouble(bits); 367ulong xbits = BitConverter.DoubleToUInt64Bits(x); 368ulong ybits = BitConverter.DoubleToUInt64Bits(y); 372return BitConverter.UInt64BitsToDouble((xbits & ~double.SignMask) | (ybits & double.SignMask)); 1540double 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\BFloat16.cs (9)

472ulong bitValue = BitConverter.DoubleToUInt64Bits(value); 482ulong exponentOffset0 = BitConverter.DoubleToUInt64Bits(double.Max(value, BitConverter.UInt64BitsToDouble(MinExp))); 488value += BitConverter.UInt64BitsToDouble(exponentOffset0); 489bitValue = BitConverter.DoubleToUInt64Bits(value); 552uint roundedValueBits = BitConverter.SingleToUInt32Bits(roundedValue); 592uint bits = BitConverter.SingleToUInt32Bits(value); 613uint roundedValueBits = BitConverter.SingleToUInt32Bits(roundedValue); 840public static explicit operator float(BFloat16 value) => BitConverter.Int32BitsToSingle(value._value << 16);

src\libraries\System.Private.CoreLib\src\System\Numerics\Colors\Argb.cs (4)

23if (BitConverter.IsLittleEndian) 41if (!BitConverter.IsLittleEndian) 61return BitConverter.IsLittleEndian ? BinaryPrimitives.ReverseEndianness(bits) : bits; 76return BitConverter.IsLittleEndian ? bits : BinaryPrimitives.ReverseEndianness(bits);

src\libraries\System.Private.CoreLib\src\System\Numerics\Colors\Rgba.cs (4)

23if (BitConverter.IsLittleEndian) 41if (!BitConverter.IsLittleEndian) 61return BitConverter.IsLittleEndian ? BinaryPrimitives.ReverseEndianness(bits) : bits; 76return BitConverter.IsLittleEndian ? bits : BinaryPrimitives.ReverseEndianness(bits);

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); 694ulong bits = BitConverter.DoubleToUInt64Bits((double)(object)value); 739uint bits = BitConverter.SingleToUInt32Bits((float)(object)value); 1480long bits = BitConverter.DoubleToInt64Bits((double)(object)value); 1481double result = BitConverter.Int64BitsToDouble(bits << shiftCount); 1510int bits = BitConverter.SingleToInt32Bits((float)(object)value); 1511float result = BitConverter.Int32BitsToSingle(bits << shiftCount); 1542long bits = BitConverter.DoubleToInt64Bits((double)(object)value); 1543double result = BitConverter.Int64BitsToDouble(bits >> shiftCount); 1572int bits = BitConverter.SingleToInt32Bits((float)(object)value); 1573float result = BitConverter.Int32BitsToSingle(bits >> shiftCount); 1604long bits = BitConverter.DoubleToInt64Bits((double)(object)value); 1605double result = BitConverter.Int64BitsToDouble(bits >>> shiftCount); 1634int bits = BitConverter.SingleToInt32Bits((float)(object)value); 1635float result = BitConverter.Int32BitsToSingle(bits >>> shiftCount);

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

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

818if (!BitConverter.IsLittleEndian) 832if (!BitConverter.IsLittleEndian) 936if (!BitConverter.IsLittleEndian) 962if (!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)

288if (((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\UInt128.cs (7)

267double lower = BitConverter.UInt64BitsToDouble(TwoPow52Bits | ((value._lower << 12) >> 12)) - TwoPow52; 268double upper = BitConverter.UInt64BitsToDouble(TwoPow104Bits | (ulong)(value >> 52)) - TwoPow104; 278double lower = BitConverter.UInt64BitsToDouble(TwoPow76Bits | ((ulong)(value >> 12) >> 12) | (value._lower & 0xFFFFFF)) - TwoPow76; 279double upper = BitConverter.UInt64BitsToDouble(TwoPow128Bits | (value._upper >> 12)) - TwoPow128; 564ulong bits = BitConverter.DoubleToUInt64Bits(value); 856if (BitConverter.IsLittleEndian) 911if (!BitConverter.IsLittleEndian)

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)

369if (BitConverter.IsLittleEndian) 424if (!BitConverter.IsLittleEndian)

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

744BinaryPrimitives.WriteInt32LittleEndian(m_ILStream.AsSpan(m_length), BitConverter.SingleToInt32Bits(arg)); 752BinaryPrimitives.WriteInt64LittleEndian(m_ILStream.AsSpan(m_length), BitConverter.DoubleToInt64Bits(arg));

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

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()) }; 1541if (!BitConverter.IsLittleEndian)

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

56if (BitConverter.IsLittleEndian) 115if (!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)

62if (BitConverter.IsLittleEndian) 80Debug.Assert((fourByteBuffer & (BitConverter.IsLittleEndian ? 0x00000080 : 0x80000000)) != 0); 81Debug.Assert((fourByteBuffer & (BitConverter.IsLittleEndian ? 0x00008000 : 0x00800000)) != 0); 82Debug.Assert(bytesLeftInBuffer < 3 || (fourByteBuffer & (BitConverter.IsLittleEndian ? 0x00800000 : 0x00008000)) != 0); 83Debug.Assert(bytesLeftInBuffer < 4 || (fourByteBuffer & (BitConverter.IsLittleEndian ? 0x80000000 : 0x00000080)) != 0); 140if (BitConverter.IsLittleEndian) 151if (BitConverter.IsLittleEndian)

System\IO\BinaryReaderExtensions.cs (2)

127if (sizeof(T) != 1 && !BitConverter.IsLittleEndian) 256if (sizeof(T) == 1 || BitConverter.IsLittleEndian)

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

25Debug.Assert(BitConverter.IsLittleEndian); 35Debug.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)); 36WriteUInt32(buffer, start, BitConverter.SingleToUInt32Bits(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); 61Unsafe.WriteUnaligned(ref buffer[start], !BitConverter.IsLittleEndian ? BinaryPrimitives.ReverseEndianness(value) : value); 64Unsafe.WriteUnaligned(ref buffer[start], !BitConverter.IsLittleEndian ? BinaryPrimitives.ReverseEndianness(value) : value);

System\Reflection\Internal\Utilities\MemoryBlock.cs (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\net11.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)

1452if (BitConverter.IsLittleEndian)

System\Numerics\BigInteger.cs (10)

System\Numerics\NumericsHelpers.cs (2)

17ulong bits = BitConverter.DoubleToUInt64Bits(dbl); 96return 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)

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

133if (BitConverter.IsLittleEndian) 164if (BitConverter.IsLittleEndian) 185if (BitConverter.IsLittleEndian) 206if (BitConverter.IsLittleEndian)

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

72if (BitConverter.IsLittleEndian)

RegexGenerator.Emitter.cs (1)

5810BitConverter.ToString(bytes).Replace("-", "");

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

87value = BitConverter.ToString(bytes);

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\RoslynAnalyzers\Utilities\Compiler\RoslynHashCode.cs (1)

84return BitConverter.ToUInt32(array, 0);

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

45Debug.Assert(BitConverter.IsLittleEndian);

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

92Debug.Assert(BitConverter.IsLittleEndian);

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\RoslynAnalyzers\Utilities\Compiler\RoslynHashCode.cs (1)

84return BitConverter.ToUInt32(array, 0);

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

45Debug.Assert(BitConverter.IsLittleEndian);

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

92Debug.Assert(BitConverter.IsLittleEndian);

src\Compilers\Shared\BuildProtocol.cs (4)

129var length = BitConverter.ToInt32(lengthBuffer, 0); 186await outStream.WriteAsync(BitConverter.GetBytes(length), 0, 4, 302await outStream.WriteAsync(BitConverter.GetBytes(length), 325var length = BitConverter.ToUInt32(lengthBuffer, 0);

src\Compilers\Shared\BuildProtocol.cs (4)

129var length = BitConverter.ToInt32(lengthBuffer, 0); 186await outStream.WriteAsync(BitConverter.GetBytes(length), 0, 4, 302await outStream.WriteAsync(BitConverter.GetBytes(length), 325var length = BitConverter.ToUInt32(lengthBuffer, 0);