Skip to content

Commit c286a8e

Browse files
stephentoubstephentoub
authored
Revert uses of Unsafe.BitCast with spans to unblock mono (#102998)
* Revert uses of Unsafe.BitCast with spans to unblock mono * Comment out a test
1 parent a4407a1 commit c286a8e

File tree

10 files changed

+67
-74
lines changed

10 files changed

+67
-74
lines changed

‎src/libraries/System.Linq/src/System/Linq/Sum.cs

+2-2
Original file line numberDiff line numberDiff line change
@@ -60,11 +60,11 @@ private static TResult Sum<T, TResult>(ReadOnlySpan<T> span)
6060

6161
if (typeof(T) == typeof(long))
6262
{
63-
return (TResult)(object)SumSignedIntegersVectorized(Unsafe.BitCast<ReadOnlySpan<T>, ReadOnlySpan<long>>(span));
63+
return (TResult)(object)SumSignedIntegersVectorized(MemoryMarshal.Cast<T, long>(span));
6464
}
6565
if (typeof(T) == typeof(int))
6666
{
67-
return (TResult)(object)SumSignedIntegersVectorized(Unsafe.BitCast<ReadOnlySpan<T>, ReadOnlySpan<int>>(span));
67+
return (TResult)(object)SumSignedIntegersVectorized(MemoryMarshal.Cast<T, int>(span));
6868
}
6969
}
7070

‎src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/TensorPrimitives.Helpers.cs

