Convert uses of the Dangerous APIs to use MemoryMarshal.GetReference

src/mscorlib/shared/Internal/Runtime/CompilerServices/Unsafe.cs

@@ -317,6 +317,17 @@ public static ref T AsRef<T>(void* source)
             return ref Unsafe.As<byte, T>(ref *(byte*)source);
         }
 
+        /// <summary>
+        /// Reinterprets the given read-only reference as a reference.
+        /// </summary>
+        [Intrinsic]
+        [NonVersionable]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static ref T AsRef<T>(in T source)
+        {
+            throw new PlatformNotSupportedException();
+        }
+
         /// <summary>
         /// Determines the byte offset from origin to target from the given references.
         /// </summary>

src/mscorlib/shared/System/BitConverter.cs

@@ -4,6 +4,8 @@
 
 using System.Diagnostics;
 using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
 using Internal.Runtime.CompilerServices;
 
 namespace System
@@ -37,7 +39,7 @@ public static bool TryWriteBytes(Span<byte> destination, bool value)
             if (destination.Length < sizeof(byte))
                 return false;
 
-            Unsafe.WriteUnaligned(ref destination.DangerousGetPinnableReference(), value ? (byte)1 : (byte)0);
+            Unsafe.WriteUnaligned(ref MemoryMarshal.GetReference(destination), value ? (byte)1 : (byte)0);
             return true;
         }
 
@@ -55,7 +57,7 @@ public static bool TryWriteBytes(Span<byte> destination, char value)
             if (destination.Length < sizeof(char))
                 return false;
 
-            Unsafe.WriteUnaligned(ref destination.DangerousGetPinnableReference(), value);
+            Unsafe.WriteUnaligned(ref MemoryMarshal.GetReference(destination), value);
             return true;
         }
 
@@ -74,7 +76,7 @@ public static bool TryWriteBytes(Span<byte> destination, short value)
             if (destination.Length < sizeof(short))
                 return false;
 
-            Unsafe.WriteUnaligned(ref destination.DangerousGetPinnableReference(), value);
+            Unsafe.WriteUnaligned(ref MemoryMarshal.GetReference(destination), value);
             return true;
         }
 
@@ -93,7 +95,7 @@ public static bool TryWriteBytes(Span<byte> destination, int value)
             if (destination.Length < sizeof(int))
                 return false;
 
-            Unsafe.WriteUnaligned(ref destination.DangerousGetPinnableReference(), value);
+            Unsafe.WriteUnaligned(ref MemoryMarshal.GetReference(destination), value);
             return true;
         }
 
@@ -112,7 +114,7 @@ public static bool TryWriteBytes(Span<byte> destination, long value)
             if (destination.Length < sizeof(long))
                 return false;
 
-            Unsafe.WriteUnaligned(ref destination.DangerousGetPinnableReference(), value);
+            Unsafe.WriteUnaligned(ref MemoryMarshal.GetReference(destination), value);
             return true;
         }
 
@@ -133,7 +135,7 @@ public static bool TryWriteBytes(Span<byte> destination, ushort value)
             if (destination.Length < sizeof(ushort))
                 return false;
 
-            Unsafe.WriteUnaligned(ref destination.DangerousGetPinnableReference(), value);
+            Unsafe.WriteUnaligned(ref MemoryMarshal.GetReference(destination), value);
             return true;
         }
 
@@ -154,7 +156,7 @@ public static bool TryWriteBytes(Span<byte> destination, uint value)
             if (destination.Length < sizeof(uint))
                 return false;
 
-            Unsafe.WriteUnaligned(ref destination.DangerousGetPinnableReference(), value);
+            Unsafe.WriteUnaligned(ref MemoryMarshal.GetReference(destination), value);
             return true;
         }
 
@@ -175,7 +177,7 @@ public static bool TryWriteBytes(Span<byte> destination, ulong value)
             if (destination.Length < sizeof(ulong))
                 return false;
 
