Merge pull request #511 from CommunityToolkit/dev/use-language-unsafe

Replace Unsafe.SizeOf<T>() with sizeof(T)

Author: Sergio0694

build/Community.Toolkit.Common.props

@@ -22,6 +22,13 @@
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
     <LangVersion>11.0</LangVersion>
     <Nullable>enable</Nullable>
+
+    <!--
+      Suppress ref safety warnings in unsafe contexts (see https://github.com/dotnet/csharplang/issues/6476).
+      This is used eg. to replace Unsafe.SizeOf<T>() calls with just sizeof(T). The warning is not necessary
+      since in order to use these APIs the caller already has to be in an unsafe context.
+    -->
+    <NoWarn>$(NoWarn);CS8500</NoWarn>
   </PropertyGroup>
 
   <PropertyGroup>

src/CommunityToolkit.Diagnostics/Extensions/ValueTypeExtensions.cs

@@ -44,7 +44,7 @@ public static class ValueTypeExtensions
     public static unsafe string ToHexString<T>(this T value)
         where T : unmanaged
     {
-        int sizeOfT = Unsafe.SizeOf<T>();
+        int sizeOfT = sizeof(T);
         int bufferSize = (2 * sizeOfT) + 2;
         char* p = stackalloc char[bufferSize];
 

src/CommunityToolkit.Diagnostics/Guard.String.cs

@@ -4,7 +4,6 @@
 
 using System;
 using System.Diagnostics.CodeAnalysis;
-using System.IO;
 using System.Runtime.CompilerServices;
 
 #pragma warning disable CS8777

src/CommunityToolkit.HighPerformance/Buffers/Internals/ArrayMemoryManager{TFrom,TTo}.cs

@@ -70,13 +70,13 @@ public override Span<TTo> GetSpan()
     /// <inheritdoc/>
     public override unsafe MemoryHandle Pin(int elementIndex = 0)
     {
-        if ((uint)elementIndex >= (uint)(this.length * Unsafe.SizeOf<TFrom>() / Unsafe.SizeOf<TTo>()))
+        if ((uint)elementIndex >= (uint)(this.length * sizeof(TFrom) / sizeof(TTo)))
         {
             ThrowArgumentOutOfRangeExceptionForInvalidIndex();
         }
 
-        int bytePrefix = this.offset * Unsafe.SizeOf<TFrom>();
-        int byteSuffix = elementIndex * Unsafe.SizeOf<TTo>();
+        int bytePrefix = this.offset * sizeof(TFrom);
+        int byteSuffix = elementIndex * sizeof(TTo);
         int byteOffset = bytePrefix + byteSuffix;
 
         GCHandle handle = GCHandle.Alloc(this.array, GCHandleType.Pinned);

src/CommunityToolkit.HighPerformance/Buffers/Internals/ProxyMemoryManager{TFrom,TTo}.cs

@@ -4,7 +4,6 @@
 
 using System;
 using System.Buffers;
-using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 using CommunityToolkit.HighPerformance.Buffers.Internals.Interfaces;
 using RuntimeHelpers = CommunityToolkit.HighPerformance.Helpers.Internals.RuntimeHelpers;
@@ -57,17 +56,17 @@ public override Span<TTo> GetSpan()
     }
 
     /// <inheritdoc/>
-    public override MemoryHandle Pin(int elementIndex = 0)
+    public override unsafe MemoryHandle Pin(int elementIndex = 0)
     {
-        if ((uint)elementIndex >= (uint)(this.length * Unsafe.SizeOf<TFrom>() / Unsafe.SizeOf<TTo>()))
+        if ((uint)elementIndex >= (uint)(this.length * sizeof(TFrom) / sizeof(TTo)))
         {
             ThrowArgumentExceptionForInvalidIndex();
         }
 
-        int bytePrefix = this.offset * Unsafe.SizeOf<TFrom>();
-        int byteSuffix = elementIndex * Unsafe.SizeOf<TTo>();
+        int bytePrefix = this.offset * sizeof(TFrom);
+        int byteSuffix = elementIndex * sizeof(TTo);
         int byteOffset = bytePrefix + byteSuffix;
-        int shiftedOffset = Math.DivRem(byteOffset, Unsafe.SizeOf<TFrom>(), out int remainder);
+        int shiftedOffset = Math.DivRem(byteOffset, sizeof(TFrom), out int remainder);
 
         if (remainder != 0)
         {

src/CommunityToolkit.HighPerformance/Buffers/Internals/StringMemoryManager{TTo}.cs

@@ -66,13 +66,13 @@ public override Span<TTo> GetSpan()
     /// <inheritdoc/>
     public override unsafe MemoryHandle Pin(int elementIndex = 0)
     {
-        if ((uint)elementIndex >= (uint)(this.length * Unsafe.SizeOf<char>() / Unsafe.SizeOf<TTo>()))
+        if ((uint)elementIndex >= (uint)(this.length * sizeof(char) / sizeof(TTo)))
         {
             ThrowArgumentOutOfRangeExceptionForInvalidIndex();
         }
 
-        int bytePrefix = this.offset * Unsafe.SizeOf<char>();
-        int byteSuffix = elementIndex * Unsafe.SizeOf<TTo>();
+        int bytePrefix = this.offset * sizeof(char);
+        int byteSuffix = elementIndex * sizeof(TTo);
         int byteOffset = bytePrefix + byteSuffix;
 
         GCHandle handle = GCHandle.Alloc(this.text, GCHandleType.Pinned);

src/CommunityToolkit.HighPerformance/Extensions/IBufferWriterExtensions.cs

@@ -45,10 +45,10 @@ public static Stream AsStream(this IBufferWriter<byte> writer)
     /// <param name="writer">The target <see cref="IBufferWriter{T}"/> instance to write to.</param>
     /// <param name="value">The input value to write to <paramref name="writer"/>.</param>
     /// <exception cref="ArgumentException">Thrown if <paramref name="writer"/> reaches the end.</exception>
-    public static void Write<T>(this IBufferWriter<byte> writer, T value)
+    public static unsafe void Write<T>(this IBufferWriter<byte> writer, T value)
         where T : unmanaged
     {
-        int length = Unsafe.SizeOf<T>();
+        int length = sizeof(T);
         Span<byte> span = writer.GetSpan(1);
 
         if (span.Length < length)

src/CommunityToolkit.HighPerformance/Extensions/ReadOnlySpanExtensions.cs

@@ -210,13 +210,13 @@ public static ReadOnlySpan2D<T> AsSpan2D<T>(this ReadOnlySpan<T> span, int offse
     /// <param name="value">The reference to the target item to get the index for.</param>
     /// <returns>The index of <paramref name="value"/> within <paramref name="span"/>, or <c>-1</c>.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static int IndexOf<T>(this ReadOnlySpan<T> span, in T value)
+    public static unsafe int IndexOf<T>(this ReadOnlySpan<T> span, in T value)
     {
         ref T r0 = ref MemoryMarshal.GetReference(span);
         ref T r1 = ref Unsafe.AsRef(value);
         IntPtr byteOffset = Unsafe.ByteOffset(ref r0, ref r1);
 
-        nint elementOffset = byteOffset / (nint)(uint)Unsafe.SizeOf<T>();
+        nint elementOffset = byteOffset / (nint)(uint)sizeof(T);
 
         if ((nuint)elementOffset >= (uint)span.Length)
         {

src/CommunityToolkit.HighPerformance/Extensions/SpanExtensions.cs

@@ -148,12 +148,12 @@ public static Span<TTo> Cast<TFrom, TTo>(this Span<TFrom> span)
     /// <param name="value">The reference to the target item to get the index for.</param>
     /// <returns>The index of <paramref name="value"/> within <paramref name="span"/>, or <c>-1</c>.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static int IndexOf<T>(this Span<T> span, ref T value)
+    public static unsafe int IndexOf<T>(this Span<T> span, ref T value)
     {
         ref T r0 = ref MemoryMarshal.GetReference(span);
         IntPtr byteOffset = Unsafe.ByteOffset(ref r0, ref value);
 
-        nint elementOffset = byteOffset / (nint)(uint)Unsafe.SizeOf<T>();
+        nint elementOffset = byteOffset / (nint)(uint)sizeof(T);
 
         if ((nuint)elementOffset >= (uint)span.Length)
         {

src/CommunityToolkit.HighPerformance/Extensions/StreamExtensions.cs

@@ -202,12 +202,12 @@ public static void Write(this Stream stream, ReadOnlySpan<byte> buffer)
 #if NETSTANDARD2_1_OR_GREATER
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
 #endif
-    public static T Read<T>(this Stream stream)
+    public static unsafe T Read<T>(this Stream stream)
         where T : unmanaged
     {
 #if NETSTANDARD2_1_OR_GREATER
         T result = default;
-        int length = Unsafe.SizeOf<T>();
+        int length = sizeof(T);
 
         unsafe
         {
@@ -219,7 +219,7 @@ public static T Read<T>(this Stream stream)
 
         return result;
 #else
-        int length = Unsafe.SizeOf<T>();
+        int length = sizeof(T);
         byte[] buffer = ArrayPool<byte>.Shared.Rent(length);
 
         try
@@ -247,19 +247,19 @@ public static T Read<T>(this Stream stream)
 #if NETSTANDARD2_1_OR_GREATER
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
 #endif
-    public static void Write<T>(this Stream stream, in T value)
+    public static unsafe void Write<T>(this Stream stream, in T value)
         where T : unmanaged
     {
 #if NETSTANDARD2_1_OR_GREATER
         ref T r0 = ref Unsafe.AsRef(value);
         ref byte r1 = ref Unsafe.As<T, byte>(ref r0);
-        int length = Unsafe.SizeOf<T>();
+        int length = sizeof(T);
 
         ReadOnlySpan<byte> span = MemoryMarshal.CreateReadOnlySpan(ref r1, length);
 
         stream.Write(span);
 #else
-        int length = Unsafe.SizeOf<T>();
+        int length = sizeof(T);
         byte[] buffer = ArrayPool<byte>.Shared.Rent(length);
 
         try