-8
Original file line numberDiff line numberDiff line change
@@ -36,11 +36,7 @@ private static void ValidateInputOutputSpanNonOverlapping<T>(ReadOnlySpan<T> inp
3636
private static unsafe Span<TTo> Rename<TFrom, TTo>(Span<TFrom> span)
3737
{
3838
Debug.Assert(sizeof(TFrom) == sizeof(TTo));
39-
#if NET9_0_OR_GREATER
40-
return Unsafe.BitCast<Span<TFrom>, Span<TTo>>(span);
41-
#else
4239
return *(Span<TTo>*)(&span);
43-
#endif
4440
}
4541

4642
/// <summary>Creates a span of <typeparamref name="TTo"/> from a <typeparamref name="TFrom"/> when they're the same type.</summary>
@@ -52,11 +48,7 @@ private static unsafe Span<TTo> Rename<TFrom, TTo>(Span<TFrom> span)
5248
private static unsafe ReadOnlySpan<TTo> Rename<TFrom, TTo>(ReadOnlySpan<TFrom> span)
5349
{
5450
Debug.Assert(sizeof(TFrom) == sizeof(TTo));
55-
#if NET9_0_OR_GREATER
56-
return Unsafe.BitCast<ReadOnlySpan<TFrom>, ReadOnlySpan<TTo>>(span);
57-
#else
5851
return *(ReadOnlySpan<TTo>*)(&span);
59-
#endif
6052
}
6153

6254
/// <summary>Mask used to handle alignment elements before vectorized handling of the input.</summary>

‎src/libraries/System.Private.CoreLib/src/System/Globalization/DateTimeFormat.cs

+4-4
Original file line numberDiff line numberDiff line change
@@ -763,12 +763,12 @@ private static void AppendString<TChar>(ref ValueListBuilder<TChar> result, scop
763763
{
764764
if (typeof(TChar) == typeof(char))
765765
{
766-
result.Append(Unsafe.BitCast<ReadOnlySpan<char>, ReadOnlySpan<TChar>>(s));
766+
result.Append(MemoryMarshal.Cast<char, TChar>(s));
767767
}
768768
else
769769
{
770770
Debug.Assert(typeof(TChar) == typeof(byte));
771-
Encoding.UTF8.GetBytes(s, Unsafe.BitCast<Span<TChar>, Span<byte>>(result.AppendSpan(Encoding.UTF8.GetByteCount(s))));
771+
Encoding.UTF8.GetBytes(s, MemoryMarshal.Cast<TChar, byte>(result.AppendSpan(Encoding.UTF8.GetByteCount(s))));
772772
}
773773
}
774774

@@ -777,8 +777,8 @@ internal static void FormatFraction<TChar>(ref ValueListBuilder<TChar> result, i
777777
Span<TChar> chars = stackalloc TChar[11];
778778
int charCount;
779779
bool formatted = typeof(TChar) == typeof(char) ?
780-
fraction.TryFormat(Unsafe.BitCast<Span<TChar>, Span<char>>(chars), out charCount, fractionFormat, CultureInfo.InvariantCulture) :
781-
fraction.TryFormat(Unsafe.BitCast<Span<TChar>, Span<byte>>(chars), out charCount, fractionFormat, CultureInfo.InvariantCulture);
780+
fraction.TryFormat(MemoryMarshal.Cast<TChar, char>(chars), out charCount, fractionFormat, CultureInfo.InvariantCulture) :
781+
fraction.TryFormat(MemoryMarshal.Cast<TChar, byte>(chars), out charCount, fractionFormat, CultureInfo.InvariantCulture);
782782
Debug.Assert(charCount != 0);
783783
result.Append(chars.Slice(0, charCount));
784784
}

‎src/libraries/System.Private.CoreLib/src/System/Globalization/DateTimeFormatInfo.cs

+10-10
Original file line numberDiff line numberDiff line change
@@ -358,8 +358,8 @@ internal ReadOnlySpan<TChar> AMDesignatorTChar<TChar>() where TChar : unmanaged,
358358
{
359359
Debug.Assert(typeof(TChar) == typeof(char) || typeof(TChar) == typeof(byte));
360360
return typeof(TChar) == typeof(char) ?
361-
Unsafe.BitCast<ReadOnlySpan<char>, ReadOnlySpan<TChar>>(AMDesignator) :
362-
Unsafe.BitCast<ReadOnlySpan<byte>, ReadOnlySpan<TChar>>(amDesignatorUtf8 ??= Encoding.UTF8.GetBytes(AMDesignator));
361+
MemoryMarshal.Cast<char, TChar>(AMDesignator) :
362+
MemoryMarshal.Cast<byte, TChar>(amDesignatorUtf8 ??= Encoding.UTF8.GetBytes(AMDesignator));
363363
}
364364

365365
public Calendar Calendar
@@ -607,8 +607,8 @@ internal ReadOnlySpan<TChar> DateSeparatorTChar<TChar>() where TChar : unmanaged
607607
{
608608
Debug.Assert(typeof(TChar) == typeof(char) || typeof(TChar) == typeof(byte));
609609
return typeof(TChar) == typeof(char) ?
610-
Unsafe.BitCast<ReadOnlySpan<char>, ReadOnlySpan<TChar>>(DateSeparator) :
611-
Unsafe.BitCast<ReadOnlySpan<byte>, ReadOnlySpan<TChar>>(dateSeparatorUtf8 ??= Encoding.UTF8.GetBytes(DateSeparator));
610+
MemoryMarshal.Cast<char, TChar>(DateSeparator) :
611+
MemoryMarshal.Cast<byte, TChar>(dateSeparatorUtf8 ??= Encoding.UTF8.GetBytes(DateSeparator));
612612
}
613613

614614
public DayOfWeek FirstDayOfWeek
@@ -810,8 +810,8 @@ internal ReadOnlySpan<TChar> PMDesignatorTChar<TChar>() where TChar : unmanaged,
810810
{
811811
Debug.Assert(typeof(TChar) == typeof(char) || typeof(TChar) == typeof(byte));
812812
return typeof(TChar) == typeof(char) ?
813-
Unsafe.BitCast<ReadOnlySpan<char>, ReadOnlySpan<TChar>>(PMDesignator) :
814-
Unsafe.BitCast<ReadOnlySpan<byte>, ReadOnlySpan<TChar>>(pmDesignatorUtf8 ??= Encoding.UTF8.GetBytes(PMDesignator));
813+
MemoryMarshal.Cast<char, TChar>(PMDesignator) :
814+
MemoryMarshal.Cast<byte, TChar>(pmDesignatorUtf8 ??= Encoding.UTF8.GetBytes(PMDesignator));
815815
}
816816

817817
public string RFC1123Pattern => rfc1123Pattern;
@@ -992,8 +992,8 @@ internal ReadOnlySpan<TChar> TimeSeparatorTChar<TChar>() where TChar : unmanaged
992992
{
993993
Debug.Assert(typeof(TChar) == typeof(char) || typeof(TChar) == typeof(byte));
994994
return typeof(TChar) == typeof(char) ?
995-
Unsafe.BitCast<ReadOnlySpan<char>, ReadOnlySpan<TChar>>(TimeSeparator) :
996-
Unsafe.BitCast<ReadOnlySpan<byte>, ReadOnlySpan<TChar>>(timeSeparatorUtf8 ??= Encoding.UTF8.GetBytes(TimeSeparator));
995+
MemoryMarshal.Cast<char, TChar>(TimeSeparator) :
996+
MemoryMarshal.Cast<byte, TChar>(timeSeparatorUtf8 ??= Encoding.UTF8.GetBytes(TimeSeparator));
997997
}
998998

999999
public string UniversalSortableDateTimePattern => universalSortableDateTimePattern;
@@ -1731,8 +1731,8 @@ internal ReadOnlySpan<TChar> DecimalSeparatorTChar<TChar>() where TChar : unmana
17311731
{
17321732
Debug.Assert(typeof(TChar) == typeof(char) || typeof(TChar) == typeof(byte));
17331733
return typeof(TChar) == typeof(char) ?
1734-
Unsafe.BitCast<ReadOnlySpan<char>, ReadOnlySpan<TChar>>(DecimalSeparator) :
1735-
Unsafe.BitCast<ReadOnlySpan<byte>, ReadOnlySpan<TChar>>(_decimalSeparatorUtf8 ??= Encoding.UTF8.GetBytes(DecimalSeparator));
1734+
MemoryMarshal.Cast<char, TChar>(DecimalSeparator) :
1735+
MemoryMarshal.Cast<byte, TChar>(_decimalSeparatorUtf8 ??= Encoding.UTF8.GetBytes(DecimalSeparator));
17361736
}
17371737

17381738
// Positive TimeSpan Pattern

‎src/libraries/System.Private.CoreLib/src/System/Globalization/NumberFormatInfo.cs

+28-28
Original file line numberDiff line numberDiff line change
@@ -269,8 +269,8 @@ internal ReadOnlySpan<TChar> CurrencyDecimalSeparatorTChar<TChar>() where TChar
269269
{
270270
Debug.Assert(typeof(TChar) == typeof(char) || typeof(TChar) == typeof(byte));
271271
return typeof(TChar) == typeof(char) ?
272-
Unsafe.BitCast<ReadOnlySpan<char>, ReadOnlySpan<TChar>>(_currencyDecimalSeparator) :
273-
Unsafe.BitCast<ReadOnlySpan<byte>, ReadOnlySpan<TChar>>(_currencyDecimalSeparatorUtf8 ??= Encoding.UTF8.GetBytes(_currencyDecimalSeparator));
272+
MemoryMarshal.Cast<char, TChar>(_currencyDecimalSeparator) :
273+
MemoryMarshal.Cast<byte, TChar>(_currencyDecimalSeparatorUtf8 ??= Encoding.UTF8.GetBytes(_currencyDecimalSeparator));
274274
}
275275

276276
public bool IsReadOnly => _isReadOnly;
@@ -361,8 +361,8 @@ internal ReadOnlySpan<TChar> CurrencyGroupSeparatorTChar<TChar>() where TChar :
361361
{
362362
Debug.Assert(typeof(TChar) == typeof(char) || typeof(TChar) == typeof(byte));
363363
return typeof(TChar) == typeof(char) ?
364-
Unsafe.BitCast<ReadOnlySpan<char>, ReadOnlySpan<TChar>>(_currencyGroupSeparator) :
365-
Unsafe.BitCast<ReadOnlySpan<byte>, ReadOnlySpan<TChar>>(_currencyGroupSeparatorUtf8 ??= Encoding.UTF8.GetBytes(_currencyGroupSeparator));
364+
MemoryMarshal.Cast<char, TChar>(_currencyGroupSeparator) :
365+
MemoryMarshal.Cast<byte, TChar>(_currencyGroupSeparatorUtf8 ??= Encoding.UTF8.GetBytes(_currencyGroupSeparator));
366366
}
367367

368368
public string CurrencySymbol
@@ -383,8 +383,8 @@ internal ReadOnlySpan<TChar> CurrencySymbolTChar<TChar>() where TChar : unmanage
383383
{
384384
Debug.Assert(typeof(TChar) == typeof(char) || typeof(TChar) == typeof(byte));
385385
return typeof(TChar) == typeof(char) ?
386-
Unsafe.BitCast<ReadOnlySpan<char>, ReadOnlySpan<TChar>>(_currencySymbol) :
387-
Unsafe.BitCast<ReadOnlySpan<byte>, ReadOnlySpan<TChar>>(_currencySymbolUtf8 ??= Encoding.UTF8.GetBytes(_currencySymbol));
386+
MemoryMarshal.Cast<char, TChar>(_currencySymbol) :
387+
MemoryMarshal.Cast<byte, TChar>(_currencySymbolUtf8 ??= Encoding.UTF8.GetBytes(_currencySymbol));
388388
}
389389

390390
internal byte[]? CurrencySymbolUtf8 => _currencySymbolUtf8 ??= Encoding.UTF8.GetBytes(_currencySymbol);
@@ -429,8 +429,8 @@ internal ReadOnlySpan<TChar> NaNSymbolTChar<TChar>() where TChar : unmanaged, IU
429429
{
430430
Debug.Assert(typeof(TChar) == typeof(char) || typeof(TChar) == typeof(byte));
431431
return typeof(TChar) == typeof(char) ?
432-
Unsafe.BitCast<ReadOnlySpan<char>, ReadOnlySpan<TChar>>(_nanSymbol) :
433-
Unsafe.BitCast<ReadOnlySpan<byte>, ReadOnlySpan<TChar>>(_nanSymbolUtf8 ??= Encoding.UTF8.GetBytes(_nanSymbol));
432+
MemoryMarshal.Cast<char, TChar>(_nanSymbol) :
433+
MemoryMarshal.Cast<byte, TChar>(_nanSymbolUtf8 ??= Encoding.UTF8.GetBytes(_nanSymbol));
434434
}
435435

436436
public int CurrencyNegativePattern
@@ -514,8 +514,8 @@ internal ReadOnlySpan<TChar> NegativeInfinitySymbolTChar<TChar>() where TChar :
514514
{
515515
Debug.Assert(typeof(TChar) == typeof(char) || typeof(TChar) == typeof(byte));
516516
return typeof(TChar) == typeof(char) ?
517-
Unsafe.BitCast<ReadOnlySpan<char>, ReadOnlySpan<TChar>>(_negativeInfinitySymbol) :
518-
Unsafe.BitCast<ReadOnlySpan<byte>, ReadOnlySpan<TChar>>(_negativeInfinitySymbolUtf8 ??= Encoding.UTF8.GetBytes(_negativeInfinitySymbol));
517+
MemoryMarshal.Cast<char, TChar>(_negativeInfinitySymbol) :
518+
MemoryMarshal.Cast<byte, TChar>(_negativeInfinitySymbolUtf8 ??= Encoding.UTF8.GetBytes(_negativeInfinitySymbol));
519519
}
520520

521521
public string NegativeSign
@@ -537,8 +537,8 @@ internal ReadOnlySpan<TChar> NegativeSignTChar<TChar>() where TChar : unmanaged,
537537
{
538538
Debug.Assert(typeof(TChar) == typeof(char) || typeof(TChar) == typeof(byte));
539539
return typeof(TChar) == typeof(char) ?
540-
Unsafe.BitCast<ReadOnlySpan<char>, ReadOnlySpan<TChar>>(_negativeSign) :
541-
Unsafe.BitCast<ReadOnlySpan<byte>, ReadOnlySpan<TChar>>(_negativeSignUtf8 ??= Encoding.UTF8.GetBytes(_negativeSign));
540+
MemoryMarshal.Cast<char, TChar>(_negativeSign) :
541+
MemoryMarshal.Cast<byte, TChar>(_negativeSignUtf8 ??= Encoding.UTF8.GetBytes(_negativeSign));
542542
}
543543

544544
public int NumberDecimalDigits
@@ -573,8 +573,8 @@ internal ReadOnlySpan<TChar> NumberDecimalSeparatorTChar<TChar>() where TChar :
573573
{
574574
Debug.Assert(typeof(TChar) == typeof(char) || typeof(TChar) == typeof(byte));
575575
return typeof(TChar) == typeof(char) ?
576-
Unsafe.BitCast<ReadOnlySpan<char>, ReadOnlySpan<TChar>>(_numberDecimalSeparator) :
577-
Unsafe.BitCast<ReadOnlySpan<byte>, ReadOnlySpan<TChar>>(_numberDecimalSeparatorUtf8 ??= Encoding.UTF8.GetBytes(_numberDecimalSeparator));
576+
MemoryMarshal.Cast<char, TChar>(_numberDecimalSeparator) :
577+
MemoryMarshal.Cast<byte, TChar>(_numberDecimalSeparatorUtf8 ??= Encoding.UTF8.GetBytes(_numberDecimalSeparator));
578578
}
579579

580580
public string NumberGroupSeparator
@@ -594,8 +594,8 @@ internal ReadOnlySpan<TChar> NumberGroupSeparatorTChar<TChar>() where TChar : un
594594
{
595595
Debug.Assert(typeof(TChar) == typeof(char) || typeof(TChar) == typeof(byte));
596596
return typeof(TChar) == typeof(char) ?
597-
Unsafe.BitCast<ReadOnlySpan<char>, ReadOnlySpan<TChar>>(_numberGroupSeparator) :
598-
Unsafe.BitCast<ReadOnlySpan<byte>, ReadOnlySpan<TChar>>(_numberGroupSeparatorUtf8 ??= Encoding.UTF8.GetBytes(_numberGroupSeparator));
597+
MemoryMarshal.Cast<char, TChar>(_numberGroupSeparator) :
598+
MemoryMarshal.Cast<byte, TChar>(_numberGroupSeparatorUtf8 ??= Encoding.UTF8.GetBytes(_numberGroupSeparator));
599599
}
600600

601601
public int CurrencyPositivePattern
@@ -631,8 +631,8 @@ internal ReadOnlySpan<TChar> PositiveInfinitySymbolTChar<TChar>() where TChar :
631631
{
632632
Debug.Assert(typeof(TChar) == typeof(char) || typeof(TChar) == typeof(byte));
633633
return typeof(TChar) == typeof(char) ?
634-
Unsafe.BitCast<ReadOnlySpan<char>, ReadOnlySpan<TChar>>(_positiveInfinitySymbol) :
635-
Unsafe.BitCast<ReadOnlySpan<byte>, ReadOnlySpan<TChar>>(_positiveInfinitySymbolUtf8 ??= Encoding.UTF8.GetBytes(_positiveInfinitySymbol));
634+
MemoryMarshal.Cast<char, TChar>(_positiveInfinitySymbol) :
635+
MemoryMarshal.Cast<byte, TChar>(_positiveInfinitySymbolUtf8 ??= Encoding.UTF8.GetBytes(_positiveInfinitySymbol));
636636
}
637637

638638
public string PositiveSign
@@ -654,8 +654,8 @@ internal ReadOnlySpan<TChar> PositiveSignTChar<TChar>() where TChar : unmanaged,
654654
{
655655
Debug.Assert(typeof(TChar) == typeof(char) || typeof(TChar) == typeof(byte));
656656
return typeof(TChar) == typeof(char) ?
657-
Unsafe.BitCast<ReadOnlySpan<char>, ReadOnlySpan<TChar>>(_positiveSign) :
658-
Unsafe.BitCast<ReadOnlySpan<byte>, ReadOnlySpan<TChar>>(_positiveSignUtf8 ??= Encoding.UTF8.GetBytes(_positiveSign));
657+
MemoryMarshal.Cast<char, TChar>(_positiveSign) :
658+
MemoryMarshal.Cast<byte, TChar>(_positiveSignUtf8 ??= Encoding.UTF8.GetBytes(_positiveSign));
659659
}
660660

661661
public int PercentDecimalDigits
@@ -690,8 +690,8 @@ internal ReadOnlySpan<TChar> PercentDecimalSeparatorTChar<TChar>() where TChar :
690690
{
691691
Debug.Assert(typeof(TChar) == typeof(char) || typeof(TChar) == typeof(byte));
692692
return typeof(TChar) == typeof(char) ?
693-
Unsafe.BitCast<ReadOnlySpan<char>, ReadOnlySpan<TChar>>(_percentDecimalSeparator) :
694-
Unsafe.BitCast<ReadOnlySpan<byte>, ReadOnlySpan<TChar>>(_percentDecimalSeparatorUtf8 ??= Encoding.UTF8.GetBytes(_percentDecimalSeparator));
693+
MemoryMarshal.Cast<char, TChar>(_percentDecimalSeparator) :
694+
MemoryMarshal.Cast<byte, TChar>(_percentDecimalSeparatorUtf8 ??= Encoding.UTF8.GetBytes(_percentDecimalSeparator));
695695
}
696696

697697
public string PercentGroupSeparator
@@ -711,8 +711,8 @@ internal ReadOnlySpan<TChar> PercentGroupSeparatorTChar<TChar>() where TChar : u
711711
{
712712
Debug.Assert(typeof(TChar) == typeof(char) || typeof(TChar) == typeof(byte));
713713
return typeof(TChar) == typeof(char) ?
714-
Unsafe.BitCast<ReadOnlySpan<char>, ReadOnlySpan<TChar>>(_percentGroupSeparator) :
715-
Unsafe.BitCast<ReadOnlySpan<byte>, ReadOnlySpan<TChar>>(_percentGroupSeparatorUtf8 ??= Encoding.UTF8.GetBytes(_percentGroupSeparator));
714+
MemoryMarshal.Cast<char, TChar>(_percentGroupSeparator) :
715+
MemoryMarshal.Cast<byte, TChar>(_percentGroupSeparatorUtf8 ??= Encoding.UTF8.GetBytes(_percentGroupSeparator));
716716
}
717717

718718
public string PercentSymbol
@@ -732,8 +732,8 @@ internal ReadOnlySpan<TChar> PercentSymbolTChar<TChar>() where TChar : unmanaged
732732
{
733733
Debug.Assert(typeof(TChar) == typeof(char) || typeof(TChar) == typeof(byte));
734734
return typeof(TChar) == typeof(char) ?
735-
Unsafe.BitCast<ReadOnlySpan<char>, ReadOnlySpan<TChar>>(_percentSymbol) :
736-
Unsafe.BitCast<ReadOnlySpan<byte>, ReadOnlySpan<TChar>>(_percentSymbolUtf8 ??= Encoding.UTF8.GetBytes(_percentSymbol));
735+
MemoryMarshal.Cast<char, TChar>(_percentSymbol) :
736+
MemoryMarshal.Cast<byte, TChar>(_percentSymbolUtf8 ??= Encoding.UTF8.GetBytes(_percentSymbol));
737737
}
738738

739739
public string PerMilleSymbol
@@ -754,8 +754,8 @@ internal ReadOnlySpan<TChar> PerMilleSymbolTChar<TChar>() where TChar : unmanage
754754
{
755755
Debug.Assert(typeof(TChar) == typeof(char) || typeof(TChar) == typeof(byte));
756756
return typeof(TChar) == typeof(char) ?
757-
Unsafe.BitCast<ReadOnlySpan<char>, ReadOnlySpan<TChar>>(_perMilleSymbol) :
758-
Unsafe.BitCast<ReadOnlySpan<byte>, ReadOnlySpan<TChar>>(_perMilleSymbolUtf8 ??= Encoding.UTF8.GetBytes(_perMilleSymbol));
757+
MemoryMarshal.Cast<char, TChar>(_perMilleSymbol) :
758+
MemoryMarshal.Cast<byte, TChar>(_perMilleSymbolUtf8 ??= Encoding.UTF8.GetBytes(_perMilleSymbol));
759759
}
760760

761761
public string[] NativeDigits

‎src/libraries/System.Private.CoreLib/src/System/Number.Formatting.cs

+2-2
Original file line numberDiff line numberDiff line change
@@ -621,7 +621,7 @@ private static bool TryCopyTo<TChar>(string source, Span<TChar> destination, out
621621

622622
if (typeof(TChar) == typeof(char))
623623
{
624-
if (source.TryCopyTo(Unsafe.BitCast<Span<TChar>, Span<char>>(destination)))
624+
if (source.TryCopyTo(MemoryMarshal.Cast<TChar, char>(destination)))
625625
{
626626
charsWritten = source.Length;
627627
return true;
@@ -632,7 +632,7 @@ private static bool TryCopyTo<TChar>(string source, Span<TChar> destination, out
632632
}
633633
else
634634
{
635-
return Encoding.UTF8.TryGetBytes(source, Unsafe.BitCast<Span<TChar>, Span<byte>>(destination), out charsWritten);
635+
return Encoding.UTF8.TryGetBytes(source, MemoryMarshal.Cast<TChar, byte>(destination), out charsWritten);
636636
}
637637
}
638638

0 commit comments

Comments
 (0)