-            Unsafe.WriteUnaligned(ref destination.DangerousGetPinnableReference(), value);
+            Unsafe.WriteUnaligned(ref MemoryMarshal.GetReference(destination), value);
             return true;
         }
 
@@ -194,7 +196,7 @@ public static bool TryWriteBytes(Span<byte> destination, float value)
             if (destination.Length < sizeof(float))
                 return false;
 
-            Unsafe.WriteUnaligned(ref destination.DangerousGetPinnableReference(), value);
+            Unsafe.WriteUnaligned(ref MemoryMarshal.GetReference(destination), value);
             return true;
         }
 
@@ -213,7 +215,7 @@ public static bool TryWriteBytes(Span<byte> destination, double value)
             if (destination.Length < sizeof(double))
                 return false;
 
-            Unsafe.WriteUnaligned(ref destination.DangerousGetPinnableReference(), value);
+            Unsafe.WriteUnaligned(ref MemoryMarshal.GetReference(destination), value);
             return true;
         }
 
@@ -225,7 +227,7 @@ public static char ToChar(ReadOnlySpan<byte> value)
         {
             if (value.Length < sizeof(char))
                 ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.value);
-            return Unsafe.ReadUnaligned<char>(ref value.DangerousGetPinnableReference());
+            return Unsafe.ReadUnaligned<char>(ref Unsafe.AsRef(in MemoryMarshal.GetReference(value)));
         }
 
         // Converts an array of bytes into a short.  
@@ -246,7 +248,7 @@ public static short ToInt16(ReadOnlySpan<byte> value)
         {
             if (value.Length < sizeof(short))
                 ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.value);
-            return Unsafe.ReadUnaligned<short>(ref value.DangerousGetPinnableReference());
+            return Unsafe.ReadUnaligned<short>(ref Unsafe.AsRef(in MemoryMarshal.GetReference(value)));
         }
 
         // Converts an array of bytes into an int.  
@@ -267,7 +269,7 @@ public static int ToInt32(ReadOnlySpan<byte> value)
         {
             if (value.Length < sizeof(int))
                 ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.value);
-            return Unsafe.ReadUnaligned<int>(ref value.DangerousGetPinnableReference());
+            return Unsafe.ReadUnaligned<int>(ref Unsafe.AsRef(in MemoryMarshal.GetReference(value)));
         }
 
         // Converts an array of bytes into a long.  
@@ -288,7 +290,7 @@ public static long ToInt64(ReadOnlySpan<byte> value)
         {
             if (value.Length < sizeof(long))
                 ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.value);
-            return Unsafe.ReadUnaligned<long>(ref value.DangerousGetPinnableReference());
+            return Unsafe.ReadUnaligned<long>(ref Unsafe.AsRef(in MemoryMarshal.GetReference(value)));
         }
 
         // Converts an array of bytes into an ushort.
@@ -302,7 +304,7 @@ public static ushort ToUInt16(ReadOnlySpan<byte> value)
         {
             if (value.Length < sizeof(ushort))
                 ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.value);
-            return Unsafe.ReadUnaligned<ushort>(ref value.DangerousGetPinnableReference());
+            return Unsafe.ReadUnaligned<ushort>(ref Unsafe.AsRef(in MemoryMarshal.GetReference(value)));
         }
 
         // Converts an array of bytes into an uint.
@@ -316,7 +318,7 @@ public static uint ToUInt32(ReadOnlySpan<byte> value)
         {
             if (value.Length < sizeof(uint))
                 ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.value);
-            return Unsafe.ReadUnaligned<uint>(ref value.DangerousGetPinnableReference());
+            return Unsafe.ReadUnaligned<uint>(ref Unsafe.AsRef(in MemoryMarshal.GetReference(value)));
         }
 
         // Converts an array of bytes into an unsigned long.
