Add InplaceStringBuilder

src/Microsoft.Extensions.Primitives/InplaceStringBuilder.cs

@@ -0,0 +1,90 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+using System;
+using System.Runtime.CompilerServices;
+
+namespace Microsoft.Extensions.Primitives
+{
+    public struct InplaceStringBuilder
+    {
+        private int _length;
+        private int _offset;
+        private bool _writing;
+        private string _value;
+
+        public InplaceStringBuilder(int length) : this()
+        {
+            _length = length;
+        }
+
+        public void IncrementLength(string s)
+        {
+            IncrementLength(s.Length);
+        }
+
+        public void IncrementLength(char c)
+        {
+            IncrementLength(1);
+        }
+
+        public void IncrementLength(int length)
+        {
+            if (_writing)
+            {
+                throw new InvalidOperationException("Cannot append lenght after write started.");
+            }
+            _length += length;
+        }
+
+        public unsafe void Append(string s)
+        {
+            EnsureValue(s.Length);
+            fixed (char* value = _value)
+            fixed (char* pDomainToken = s)
+            {
+                //TODO: Use CopyBlockUnaligned when added https://github.com/dotnet/corefx/issues/12243
+                Unsafe.CopyBlock(value + _offset, pDomainToken, (uint)s.Length * 2);
+                _offset += s.Length;
+            }
+        }
+        public unsafe void Append(char c)
+        {
+            EnsureValue(1);
+            fixed (char* value = _value)
+            {
+                value[_offset++] = c;
+            }
+        }
+
+        private void EnsureValue(int length)
+        {
+            if (_value == null)
+            {
+                _writing = true;
+                _value = new string('\0', _length);
+            }
+            if (_offset + length > _length)
+            {
+                throw new InvalidOperationException($"Not enough space to write '{length}' characters, only '{_length - _offset}' left.");
+            }
+        }
+
+        // Debugger calls ToString so this method should be used to get formatted value
+        public string Build()
+        {
+            if (_offset != _length)
+            {
+                throw new InvalidOperationException($"Entire reserved lenght was not used. Length: '{_length}', written '{_offset}'.");
+            }
+            return _value;
+        }
+
+        public override string ToString()
+        {
+            // Clone string so we won't be modifying returned string if called before
+            // whole value was written
+            return new string(_value.ToCharArray());
+        }
+    }
+}

src/Microsoft.Extensions.Primitives/project.json

@@ -16,13 +16,15 @@
     "nowarn": [
       "CS1591"
     ],
-    "xmlDoc": true
+    "xmlDoc": true,
+    "allowUnsafe": true
   },
   "dependencies": {
     "Microsoft.Extensions.HashCodeCombiner.Sources": {
       "type": "build",
       "version": "1.1.0-*"
-    }
+    },
+    "System.Runtime.CompilerServices.Unsafe": "4.0.0"
   },
   "frameworks": {
     "netstandard1.0": {

test/Microsoft.Extensions.Primitives.Tests/InplaceStringBuilderTest.cs

@@ -0,0 +1,76 @@
+using System;
+using Microsoft.Extensions.Primitives;
+using Xunit;
+
+namespace Microsoft.AspNetCore.Http.Tests.Internal
+{
+    public class InplaceStringBuilderTest
+    {
+        [Fact]
+        public void ToString_ReturnsStringWithAllAppendedValues()
+        {
+            var s1 = "123";
+            var c1 = '4';
+            var s2 = "56789";
+
+            var formatter = new InplaceStringBuilder();
+            formatter.IncrementLength(s1);
+            formatter.IncrementLength(c1);
+            formatter.IncrementLength(s2);
+            formatter.Append(s1);
+            formatter.Append(c1);
+            formatter.Append(s2);
+            Assert.Equal("123456789", formatter.Build());
+        }
+
+        [Fact]
+        public void Build_ThrowsIfNotEnoughWritten()
+        {
+            var formatter = new InplaceStringBuilder(5);
+            formatter.Append("123");
+            var exception = Assert.Throws<InvalidOperationException>(() => formatter.Build());
+            Assert.Equal(exception.Message, "Entire reserved lenght was not used. Length: '5', written '3'.");
+        }
+
+        [Fact]
+        public void AppendLength_IfAppendWasCalled()
+        {
+            var formatter = new InplaceStringBuilder(3);
+            formatter.Append("123");
+
+            var exception = Assert.Throws<InvalidOperationException>(() => formatter.IncrementLength(1));
+            Assert.Equal(exception.Message, "Cannot append lenght after write started.");
+        }
+
+        [Fact]
+        public void Append_ThrowsIfNotEnoughSpace()
+        {
+            var formatter = new InplaceStringBuilder(1);
+
+            var exception = Assert.Throws<InvalidOperationException>(() => formatter.Append("123"));
+            Assert.Equal(exception.Message, "Not enough space to write '3' characters, only '1' left.");
+        }
+
+        [Fact]
+        public void ToString_ReturnsPartialyFormatedValue()
+        {
+            var formatter = new InplaceStringBuilder(5);
+            formatter.Append("123");
+
+            Assert.Equal("123\0\0", formatter.ToString());
+        }
+
+        [Fact]
+        public void ToString_ReturnedValueIsNotModified()
+        {
+            var formatter = new InplaceStringBuilder(5);
+            formatter.Append("123");
+
+            var s = formatter.ToString();
+            Assert.Equal("123\0\0", s);
+
+            formatter.Append("45");
+            Assert.Equal("123\0\0", s);
+        }
+    }
+}