Ejemplo n.º 1
0
        public static byte[] ToArray(this Stream stream)
        {
            var bufferOwner = BufferArrayPool <byte> .Rent(1024 * 16);

            var buffer    = bufferOwner.AsSpan();
            var totalRead = 0;
            int read;

            try
            {
                while ((read = stream.Read(buffer.Slice(totalRead, buffer.Length - totalRead))) > 0)
                {
                    totalRead += read;
                    if (totalRead == buffer.Length)
                    {
                        BufferArrayPool <byte> .Grow(ref bufferOwner, bufferOwner.Length * 2);

                        buffer = bufferOwner.AsSpan();
                    }
                }

                var bytes = new byte[totalRead];
                Buffer.BlockCopy(bufferOwner, 0, bytes, 0, totalRead);
                return(bytes);
            }
            finally
            {
                buffer.Slice(0, totalRead).Clear();
                BufferArrayPool <byte> .Return(bufferOwner);
            }
        }
Ejemplo n.º 2
0
        public static async Task <byte[]> ToArrayAsync(this Stream stream, CancellationToken cancellationToken = default)
        {
            var bufferOwner = BufferArrayPool <byte> .Rent(1024 * 16);

            var buffer    = bufferOwner.AsMemory();
            var totalRead = 0;
            int read;

            try
            {
                while ((read = await stream.ReadAsync(buffer.Slice(totalRead, buffer.Length - totalRead), cancellationToken)) > 0)
                {
                    totalRead += read;
                    if (totalRead == buffer.Length)
                    {
                        BufferArrayPool <byte> .Grow(ref bufferOwner, buffer.Length * 2);

                        buffer = bufferOwner.AsMemory();
                    }
                }

                var bytes = new byte[totalRead];
                buffer.Slice(0, totalRead).Span.CopyTo(bytes.AsSpan());
                return(bytes);
            }
            finally
            {
                buffer.Span.Slice(0, totalRead).Clear();
                BufferArrayPool <byte> .Return(bufferOwner);
            }
        }
Ejemplo n.º 3
0
        public static async Task <byte[]> ToArrayAsync(this Stream stream, CancellationToken cancellationToken = default)
        {
            var buffer = BufferArrayPool <byte> .Rent(1024 * 16);

            var totalRead = 0;
            int read;

            try
            {
                while ((read = await stream.ReadAsync(buffer, totalRead, buffer.Length - totalRead, cancellationToken)) > 0)
                {
                    totalRead += read;
                    if (totalRead == buffer.Length)
                    {
                        BufferArrayPool <byte> .Grow(ref buffer, buffer.Length * 2);
                    }
                }

                var bytes = new byte[totalRead];
                Buffer.BlockCopy(buffer, 0, bytes, 0, totalRead);
                return(bytes);
            }
            finally
            {
                Array.Clear(buffer, 0, totalRead);
                BufferArrayPool <byte> .Return(buffer);
            }
        }
Ejemplo n.º 4
0
        public static unsafe T Deserialize <T>(string queryString)
        {
            var model      = Instantiator.CreateInstance <T>();
            var typeDetail = TypeAnalyzer.GetTypeDetail(typeof(T));

            var bufferOwner = BufferArrayPool <char> .Rent(256);

            var buffer       = bufferOwner.AsSpan();
            var bufferLength = 0;

            try
            {
                fixed(char *pFixed = queryString)
                {
                    char * p    = pFixed;
                    string name = null;

                    for (var i = 0; i < queryString.Length; i++)
                    {
                        var c = *p;
                        switch (c)
                        {
                        case '=':
                            if (name != null)
                            {
                                throw new Exception($"Invalid query string at position {i}");
                            }
#if NETSTANDARD2_0
                            name = new String(bufferOwner, 0, bufferLength);
#else
                            name = new String(buffer.Slice(0, bufferLength));
#endif
                            bufferLength = 0;
                            break;

                        case '&':
                            if (name == null)
                            {
                                throw new Exception($"Invalid query string at position {i}");
                            }
#if NETSTANDARD2_0
                            var value = new String(bufferOwner, 0, bufferLength);
#else
                            var value = new String(buffer.Slice(0, bufferLength));
#endif
                            SetValue(typeDetail, model, WebUtility.UrlDecode(name), WebUtility.UrlDecode(value));
                            name         = null;
                            bufferLength = 0;
                            break;

                        default:
                            if (bufferLength == buffer.Length)
                            {
                                BufferArrayPool <char> .Grow(ref bufferOwner, bufferOwner.Length * 2);

                                buffer = bufferOwner.AsSpan();
                            }
                            buffer[bufferLength++] = c;
                            break;
                        }
                        p++;
                    }

                    if (name != null)
                    {
#if NETSTANDARD2_0
                        var value = new String(bufferOwner, 0, bufferLength);
#else
                        var value = new String(buffer.Slice(0, bufferLength));
#endif
                        SetValue(typeDetail, model, WebUtility.UrlDecode(name), WebUtility.UrlDecode(value));
                        bufferLength = 0;
                    }
                }
            }
            finally
            {
                BufferArrayPool <char> .Return(bufferOwner);
            }

            return(model);
        }