@@ -330,7 +332,7 @@ public static ulong ToUInt64(ReadOnlySpan<byte> value)
         {
             if (value.Length < sizeof(ulong))
                 ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.value);
-            return Unsafe.ReadUnaligned<ulong>(ref value.DangerousGetPinnableReference());
+            return Unsafe.ReadUnaligned<ulong>(ref Unsafe.AsRef(in MemoryMarshal.GetReference(value)));
         }
 
         // Converts an array of bytes into a float.  
@@ -341,7 +343,7 @@ public static float ToSingle(ReadOnlySpan<byte> value)
         {
             if (value.Length < sizeof(float))
                 ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.value);
-            return Unsafe.ReadUnaligned<float>(ref value.DangerousGetPinnableReference());
+            return Unsafe.ReadUnaligned<float>(ref Unsafe.AsRef(in MemoryMarshal.GetReference(value)));
         }
 
         // Converts an array of bytes into a double.  
@@ -352,7 +354,7 @@ public static double ToDouble(ReadOnlySpan<byte> value)
         {
             if (value.Length < sizeof(double))
                 ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.value);
-            return Unsafe.ReadUnaligned<double>(ref value.DangerousGetPinnableReference());
+            return Unsafe.ReadUnaligned<double>(ref Unsafe.AsRef(in MemoryMarshal.GetReference(value)));
         }
 
         // Converts an array of bytes into a String.  
@@ -442,7 +444,7 @@ public static bool ToBoolean(ReadOnlySpan<byte> value)
         {
             if (value.Length < sizeof(byte))
                 ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.value);
-            return Unsafe.ReadUnaligned<byte>(ref value.DangerousGetPinnableReference()) != 0;
+            return Unsafe.ReadUnaligned<byte>(ref Unsafe.AsRef(in MemoryMarshal.GetReference(value))) != 0;
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]

src/mscorlib/shared/System/Convert.cs

