public ResponseWriter(HttpContext httpContext, IOutputFormatter outputFormatter)
        {
            _httpContext     = httpContext;
            _outputFormatter = outputFormatter;

            IArraySegmentPool <byte>         byteSegmentPool = new DefaultArraySegmentPool <byte>();
            IArraySegmentPool <char>         charSegmentPool = new DefaultArraySegmentPool <char>();
            IHttpResponseStreamWriterFactory writerFactory   = new MemoryPoolHttpResponseStreamWriterFactory(byteSegmentPool, charSegmentPool);

            _responseWriterFactory = writerFactory.CreateWriter;
        }
Пример #2
0
        public void HttpResponseStreamWriter_UsingPooledBuffers()
        {
            // Arrange
            var encoding = Encoding.UTF8;
            var stream   = new MemoryStream();

            var expectedBytes = encoding.GetBytes("Hello, World!");

            using (var bytePool = new DefaultArraySegmentPool <byte>())
            {
                using (var charPool = new DefaultArraySegmentPool <char>())
                {
                    LeasedArraySegment <byte> bytes = null;
                    LeasedArraySegment <char> chars = null;
                    HttpResponseStreamWriter  writer;

                    try
                    {
                        bytes = bytePool.Lease(4096);
                        chars = charPool.Lease(1024);

                        writer = new HttpResponseStreamWriter(stream, encoding, 1024, bytes, chars);
                    }
                    catch
                    {
                        if (bytes != null)
                        {
                            bytes.Owner.Return(bytes);
                        }

                        if (chars != null)
                        {
                            chars.Owner.Return(chars);
                        }

                        throw;
                    }

                    // Act
                    using (writer)
                    {
                        writer.Write("Hello, World!");
                    }
                }
            }

            // Assert
            Assert.Equal(expectedBytes, stream.ToArray());
        }
Пример #3
0
        public void HttpResponseStreamWriter_UsingPooledBuffers_SmallByteBuffer()
        {
            // Arrange
            var encoding = Encoding.UTF8;
            var stream   = new MemoryStream();

            var message =
                "The byte buffer must have a length of at least '12291' to be used with a char buffer of " +
                "size '4096' and encoding 'Unicode (UTF-8)'. Use 'System.Text.Encoding.GetMaxByteCount' " +
                "to compute the correct size for the byte buffer.";

            using (var bytePool = new DefaultArraySegmentPool <byte>())
            {
                using (var charPool = new DefaultArraySegmentPool <char>())
                {
                    LeasedArraySegment <byte> bytes  = null;
                    LeasedArraySegment <char> chars  = null;
                    HttpResponseStreamWriter  writer = null;

                    try
                    {
                        bytes = bytePool.Lease(1024);
                        chars = charPool.Lease(4096);

                        // Act & Assert
                        ExceptionAssert.ThrowsArgument(
                            () => writer = new HttpResponseStreamWriter(stream, encoding, chars.Data.Count, bytes, chars),
                            "byteBuffer",
                            message);
                        writer.Dispose();
                    }
                    catch
                    {
                        if (bytes != null)
                        {
                            bytes.Owner.Return(bytes);
                        }

                        if (chars != null)
                        {
                            chars.Owner.Return(chars);
                        }
                    }
                }
            }
        }
        public void Dispose_Disposes_CachedSegments()
        {
            // Arrange
            for (var i = 0; i < DefaultArraySegmentPool<object>.Capacity; i++)
            {
                Pool.Return(Lease(DefaultArraySegmentPool<object>.BlockSize));
            }

            foreach (var segment in CreatedSegments)
            {
                Pool.Return(segment);
            }

            // Act
            Pool.Dispose();
            Pool = null;

            // Assert
            foreach (var segment in CreatedSegments)
            {
                Assert.Null(segment.Data.Array);
                Assert.Null(segment.Owner);
            }
        }
        public void Return_ToDisposedPool_IsNotCached()
        {
            // Arrange
            var segment = Lease(DefaultArraySegmentPool<object>.BlockSize);

            Pool.Dispose();

            // Act
            Pool.Return(segment);
            Pool = null;

            // Assert
            Assert.Null(segment.Data.Array);
            Assert.Null(segment.Owner);
        }
 public DefaultArraySegmentPoolTest()
 {
     Pool = new DefaultArraySegmentPool<object>();
     CreatedSegments = new List<LeasedArraySegment<object>>();
 }
        public void HttpResponseStreamWriter_UsingPooledBuffers_SmallByteBuffer()
        {
            // Arrange
            var encoding = Encoding.UTF8;
            var stream = new MemoryStream();

            var message =
                "The byte buffer must have a length of at least '12291' to be used with a char buffer of " +
                "size '4096' and encoding 'Unicode (UTF-8)'. Use 'System.Text.Encoding.GetMaxByteCount' " +
                "to compute the correct size for the byte buffer.";

            using (var bytePool = new DefaultArraySegmentPool<byte>())
            {
                using (var charPool = new DefaultArraySegmentPool<char>())
                {
                    LeasedArraySegment<byte> bytes = null;
                    LeasedArraySegment<char> chars = null;
                    HttpResponseStreamWriter writer = null;

                    try
                    {
                        bytes = bytePool.Lease(1024);
                        chars = charPool.Lease(4096);

                        // Act & Assert
                        ExceptionAssert.ThrowsArgument(
                            () => writer = new HttpResponseStreamWriter(stream, encoding, chars.Data.Count, bytes, chars),
                            "byteBuffer",
                            message);
                        writer.Dispose();
                    }
                    catch
                    {
                        if (bytes != null)
                        {
                            bytes.Owner.Return(bytes);
                        }

                        if (chars != null)
                        {
                            chars.Owner.Return(chars);
                        }
                    }
                }
            }
        }
        public void HttpResponseStreamWriter_UsingPooledBuffers()
        {
            // Arrange
            var encoding = Encoding.UTF8;
            var stream = new MemoryStream();

            var expectedBytes = encoding.GetBytes("Hello, World!");

            using (var bytePool = new DefaultArraySegmentPool<byte>())
            {
                using (var charPool = new DefaultArraySegmentPool<char>())
                {
                    LeasedArraySegment<byte> bytes = null;
                    LeasedArraySegment<char> chars = null;
                    HttpResponseStreamWriter writer;

                    try
                    {
                        bytes = bytePool.Lease(4096);
                        chars = charPool.Lease(1024);

                        writer = new HttpResponseStreamWriter(stream, encoding, 1024, bytes, chars);
                    }
                    catch
                    {
                        if (bytes != null)
                        {
                            bytes.Owner.Return(bytes);
                        }

                        if (chars != null)
                        {
                            chars.Owner.Return(chars);
                        }

                        throw;
                    }

                    // Act
                    using (writer)
                    {
                        writer.Write("Hello, World!");
                    }
                }
            }

            // Assert
            Assert.Equal(expectedBytes, stream.ToArray());
        }