Replace Memory<char> with string

Author: RobertMut

src/ImageSharp/Formats/Jpeg/JpegDecoderCore.cs

@@ -524,13 +524,12 @@ public void Dispose()
     private void ProcessComMarker(BufferedReadStream stream, int markerContentByteSize)
     {
         Span<byte> temp = new byte[markerContentByteSize];
-        char[] chars = new char[markerContentByteSize];
         JpegMetadata metadata = this.Metadata.GetFormatMetadata(JpegFormat.Instance);
 
         stream.Read(temp);
-        Encoding.ASCII.GetChars(temp, chars);
+        string comment = Encoding.ASCII.GetString(temp);
 
-        metadata.Comments.Add(chars);
+        metadata.Comments.Add(comment);
     }
 
     /// <summary>

src/ImageSharp/Formats/Jpeg/JpegEncoderCore.cs

@@ -186,23 +186,23 @@ private void WriteComment(JpegMetadata metadata)
 
         for (int i = 0; i < metadata.Comments.Count; i++)
         {
-            Memory<char> chars = metadata.Comments[i];
+            string comment = metadata.Comments[i];
 
-            if (chars.Length > maxCommentLength)
+            if (comment.Length > maxCommentLength)
             {
-                Memory<char> splitComment = chars.Slice(maxCommentLength, chars.Length - maxCommentLength);
+                string splitComment = comment.Substring(maxCommentLength, comment.Length - maxCommentLength);
                 metadata.Comments.Insert(i + 1, splitComment);
 
                 // We don't want to keep the extra bytes
-                chars = chars.Slice(0, maxCommentLength);
+                comment = comment.Substring(0, maxCommentLength);
             }
 
-            int commentLength = chars.Length + 4;
+            int commentLength = comment.Length + 4;
 
-            Span<byte> comment = new byte[commentLength];
-            Span<byte> markers = comment.Slice(0, 2);
-            Span<byte> payloadSize = comment.Slice(2, 2);
-            Span<byte> payload = comment.Slice(4, chars.Length);
+            Span<byte> commentSpan = new byte[commentLength];
+            Span<byte> markers = commentSpan.Slice(0, 2);
+            Span<byte> payloadSize = commentSpan.Slice(2, 2);
+            Span<byte> payload = commentSpan.Slice(4, comment.Length);
 
             // Beginning of comment ff fe
             markers[0] = JpegConstants.Markers.XFF;
@@ -213,9 +213,9 @@ private void WriteComment(JpegMetadata metadata)
             payloadSize[0] = (byte)((comWithoutMarker >> 8) & 0xFF);
             payloadSize[1] = (byte)(comWithoutMarker & 0xFF);
 
-            Encoding.ASCII.GetBytes(chars.Span, payload);
+            Encoding.ASCII.GetBytes(comment, payload);
 
-            this.outputStream.Write(comment, 0, comment.Length);
+            this.outputStream.Write(commentSpan, 0, commentSpan.Length);
         }
     }
 

src/ImageSharp/Formats/Jpeg/JpegMetadata.cs

@@ -15,7 +15,7 @@ public class JpegMetadata : IDeepCloneable
     /// </summary>
     public JpegMetadata()
     {
-        this.Comments = new List<Memory<char>>();
+        this.Comments = new List<string>();
     }
 
     /// <summary>
@@ -106,7 +106,7 @@ public int Quality
     /// <summary>
     /// Gets the comments.
     /// </summary>
-    public IList<Memory<char>> Comments { get; }
+    public IList<string> Comments { get; }
 
     /// <inheritdoc/>
     public IDeepCloneable DeepClone() => new JpegMetadata(this);

tests/ImageSharp.Tests/Formats/Jpg/JpegDecoderTests.Metadata.cs

@@ -435,7 +435,7 @@ public void JpegDecoder_DecodeMetadataComment<TPixel>(TestImageProvider<TPixel>
         JpegMetadata metadata = image.Metadata.GetJpegMetadata();
 
         Assert.Equal(1, metadata.Comments.Count);
-        Assert.Equal(expectedComment.ToCharArray(), metadata.Comments.ElementAtOrDefault(0));
+        Assert.Equal(expectedComment, metadata.Comments.ElementAtOrDefault(0));
         image.DebugSave(provider);
         image.CompareToOriginal(provider);
     }

tests/ImageSharp.Tests/Formats/Jpg/JpegEncoderTests.Metadata.cs

@@ -172,7 +172,7 @@ public void Encode_PreservesComments<TPixel>(TestImageProvider<TPixel> provider)
         JpegMetadata actual = output.Metadata.GetJpegMetadata();
         Assert.NotEmpty(actual.Comments);
         Assert.Equal(1, actual.Comments.Count);
-        Assert.Equal("TEST COMMENT", actual.Comments.ElementAtOrDefault(0).ToString());
+        Assert.Equal("TEST COMMENT", actual.Comments.ElementAtOrDefault(0));
     }
 
     [Fact]
@@ -184,8 +184,8 @@ public void Encode_SavesMultipleComments()
         using var memStream = new MemoryStream();
 
         // act
-        meta.Comments.Add("First comment".ToCharArray());
-        meta.Comments.Add("Second Comment".ToCharArray());
+        meta.Comments.Add("First comment");
+        meta.Comments.Add("Second Comment");
         input.Save(memStream, JpegEncoder);
 
         // assert
@@ -194,8 +194,8 @@ public void Encode_SavesMultipleComments()
         JpegMetadata actual = output.Metadata.GetJpegMetadata();
         Assert.NotEmpty(actual.Comments);
         Assert.Equal(2, actual.Comments.Count);
-        Assert.Equal(meta.Comments.ElementAtOrDefault(0).ToString(), actual.Comments.ElementAtOrDefault(0).ToString());
-        Assert.Equal(meta.Comments.ElementAtOrDefault(1).ToString(), actual.Comments.ElementAtOrDefault(1).ToString());
+        Assert.Equal(meta.Comments.ElementAtOrDefault(0), actual.Comments.ElementAtOrDefault(0));
+        Assert.Equal(meta.Comments.ElementAtOrDefault(1), actual.Comments.ElementAtOrDefault(1));
     }
 
     [Theory]

tests/ImageSharp.Tests/Formats/Jpg/JpegMetadataTests.cs

@@ -64,19 +64,19 @@ public void Comment_EmptyComment()
     {
         var meta = new JpegMetadata();
 
-        Assert.True(Array.Empty<Memory<char>>().SequenceEqual(meta.Comments));
+        Assert.True(Array.Empty<string>().SequenceEqual(meta.Comments));
     }
 
     [Fact]
     public void Comment_OnlyComment()
     {
         string comment = "test comment";
-        var expectedCollection = new Collection<Memory<char>> { new(comment.ToCharArray()) };
+        var expectedCollection = new Collection<string> { comment };
 
         var meta = new JpegMetadata();
-        meta.Comments?.Add(comment.ToCharArray());
+        meta.Comments.Add(comment);
 
-        Assert.Equal(1, meta.Comments?.Count);
-        Assert.True(expectedCollection.FirstOrDefault().ToString() == meta.Comments?.FirstOrDefault().ToString());
+        Assert.Equal(1, meta.Comments.Count);
+        Assert.True(expectedCollection.FirstOrDefault() == meta.Comments.FirstOrDefault());
     }
 }