Skip to content

Commit 194ad16

Browse files
EgorBoEgorBo
authored
Code clean up around TryWriteBigEndian/TryWriteLittleEndian (#110897)
1 parent 75b550d commit 194ad16

18 files changed

+154
-458
lines changed

‎src/libraries/System.Private.CoreLib/src/System/Char.cs

+8-18
Original file line numberDiff line numberDiff line change
@@ -1281,37 +1281,27 @@ static bool IBinaryInteger<char>.TryReadLittleEndian(ReadOnlySpan<byte> source,
12811281
/// <inheritdoc cref="IBinaryInteger{TSelf}.TryWriteBigEndian(Span{byte}, out int)" />
12821282
bool IBinaryInteger<char>.TryWriteBigEndian(Span<byte> destination, out int bytesWritten)
12831283
{
1284-
if (destination.Length >= sizeof(char))
1284+
if (BinaryPrimitives.TryWriteUInt16BigEndian(destination, m_value))
12851285
{
1286-
ushort value = BitConverter.IsLittleEndian ? BinaryPrimitives.ReverseEndianness(m_value) : m_value;
1287-
Unsafe.WriteUnaligned(ref MemoryMarshal.GetReference(destination), value);
1288-
12891286
bytesWritten = sizeof(char);
12901287
return true;
12911288
}
1292-
else
1293-
{
1294-
bytesWritten = 0;
1295-
return false;
1296-
}
1289+
1290+
bytesWritten = 0;
1291+
return false;
12971292
}
12981293

12991294
/// <inheritdoc cref="IBinaryInteger{TSelf}.TryWriteLittleEndian(Span{byte}, out int)" />
13001295
bool IBinaryInteger<char>.TryWriteLittleEndian(Span<byte> destination, out int bytesWritten)
13011296
{
1302-
if (destination.Length >= sizeof(char))
1297+
if (BinaryPrimitives.TryWriteUInt16LittleEndian(destination, m_value))
13031298
{
1304-
ushort value = BitConverter.IsLittleEndian ? m_value : BinaryPrimitives.ReverseEndianness(m_value);
1305-
Unsafe.WriteUnaligned(ref MemoryMarshal.GetReference(destination), value);
1306-
13071299
bytesWritten = sizeof(char);
13081300
return true;
13091301
}
1310-
else
1311-
{
1312-
bytesWritten = 0;
1313-
return false;
1314-
}
1302+
1303+
bytesWritten = 0;
1304+
return false;
13151305
}
13161306

13171307
//

‎src/libraries/System.Private.CoreLib/src/System/Decimal.cs

+8-16
Original file line numberDiff line numberDiff line change
@@ -1146,35 +1146,27 @@ bool IFloatingPoint<decimal>.TryWriteExponentBigEndian(Span<byte> destination, o
11461146
{
11471147
if (destination.Length >= sizeof(sbyte))
11481148
{
1149-
sbyte exponent = Exponent;
1150-
Unsafe.WriteUnaligned(ref MemoryMarshal.GetReference(destination), exponent);
1151-
1149+
destination[0] = (byte)Exponent;
11521150
bytesWritten = sizeof(sbyte);
11531151
return true;
11541152
}
1155-
else
1156-
{
1157-
bytesWritten = 0;
1158-
return false;
1159-
}
1153+
1154+
bytesWritten = 0;
1155+
return false;
11601156
}
11611157

11621158
/// <inheritdoc cref="IFloatingPoint{TSelf}.TryWriteExponentLittleEndian(Span{byte}, out int)" />
11631159
bool IFloatingPoint<decimal>.TryWriteExponentLittleEndian(Span<byte> destination, out int bytesWritten)
11641160
{
11651161
if (destination.Length >= sizeof(sbyte))
11661162
{
1167-
sbyte exponent = Exponent;
1168-
Unsafe.WriteUnaligned(ref MemoryMarshal.GetReference(destination), exponent);
1169-
1163+
destination[0] = (byte)Exponent;
11701164
bytesWritten = sizeof(sbyte);
11711165
return true;
11721166
}
1173-
else
1174-
{
1175-
bytesWritten = 0;
1176-
return false;
1177-
}
1167+
1168+
bytesWritten = 0;
1169+
return false;
11781170
}
11791171

11801172
/// <inheritdoc cref="IFloatingPoint{TSelf}.TryWriteSignificandBigEndian(Span{byte}, out int)" />

‎src/libraries/System.Private.CoreLib/src/System/Double.cs

+16-60
Original file line numberDiff line numberDiff line change
@@ -725,97 +725,53 @@ int IFloatingPoint<double>.GetExponentShortestBitLength()
725725
/// <inheritdoc cref="IFloatingPoint{TSelf}.TryWriteExponentBigEndian(Span{byte}, out int)" />
726726
bool IFloatingPoint<double>.TryWriteExponentBigEndian(Span<byte> destination, out int bytesWritten)
727727
{
728-
if (destination.Length >= sizeof(short))
728+
if (BinaryPrimitives.TryWriteInt16BigEndian(destination, Exponent))
729729
{
730-
short exponent = Exponent;
731-
732-
if (BitConverter.IsLittleEndian)
733-
{
734-
exponent = BinaryPrimitives.ReverseEndianness(exponent);
735-
}
736-
737-
Unsafe.WriteUnaligned(ref MemoryMarshal.GetReference(destination), exponent);
738-
739730
bytesWritten = sizeof(short);
740731
return true;
741732
}
742-
else
743-
{
744-
bytesWritten = 0;
745-
return false;
746-
}
733+
734+
bytesWritten = 0;
735+
return false;
747736
}
748737

749738
/// <inheritdoc cref="IFloatingPoint{TSelf}.TryWriteExponentLittleEndian(Span{byte}, out int)" />
750739
bool IFloatingPoint<double>.TryWriteExponentLittleEndian(Span<byte> destination, out int bytesWritten)
751740
{
752-
if (destination.Length >= sizeof(short))
741+
if (BinaryPrimitives.TryWriteInt16LittleEndian(destination, Exponent))
753742
{
754-
short exponent = Exponent;
755-
756-
if (!BitConverter.IsLittleEndian)
757-
{
758-
exponent = BinaryPrimitives.ReverseEndianness(exponent);
759-
}
760-
761-
Unsafe.WriteUnaligned(ref MemoryMarshal.GetReference(destination), exponent);
762-
763743
bytesWritten = sizeof(short);
764744
return true;
765745
}
766-
else
767-
{
768-
bytesWritten = 0;
769-
return false;
770-
}
746+
747+
bytesWritten = 0;
748+
return false;
771749
}
772750

773751
/// <inheritdoc cref="IFloatingPoint{TSelf}.TryWriteSignificandBigEndian(Span{byte}, out int)" />
774752
bool IFloatingPoint<double>.TryWriteSignificandBigEndian(Span<byte> destination, out int bytesWritten)
775753
{
776-
if (destination.Length >= sizeof(ulong))
754+
if (BinaryPrimitives.TryWriteUInt64BigEndian(destination, Significand))
777755
{
778-
ulong significand = Significand;
779-
780-
if (BitConverter.IsLittleEndian)
781-
{
782-
significand = BinaryPrimitives.ReverseEndianness(significand);
783-
}
784-
785-
Unsafe.WriteUnaligned(ref MemoryMarshal.GetReference(destination), significand);
786-
787756
bytesWritten = sizeof(ulong);
788757
return true;
789758
}
790-
else
791-
{
792-
bytesWritten = 0;
793-
return false;
794-
}
759+
760+
bytesWritten = 0;
761+
return false;
795762
}
796763

797764
/// <inheritdoc cref="IFloatingPoint{TSelf}.TryWriteSignificandLittleEndian(Span{byte}, out int)" />
798765
bool IFloatingPoint<double>.TryWriteSignificandLittleEndian(Span<byte> destination, out int bytesWritten)
799766
{
800-
if (destination.Length >= sizeof(ulong))
767+
if (BinaryPrimitives.TryWriteUInt64LittleEndian(destination, Significand))
801768
{
802-
ulong significand = Significand;
803-
804-
if (!BitConverter.IsLittleEndian)
805-
{
806-
significand = BinaryPrimitives.ReverseEndianness(significand);
807-
}
808-
809-
Unsafe.WriteUnaligned(ref MemoryMarshal.GetReference(destination), significand);
810-
811769
bytesWritten = sizeof(ulong);
812770
return true;
813771
}
814-
else
815-
{
816-
bytesWritten = 0;
817-
return false;
818-
}
772+
773+
bytesWritten = 0;
774+
return false;
819775
}
820776

821777
//

‎src/libraries/System.Private.CoreLib/src/System/Half.cs

+16-46
Original file line numberDiff line numberDiff line change
@@ -1369,83 +1369,53 @@ bool IFloatingPoint<Half>.TryWriteExponentBigEndian(Span<byte> destination, out
13691369
{
13701370
if (destination.Length >= sizeof(sbyte))
13711371
{
1372-
sbyte exponent = Exponent;
1373-
Unsafe.WriteUnaligned(ref MemoryMarshal.GetReference(destination), exponent);
1374-
1372+
destination[0] = (byte)Exponent;
13751373
bytesWritten = sizeof(sbyte);
13761374
return true;
13771375
}
1378-
else
1379-
{
1380-
bytesWritten = 0;
1381-
return false;
1382-
}
1376+
1377+
bytesWritten = 0;
1378+
return false;
13831379
}
13841380

13851381
/// <inheritdoc cref="IFloatingPoint{TSelf}.TryWriteExponentLittleEndian(Span{byte}, out int)" />
13861382
bool IFloatingPoint<Half>.TryWriteExponentLittleEndian(Span<byte> destination, out int bytesWritten)
13871383
{
13881384
if (destination.Length >= sizeof(sbyte))
13891385
{
1390-
sbyte exponent = Exponent;
1391-
Unsafe.WriteUnaligned(ref MemoryMarshal.GetReference(destination), exponent);
1392-
1386+
destination[0] = (byte)Exponent;
13931387
bytesWritten = sizeof(sbyte);
13941388
return true;
13951389
}
1396-
else
1397-
{
1398-
bytesWritten = 0;
1399-
return false;
1400-
}
1390+
1391+
bytesWritten = 0;
1392+
return false;
14011393
}
14021394

14031395
/// <inheritdoc cref="IFloatingPoint{TSelf}.TryWriteSignificandBigEndian(Span{byte}, out int)" />
14041396
bool IFloatingPoint<Half>.TryWriteSignificandBigEndian(Span<byte> destination, out int bytesWritten)
14051397
{
1406-
if (destination.Length >= sizeof(ushort))
1398+
if (BinaryPrimitives.TryWriteUInt16BigEndian(destination, Significand))
14071399
{
1408-
ushort significand = Significand;
1409-
1410-
if (BitConverter.IsLittleEndian)
1411-
{
1412-
significand = BinaryPrimitives.ReverseEndianness(significand);
1413-
}
1414-
1415-
Unsafe.WriteUnaligned(ref MemoryMarshal.GetReference(destination), significand);
1416-
14171400
bytesWritten = sizeof(ushort);
14181401
return true;
14191402
}
1420-
else
1421-
{
1422-
bytesWritten = 0;
1423-
return false;
1424-
}
1403+
1404+
bytesWritten = 0;
1405+
return false;
14251406
}
14261407

14271408
/// <inheritdoc cref="IFloatingPoint{TSelf}.TryWriteSignificandLittleEndian(Span{byte}, out int)" />
14281409
bool IFloatingPoint<Half>.TryWriteSignificandLittleEndian(Span<byte> destination, out int bytesWritten)
14291410
{
1430-
if (destination.Length >= sizeof(ushort))
1411+
if (BinaryPrimitives.TryWriteUInt16LittleEndian(destination, Significand))
14311412
{
1432-
ushort significand = Significand;
1433-
1434-
if (!BitConverter.IsLittleEndian)
1435-
{
1436-
significand = BinaryPrimitives.ReverseEndianness(significand);
1437-
}
1438-
1439-
Unsafe.WriteUnaligned(ref MemoryMarshal.GetReference(destination), significand);
1440-
14411413
bytesWritten = sizeof(ushort);
14421414
return true;
14431415
}
1444-
else
1445-
{
1446-
bytesWritten = 0;
1447-
return false;
1448-
}
1416+
1417+
bytesWritten = 0;
1418+
return false;
14491419
}
14501420

14511421
//

‎src/libraries/System.Private.CoreLib/src/System/Int128.cs

+8-40
Original file line numberDiff line numberDiff line change
@@ -940,59 +940,27 @@ int IBinaryInteger<Int128>.GetShortestBitLength()
940940
/// <inheritdoc cref="IBinaryInteger{TSelf}.TryWriteBigEndian(Span{byte}, out int)" />
941941
bool IBinaryInteger<Int128>.TryWriteBigEndian(Span<byte> destination, out int bytesWritten)
942942
{
943-
if (destination.Length >= Size)
943+
if (BinaryPrimitives.TryWriteInt128BigEndian(destination, this))
944944
{
945-
ulong lower = _lower;
946-
ulong upper = _upper;
947-
948-
if (BitConverter.IsLittleEndian)
949-
{
950-
lower = BinaryPrimitives.ReverseEndianness(lower);
951-
upper = BinaryPrimitives.ReverseEndianness(upper);
952-
}
953-
954-
ref byte address = ref MemoryMarshal.GetReference(destination);
955-
956-
Unsafe.WriteUnaligned(ref address, upper);
957-
Unsafe.WriteUnaligned(ref Unsafe.AddByteOffset(ref address, sizeof(ulong)), lower);
958-
959945
bytesWritten = Size;
960946
return true;
961947
}
962-
else
963-
{
964-
bytesWritten = 0;
965-
return false;
966-
}
948+
949+
bytesWritten = 0;
950+
return false;
967951
}
968952

969953
/// <inheritdoc cref="IBinaryInteger{TSelf}.TryWriteLittleEndian(Span{byte}, out int)" />
970954
bool IBinaryInteger<Int128>.TryWriteLittleEndian(Span<byte> destination, out int bytesWritten)
971955
{
972-
if (destination.Length >= Size)
956+
if (BinaryPrimitives.TryWriteInt128LittleEndian(destination, this))
973957
{
974-
ulong lower = _lower;
975-
ulong upper = _upper;
976-
977-
if (!BitConverter.IsLittleEndian)
978-
{
979-
lower = BinaryPrimitives.ReverseEndianness(lower);
980-
upper = BinaryPrimitives.ReverseEndianness(upper);
981-
}
982-
983-
ref byte address = ref MemoryMarshal.GetReference(destination);
984-
985-
Unsafe.WriteUnaligned(ref address, lower);
986-
Unsafe.WriteUnaligned(ref Unsafe.AddByteOffset(ref address, sizeof(ulong)), upper);
987-
988958
bytesWritten = Size;
989959
return true;
990960
}
991-
else
992-
{
993-
bytesWritten = 0;
994-
return false;
995-
}
961+
962+
bytesWritten = 0;
963+
return false;
996964
}
997965

998966
//

0 commit comments

Comments
 (0)