Adding {RO}Memory<T> debugger view (dotnet/coreclr#14130)

* Adding memory debugger view and fixing ToArray impl.

* Addressing PR feedback and adding span debugger display string.

* Adding link to specific VSTS instance.

* Removing redundant info in comments.

Signed-off-by: dotnet-bot-corefx-mirror <dotnet-bot@microsoft.com>

Author: ahsonkhan

src/Common/src/CoreLib/System.Private.CoreLib.Shared.projitems

@@ -203,6 +203,7 @@
     <Compile Include="$(MSBuildThisFileDirectory)System\MarshalByRefObject.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\MemberAccessException.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\Memory.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)System\MemoryDebugView.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\MethodAccessException.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\MidpointRounding.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\MissingMethodException.cs" />

src/Common/src/CoreLib/System/Memory.cs

@@ -12,6 +12,8 @@
 
 namespace System
 {
+    [DebuggerDisplay("{DebuggerDisplay,nq}")]
+    [DebuggerTypeProxy(typeof(MemoryDebugView<>))]
     public struct Memory<T>
     {
         // The highest order bit of _index is used to discern whether _arrayOrOwnedMemory is an array or an owned memory
@@ -106,6 +108,9 @@ public static implicit operator ReadOnlyMemory<T>(Memory<T> memory)
             return new ReadOnlyMemory<T>((T[])memory._arrayOrOwnedMemory, memory._index, memory._length);
         }
 
+        //Debugger Display = {T[length]}
+        private string DebuggerDisplay => string.Format("{{{0}[{1}]}}", typeof(T).Name, _length);
+
         /// <summary>
         /// Returns an empty <see cref="Memory{T}"/>
         /// </summary>
@@ -281,4 +286,4 @@ private static int CombineHashCodes(int h1, int h2, int h3)
         }
 
     }
-}
+}

src/Common/src/CoreLib/System/MemoryDebugView.cs

@@ -0,0 +1,40 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.Diagnostics;
+
+namespace System
+{
+    internal sealed class MemoryDebugView<T>
+    {
+        private readonly ReadOnlyMemory<T> _memory;
+
+        public MemoryDebugView(Memory<T> memory)
+        {
+            _memory = memory;
+        }
+
+        public MemoryDebugView(ReadOnlyMemory<T> memory)
+        {
+            _memory = memory;
+        }
+
+        [DebuggerBrowsable(DebuggerBrowsableState.RootHidden)]
+        public T[] Items
+        {
+            // This is a work around since we cannot use _memory.ToArray() due to
+            // https://devdiv.visualstudio.com/DevDiv/_workitems?id=286592
+            get
+            {
+                if (_memory.DangerousTryGetArray(out ArraySegment<T> segment))
+                {
+                    T[] array = new T[_memory.Length];
+                    Array.Copy(segment.Array, segment.Offset, array, 0, array.Length);
+                    return array;
+                }
+                return Array.Empty<T>();
+            }
+        }
+    }
+}

src/Common/src/CoreLib/System/ReadOnlyMemory.cs

@@ -12,6 +12,8 @@
 
 namespace System
 {
+    [DebuggerDisplay("{DebuggerDisplay,nq}")]
+    [DebuggerTypeProxy(typeof(MemoryDebugView<>))]
     public struct ReadOnlyMemory<T>
     {
         // The highest order bit of _index is used to discern whether _arrayOrOwnedMemory is an array or an owned memory
@@ -81,6 +83,9 @@ internal ReadOnlyMemory(OwnedMemory<T> owner, int index, int length)
             _length = length;
         }
 
+        //Debugger Display = {T[length]}
+        private string DebuggerDisplay => string.Format("{{{0}[{1}]}}", typeof(T).Name, _length);
+
         /// <summary>
         /// Defines an implicit conversion of an array to a <see cref="Memory{T}"/>
         /// </summary>

src/Common/src/CoreLib/System/ReadOnlySpan.cs

@@ -15,6 +15,7 @@ namespace System
     /// ReadOnlySpan represents a contiguous region of arbitrary memory. Unlike arrays, it can point to either managed
     /// or native memory, or to memory allocated on the stack. It is type- and memory-safe.
     /// </summary>
+    [DebuggerDisplay("{DebuggerDisplay,nq}")]
     [IsReadOnly]
     [IsByRefLike]
     [NonVersionable]
@@ -118,6 +119,9 @@ internal ReadOnlySpan(ref T ptr, int length)
             _length = length;
         }
 
+        //Debugger Display = {T[length]}
+        private string DebuggerDisplay => string.Format("{{{0}[{1}]}}", typeof(T).Name, _length);
+
         /// <summary>
         /// Returns a reference to the 0th element of the Span. If the Span is empty, returns a reference to the location where the 0th element
         /// would have been stored. Such a reference can be used for pinning but must never be dereferenced.

src/Common/src/CoreLib/System/Span.cs

@@ -21,6 +21,7 @@ namespace System
     /// Span represents a contiguous region of arbitrary memory. Unlike arrays, it can point to either managed
     /// or native memory, or to memory allocated on the stack. It is type- and memory-safe.
     /// </summary>
+    [DebuggerDisplay("{DebuggerDisplay,nq}")]
     [IsReadOnly]
     [IsByRefLike]
     [NonVersionable]
@@ -130,6 +131,9 @@ internal Span(ref T ptr, int length)
             _length = length;
         }
 
+        //Debugger Display = {T[length]}
+        private string DebuggerDisplay => string.Format("{{{0}[{1}]}}", typeof(T).Name, _length);
+
         /// <summary>
         /// Returns a reference to the 0th element of the Span. If the Span is empty, returns a reference to the location where the 0th element
         /// would have been stored. Such a reference can be used for pinning but must never be dereferenced.