@@ -2434,7 +2434,7 @@ public static string ToBase64String(ReadOnlySpan<byte> bytes, Base64FormattingOp
 
             unsafe
             {
-                fixed (byte* bytesPtr = &bytes.DangerousGetPinnableReference())
+                fixed (byte* bytesPtr = &MemoryMarshal.GetReference(bytes))
                 fixed (char* charsPtr = result)
                 {
                     int charsWritten = ConvertToBase64Array(charsPtr, bytesPtr, 0, bytes.Length, insertLineBreaks);
@@ -2527,8 +2527,8 @@ public static unsafe bool TryToBase64Chars(ReadOnlySpan<byte> bytes, Span<char>
                 return false;
             }
 
-            fixed (char* outChars = &chars.DangerousGetPinnableReference())
-            fixed (byte* inData = &bytes.DangerousGetPinnableReference())
+            fixed (char* outChars = &MemoryMarshal.GetReference(chars))
+            fixed (byte* inData = &MemoryMarshal.GetReference(bytes))
             {
                 charsWritten = ConvertToBase64Array(outChars, inData, 0, bytes.Length, insertLineBreaks);
                 return true;
@@ -2676,7 +2676,7 @@ public static unsafe bool TryFromBase64Chars(ReadOnlySpan<char> chars, Span<byte
                 chars = chars.Slice(0, chars.Length - 1);
             }
 
-            fixed (char* charsPtr = &chars.DangerousGetPinnableReference())
+            fixed (char* charsPtr = &MemoryMarshal.GetReference(chars))
             {
                 int resultLength = FromBase64_ComputeResultLength(charsPtr, chars.Length);
                 Debug.Assert(resultLength >= 0);
@@ -2686,7 +2686,7 @@ public static unsafe bool TryFromBase64Chars(ReadOnlySpan<char> chars, Span<byte
                     return false;
                 }
 
-                fixed (byte* bytesPtr = &bytes.DangerousGetPinnableReference())
+                fixed (byte* bytesPtr = &MemoryMarshal.GetReference(bytes))
                 {
                     bytesWritten = FromBase64_Decode(charsPtr, chars.Length, bytesPtr, bytes.Length);
                     return true;

src/mscorlib/shared/System/Globalization/CompareInfo.cs

@@ -14,6 +14,7 @@
 
 using System.Reflection;
 using System.Diagnostics;
+using System.Runtime.InteropServices;
 using System.Runtime.Serialization;
 
 namespace System.Globalization
@@ -555,8 +556,8 @@ internal static unsafe int CompareOrdinalIgnoreCase(ReadOnlySpan<char> strA, Rea
             int length = Math.Min(strA.Length, strB.Length);
             int range = length;
 
-            fixed (char* ap = &strA.DangerousGetPinnableReference())
-            fixed (char* bp = &strB.DangerousGetPinnableReference())
+            fixed (char* ap = &MemoryMarshal.GetReference(strA))
+            fixed (char* bp = &MemoryMarshal.GetReference(strB))
             {
                 char* a = ap;
                 char* b = bp;

src/mscorlib/shared/System/Guid.cs

@@ -5,6 +5,7 @@
 using System.Diagnostics;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
+
 using Internal.Runtime.CompilerServices;
 
 namespace System
@@ -1361,7 +1362,7 @@ public bool TryFormat(Span<char> destination, out int charsWritten, ReadOnlySpan
 
             unsafe
             {
-                fixed (char* guidChars = &destination.DangerousGetPinnableReference())
+                fixed (char* guidChars = &MemoryMarshal.GetReference(destination))
                 {
                     char * p = guidChars;
 

src/mscorlib/shared/System/IO/FileStream.Unix.cs

@@ -4,6 +4,7 @@
 
 using Microsoft.Win32.SafeHandles;
 using System.Diagnostics;
+using System.Runtime.InteropServices;
 using System.Threading;
 using System.Threading.Tasks;
 
@@ -459,7 +460,7 @@ private unsafe int ReadNative(Span<byte> buffer)
             VerifyOSHandlePosition();
 
             int bytesRead;
-            fixed (byte* bufPtr = &buffer.DangerousGetPinnableReference())
+            fixed (byte* bufPtr = &MemoryMarshal.GetReference(buffer))
             {
                 bytesRead = CheckFileCall(Interop.Sys.Read(_fileHandle, bufPtr, buffer.Length));
                 Debug.Assert(bytesRead <= buffer.Length);
@@ -612,7 +613,7 @@ private unsafe void WriteNative(ReadOnlySpan<byte> source)
         {
             VerifyOSHandlePosition();
 
-            fixed (byte* bufPtr = &source.DangerousGetPinnableReference())
+            fixed (byte* bufPtr = &MemoryMarshal.GetReference(source))
             {
                 int offset = 0;
                 int count = source.Length;

src/mscorlib/shared/System/IO/FileStream.Windows.cs

@@ -1069,7 +1069,7 @@ private unsafe Task WriteAsyncInternalCore(ReadOnlyMemory<byte> source, Cancella
             Debug.Assert(_useAsyncIO, "WriteInternalCoreAsync doesn't work on synchronous file streams!");
 
             // Create and store async stream class library specific data in the async result
-            FileStreamCompletionSource completionSource = source.DangerousTryGetArray(out ArraySegment<byte> array) ?
+            FileStreamCompletionSource completionSource = MemoryMarshal.TryGetArray(source, out ArraySegment<byte> array) ?
                 new FileStreamCompletionSource(this, 0, array.Array) :
                 new MemoryFileStreamCompletionSource(this, 0, source);
             NativeOverlapped* intOverlapped = completionSource.Overlapped;
@@ -1188,7 +1188,7 @@ private unsafe int ReadFileNative(SafeFileHandle handle, Span<byte> bytes, Nativ
             int r;
             int numBytesRead = 0;
 
-            fixed (byte* p = &bytes.DangerousGetPinnableReference())
+            fixed (byte* p = &MemoryMarshal.GetReference(bytes))
             {
                 r = _useAsyncIO ?
                     Interop.Kernel32.ReadFile(handle, p, bytes.Length, IntPtr.Zero, overlapped) :
@@ -1215,7 +1215,7 @@ private unsafe int WriteFileNative(SafeFileHandle handle, ReadOnlySpan<byte> buf
             int numBytesWritten = 0;
             int r;
 
-            fixed (byte* p = &buffer.DangerousGetPinnableReference())
+            fixed (byte* p = &MemoryMarshal.GetReference(buffer))
             {
                 r = _useAsyncIO ?
                     Interop.Kernel32.WriteFile(handle, p, buffer.Length, IntPtr.Zero, overlapped) :

src/mscorlib/shared/System/IO/FileStreamCompletionSource.Win32.cs

@@ -231,7 +231,7 @@ private sealed class MemoryFileStreamCompletionSource : FileStreamCompletionSour
             internal MemoryFileStreamCompletionSource(FileStream stream, int numBufferedBytes, ReadOnlyMemory<byte> memory) :
                 base(stream, numBufferedBytes, bytes: null) // this type handles the pinning, so null is passed for bytes
             {
-                Debug.Assert(!memory.DangerousTryGetArray(out ArraySegment<byte> array), "The base should be used directly if we can get the array.");
+                Debug.Assert(!MemoryMarshal.TryGetArray(memory, out ArraySegment<byte> array), "The base should be used directly if we can get the array.");
                 _handle = memory.Retain(pin: true);
             }
 

src/mscorlib/shared/System/IO/MemoryStream.cs

@@ -4,6 +4,7 @@
 
 using System.Diagnostics;
 using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
 using System.Threading;
 using System.Threading.Tasks;
 
@@ -762,7 +763,7 @@ public override Task WriteAsync(Byte[] buffer, int offset, int count, Cancellati
             {
                 // See corresponding comment in ReadAsync for why we don't just always use Write(ReadOnlySpan<byte>).
                 // Unlike ReadAsync, we could delegate to WriteAsync(byte[], ...) here, but we don't for consistency.
-                if (source.DangerousTryGetArray(out ArraySegment<byte> sourceArray))
+                if (MemoryMarshal.TryGetArray(source, out ArraySegment<byte> sourceArray))
                 {
                     Write(sourceArray.Array, sourceArray.Offset, sourceArray.Count);
                 }

src/mscorlib/shared/System/IO/UnmanagedMemoryStream.cs

@@ -418,7 +418,7 @@ internal int ReadCore(Span<byte> destination)
 
             unsafe
             {
-                fixed (byte* pBuffer = &destination.DangerousGetPinnableReference())
+                fixed (byte* pBuffer = &MemoryMarshal.GetReference(destination))
                 {
                     if (_buffer != null)
                     {
@@ -709,7 +709,7 @@ internal unsafe void WriteCore(ReadOnlySpan<byte> source)
                 }
             }
 
-            fixed (byte* pBuffer = &source.DangerousGetPinnableReference())
+            fixed (byte* pBuffer = &MemoryMarshal.GetReference(source))
             {
                 if (_buffer != null)
                 {
@@ -794,7 +794,7 @@ public override Task WriteAsync(Byte[] buffer, Int32 offset, Int32 count, Cancel
             {
                 // See corresponding comment in ReadAsync for why we don't just always use Write(ReadOnlySpan<byte>).
                 // Unlike ReadAsync, we could delegate to WriteAsync(byte[], ...) here, but we don't for consistency.
-                if (source.DangerousTryGetArray(out ArraySegment<byte> sourceArray))
+                if (MemoryMarshal.TryGetArray(source, out ArraySegment<byte> sourceArray))
                 {
                     Write(sourceArray.Array, sourceArray.Offset, sourceArray.Count);
                 }