Exemplo n.º 1
0
        public void Decrypt(ReadOnlySequence <byte> sequence, Action <ReadOnlySequence <byte> > action)
        {
            var bytesPipe = new BytesPipe(_bytesPool);

            Span <byte> payloadLengthBytes = stackalloc byte[4];
            Span <byte> tag    = stackalloc byte[TagLength];
            var         buffer = _bytesPool.Array.Rent(MaxPayloadLength);

            try
            {
                while (sequence.Length > 4 + TagLength)
                {
                    sequence.Slice(0, payloadLengthBytes.Length).CopyTo(payloadLengthBytes);
                    sequence = sequence.Slice(payloadLengthBytes.Length);
                    var payloadLength = BinaryPrimitives.ReadInt32BigEndian(payloadLengthBytes);

                    if (payloadLength > MaxPayloadLength)
                    {
                        throw new OmniSecureConnectionException("payload too large");
                    }

                    sequence.Slice(0, tag.Length).CopyTo(tag);
                    sequence = sequence.Slice(tag.Length);

                    var ciphertext = buffer.AsSpan()[..payloadLength];
Exemplo n.º 2
0
    private static OmniHash CreateOmniHash(string name, ReadOnlySpan <byte> publicKey, OmniHashAlgorithmType hashAlgorithmType)
    {
        if (name == null)
        {
            throw new ArgumentNullException(nameof(name));
        }

        using var bytesPipe = new BytesPipe();
        {
            var writer = new RocketMessageWriter(bytesPipe.Writer, BytesPool.Shared);

            writer.Write(name);
            writer.Write(publicKey);
        }

        if (hashAlgorithmType == OmniHashAlgorithmType.Sha2_256)
        {
            var result = new OmniHash(hashAlgorithmType, Sha2_256.ComputeHash(bytesPipe.Reader.GetSequence()));

            return(result);
        }
        else
        {
            throw new NotSupportedException();
        }
    }
Exemplo n.º 3
0
    public static string SignatureToString(OmniSignature signature)
    {
        using var bytesPipe = new BytesPipe(BytesPool.Shared);
        signature.Export(bytesPipe.Writer, BytesPool.Shared);
        var hash = new OmniHash(OmniHashAlgorithmType.Sha2_256, Sha2_256.ComputeHash(bytesPipe.Reader.GetSequence()));

        return(hash.ToString(ConvertStringType.Base16));
    }
Exemplo n.º 4
0
        public ConnectionSender(ICap cap, IBytesPool bytesPool, CancellationToken cancellationToken)
        {
            _cap               = cap;
            _bytesPool         = bytesPool;
            _cancellationToken = cancellationToken;

            _bytesPipe     = new BytesPipe(_bytesPool);
            _semaphoreSlim = new SemaphoreSlim(1, 1);
        }
Exemplo n.º 5
0
 public ConnectionReceiver(ICap cap, int maxReceiveByteCount, IBytesPool bytesPool, CancellationToken cancellationToken)
 {
     _cap = cap;
     _maxReceiveByteCount = maxReceiveByteCount;
     _bytesPool           = bytesPool;
     _cancellationToken   = cancellationToken;
     _bytesPipe           = new BytesPipe(_bytesPool);
     _semaphoreSlim       = new SemaphoreSlim(0, 1);
 }
Exemplo n.º 6
0
    public bool Verify()
    {
        using var bytesPipe = new BytesPipe();
        var target = new AuthenticationMessage(this.CreationTime, this.Hash, null);

        target.Export(bytesPipe.Writer, BytesPool.Shared);

        return(this.Certificate?.Verify(bytesPipe.Reader.GetSequence()) ?? false);
    }
Exemplo n.º 7
0
    public static async ValueTask <TValue?> TryGetValueAsync <TValue>(this IKeyValueStorage <string> storage, string key, CancellationToken cancellationToken = default)
        where TValue : IRocketMessage <TValue>
    {
        var bytesPool = BytesPool.Shared;

        using var bytesPipe = new BytesPipe(bytesPool);

        if (!await storage.TryReadAsync(key, bytesPipe.Writer, cancellationToken))
        {
            return(default);
Exemplo n.º 8
0
    public static Shout Create(Timestamp creationTime, IMemoryOwner <byte> value, OmniDigitalSignature digitalSignature)
    {
        using var bytesPipe = new BytesPipe();
        var target = new Shout(creationTime, value, null);

        target.Export(bytesPipe.Writer, BytesPool.Shared);

        var certificate = OmniDigitalSignature.CreateOmniCertificate(digitalSignature, bytesPipe.Reader.GetSequence());

        return(new Shout(creationTime, value, certificate));
    }
Exemplo n.º 9
0
    private static bool TryEncode(byte[] body, out byte[]?message)
    {
        message             = null;
        using var bytesPipe = new BytesPipe();
        if (!OmniMessageConverter.TryWrite(new ReadOnlySequence <byte>(body), bytesPipe.Writer))
        {
            return(false);
        }

        message = bytesPipe.Reader.GetSequence().ToArray();
        return(true);
    }
Exemplo n.º 10
0
    private static bool TryDecode(byte[] message, out byte[]?body)
    {
        body = null;
        using var bytesPipe = new BytesPipe();
        if (!OmniMessageConverter.TryRead(new ReadOnlySequence <byte>(message), bytesPipe.Writer))
        {
            return(false);
        }

        body = bytesPipe.Reader.GetSequence().ToArray();
        return(true);
    }
Exemplo n.º 11
0
    public static IMemoryOwner <byte> ToBytes <T>(T message)
        where T : IRocketMessage <T>
    {
        using var hub = new BytesPipe();
        message.Export(hub.Writer, BytesPool.Shared);

        var sequence    = hub.Reader.GetSequence();
        var memoryOwner = BytesPool.Shared.Memory.Rent((int)sequence.Length).Shrink((int)sequence.Length);

        sequence.CopyTo(memoryOwner.Memory.Span);

        return(memoryOwner);
    }
Exemplo n.º 12
0
    public void EmptyDataGetTest()
    {
        using var bytesPipe = new BytesPipe();
        var reader = new SequenceReader <byte>(bytesPipe.Reader.GetSequence());

        Assert.False(Varint.TryGetUInt8(ref reader, out var result1));
        Assert.False(Varint.TryGetUInt16(ref reader, out var result2));
        Assert.False(Varint.TryGetUInt32(ref reader, out var result3));
        Assert.False(Varint.TryGetUInt64(ref reader, out var result4));
        Assert.False(Varint.TryGetInt8(ref reader, out var result5));
        Assert.False(Varint.TryGetInt16(ref reader, out var result6));
        Assert.False(Varint.TryGetInt32(ref reader, out var result7));
        Assert.False(Varint.TryGetInt64(ref reader, out var result8));
    }
Exemplo n.º 13
0
        private byte[] ComputeHash(ProfileMessage profileMessage, OmniAgreementPublicKey agreementPublicKey, HashAlgorithmType hashAlgorithm)
        {
            var verificationMessage = new VerificationMessage(profileMessage, agreementPublicKey);

            if (hashAlgorithm == HashAlgorithmType.Sha2_256)
            {
                using var bytesPipe = new BytesPipe();
                verificationMessage.Export(bytesPipe.Writer, _bytesPool);

                return(Sha2_256.ComputeHash(bytesPipe.Reader.GetSequence()));
            }

            throw new NotSupportedException(nameof(hashAlgorithm));
        }
Exemplo n.º 14
0
        public void Encrypt(Action <IBufferWriter <byte> > action, IBufferWriter <byte> bufferWriter)
        {
            using var bytesPipe = new BytesPipe(_bytesPool);
            action.Invoke(bytesPipe.Writer);

            var sequence = bytesPipe.Reader.GetSequence();
            var buffer   = _bytesPool.Array.Rent(MaxPayloadLength);

            try
            {
                while (sequence.Length > 0)
                {
                    int payloadLength = (int)Math.Min(sequence.Length, MaxPayloadLength);

                    var payloadLengthBytes = bufferWriter.GetSpan(4)[..4];
Exemplo n.º 15
0
    public static void ToStream <T>(T message, Stream stream)
        where T : IRocketMessage <T>
    {
        using var bytesPipe = new BytesPipe();

        message.Export(bytesPipe.Writer, BytesPool.Shared);

        var sequence = bytesPipe.Reader.GetSequence();
        var position = sequence.Start;

        while (sequence.TryGet(ref position, out var memory))
        {
            stream.Write(memory.Span);
        }
    }
        private ArraySegment <byte> GetPayload(Action <IBufferWriter <byte> > action)
        {
            using var bytesPipe = new BytesPipe(_bytesPool);
            action.Invoke(bytesPipe.Writer);
            if (bytesPipe.Writer.WrittenBytes == 0)
            {
                return(ArraySegment <byte> .Empty);
            }

            var sequence = bytesPipe.Reader.GetSequence();
            var buffer   = _bytesPool.Array.Rent((int)sequence.Length);

            sequence.CopyTo(buffer.AsSpan());

            return(new ArraySegment <byte>(buffer, 0, (int)sequence.Length));
        }
Exemplo n.º 17
0
    public static AuthenticationMessage Create(DateTime creationTime, ReadOnlyMemory <byte> hash, OmniDigitalSignature?digitalSignature)
    {
        if (digitalSignature is null)
        {
            return(new AuthenticationMessage(Timestamp.FromDateTime(creationTime), hash, null));
        }

        using var bytesPipe = new BytesPipe();
        var target = new AuthenticationMessage(Timestamp.FromDateTime(creationTime), hash, null);

        target.Export(bytesPipe.Writer, BytesPool.Shared);

        var certificate = OmniDigitalSignature.CreateOmniCertificate(digitalSignature, bytesPipe.Reader.GetSequence());

        return(new AuthenticationMessage(Timestamp.FromDateTime(creationTime), hash, certificate));
    }
Exemplo n.º 18
0
    private static string MessageToString <T>(string path, int version, T message)
        where T : IRocketMessage <T>
    {
        var bytesPool = BytesPool.Shared;

        using var inBytesPipe = new BytesPipe(bytesPool);
        message.Export(inBytesPipe.Writer, bytesPool);

        using var outBytesPipe = new BytesPipe(bytesPool);
        if (!OmniMessageConverter.TryWrite(inBytesPipe.Reader.GetSequence(), outBytesPipe.Writer))
        {
            throw new Exception();
        }

        return(AddSchemaAndPath(path, version, OmniBase.Encode(outBytesPipe.Reader.GetSequence(), ConvertStringType.Base58) !));
    }
Exemplo n.º 19
0
    public static T FromStream <T>(Stream inStream)
        where T : IRocketMessage <T>
    {
        using var bytesPipe = new BytesPipe();

        const int bufferSize = 4096;

        while (inStream.Position < inStream.Length)
        {
            var readLength = inStream.Read(bytesPipe.Writer.GetSpan(bufferSize));
            if (readLength < 0)
            {
                break;
            }

            bytesPipe.Writer.Advance(readLength);
        }

        return(IRocketMessage <T> .Import(bytesPipe.Reader.GetSequence(), BytesPool.Shared));
    }
Exemplo n.º 20
0
    public static async IAsyncEnumerable <TValue> GetValuesAsync <TValue>(this IKeyValueStorage <string> storage, [EnumeratorCancellation] CancellationToken cancellationToken = default)
        where TValue : IRocketMessage <TValue>
    {
        var bytesPool = BytesPool.Shared;

        using var bytesPipe = new BytesPipe(bytesPool);

        await foreach (var key in storage.GetKeysAsync(cancellationToken))
        {
            if (!await storage.TryReadAsync(key, bytesPipe.Writer, cancellationToken))
            {
                continue;
            }

            var value = IRocketMessage <TValue> .Import(bytesPipe.Reader.GetSequence(), bytesPool);

            yield return(value);

            bytesPipe.Reset();
        }
    }
Exemplo n.º 21
0
    public void BrokenDataGetTest()
    {
        const byte Int8Code  = 0x80;
        const byte Int16Code = 0x81;
        const byte Int32Code = 0x82;
        const byte Int64Code = 0x83;

        {
            using var bytesPipe = new BytesPipe();
            bytesPipe.Writer.Write(new byte[] { Int8Code });
            var reader = new SequenceReader <byte>(bytesPipe.Reader.GetSequence());
            Assert.False(Varint.TryGetUInt8(ref reader, out var result1));
        }

        {
            {
                using var bytesPipe = new BytesPipe();
                bytesPipe.Writer.Write(new byte[] { Int8Code });
                var reader = new SequenceReader <byte>(bytesPipe.Reader.GetSequence());
                Assert.False(Varint.TryGetUInt16(ref reader, out var result1));
            }

            {
                using var bytesPipe = new BytesPipe();
                bytesPipe.Writer.Write(new byte[] { Int16Code });
                var reader = new SequenceReader <byte>(bytesPipe.Reader.GetSequence());
                Assert.False(Varint.TryGetUInt16(ref reader, out var result1));
            }
        }

        {
            {
                using var bytesPipe = new BytesPipe();
                bytesPipe.Writer.Write(new byte[] { Int8Code });
                var reader = new SequenceReader <byte>(bytesPipe.Reader.GetSequence());
                Assert.False(Varint.TryGetUInt32(ref reader, out var result1));
            }

            {
                using var bytesPipe = new BytesPipe();
                bytesPipe.Writer.Write(new byte[] { Int16Code });
                var reader = new SequenceReader <byte>(bytesPipe.Reader.GetSequence());
                Assert.False(Varint.TryGetUInt32(ref reader, out var result1));
            }

            {
                using var bytesPipe = new BytesPipe();
                bytesPipe.Writer.Write(new byte[] { Int32Code });
                var reader = new SequenceReader <byte>(bytesPipe.Reader.GetSequence());
                Assert.False(Varint.TryGetUInt32(ref reader, out var result1));
            }
        }

        {
            {
                using var bytesPipe = new BytesPipe();
                bytesPipe.Writer.Write(new byte[] { Int8Code });
                var reader = new SequenceReader <byte>(bytesPipe.Reader.GetSequence());
                Assert.False(Varint.TryGetUInt64(ref reader, out var result1));
            }

            {
                using var bytesPipe = new BytesPipe();
                bytesPipe.Writer.Write(new byte[] { Int16Code });
                var reader = new SequenceReader <byte>(bytesPipe.Reader.GetSequence());
                Assert.False(Varint.TryGetUInt64(ref reader, out var result1));
            }

            {
                using var bytesPipe = new BytesPipe();
                bytesPipe.Writer.Write(new byte[] { Int32Code });
                var reader = new SequenceReader <byte>(bytesPipe.Reader.GetSequence());
                Assert.False(Varint.TryGetUInt64(ref reader, out var result1));
            }

            {
                using var bytesPipe = new BytesPipe();
                bytesPipe.Writer.Write(new byte[] { Int64Code });
                var reader = new SequenceReader <byte>(bytesPipe.Reader.GetSequence());
                Assert.False(Varint.TryGetUInt64(ref reader, out var result1));
            }
        }
    }
Exemplo n.º 22
0
    public void RandomTest()
    {
        var random = new Random(0);

        using (var bytesPipe = new BytesPipe())
        {
            for (int i = 0; i < 32; i++)
            {
                foreach (var result1 in GenRandomValue(random, 8).Select(n => (byte)n))
                {
                    Varint.SetUInt8(result1, bytesPipe.Writer);

                    var reader = new SequenceReader <byte>(bytesPipe.Reader.GetSequence());
                    Varint.TryGetUInt8(ref reader, out var result2);

                    Assert.Equal(result1, result2);

                    bytesPipe.Reset();
                }
            }
        }

        using (var bytesPipe = new BytesPipe())
        {
            for (int i = 0; i < 32; i++)
            {
                foreach (var result1 in GenRandomValue(random, 16).Select(n => (ushort)n))
                {
                    Varint.SetUInt16(result1, bytesPipe.Writer);

                    var reader = new SequenceReader <byte>(bytesPipe.Reader.GetSequence());
                    Varint.TryGetUInt16(ref reader, out var result2);

                    Assert.Equal(result1, result2);

                    bytesPipe.Reset();
                }
            }
        }

        using (var bytesPipe = new BytesPipe())
        {
            for (int i = 0; i < 32; i++)
            {
                foreach (var result1 in GenRandomValue(random, 32).Select(n => (uint)n))
                {
                    Varint.SetUInt32(result1, bytesPipe.Writer);

                    var reader = new SequenceReader <byte>(bytesPipe.Reader.GetSequence());
                    Varint.TryGetUInt32(ref reader, out var result2);

                    Assert.Equal(result1, result2);

                    bytesPipe.Reset();
                }
            }
        }

        using (var bytesPipe = new BytesPipe())
        {
            for (int i = 0; i < 32; i++)
            {
                foreach (var result1 in GenRandomValue(random, 64).Select(n => (ulong)n))
                {
                    Varint.SetUInt64(result1, bytesPipe.Writer);

                    var reader = new SequenceReader <byte>(bytesPipe.Reader.GetSequence());
                    Varint.TryGetUInt64(ref reader, out var result2);

                    Assert.Equal(result1, result2);

                    bytesPipe.Reset();
                }
            }
        }

        using (var bytesPipe = new BytesPipe())
        {
            for (int i = 0; i < 32; i++)
            {
                foreach (var result1 in GenRandomValue(random, 8).Select(n => (sbyte)n))
                {
                    Varint.SetInt8(result1, bytesPipe.Writer);

                    var reader = new SequenceReader <byte>(bytesPipe.Reader.GetSequence());
                    Varint.TryGetInt8(ref reader, out var result2);

                    Assert.Equal(result1, result2);

                    bytesPipe.Reset();
                }
            }
        }

        using (var bytesPipe = new BytesPipe())
        {
            for (int i = 0; i < 32; i++)
            {
                foreach (var result1 in GenRandomValue(random, 16).Select(n => (short)n))
                {
                    Varint.SetInt16(result1, bytesPipe.Writer);

                    var reader = new SequenceReader <byte>(bytesPipe.Reader.GetSequence());
                    Varint.TryGetInt16(ref reader, out var result2);

                    Assert.Equal(result1, result2);

                    bytesPipe.Reset();
                }
            }
        }

        using (var bytesPipe = new BytesPipe())
        {
            for (int i = 0; i < 32; i++)
            {
                foreach (var result1 in GenRandomValue(random, 32).Select(n => (int)n))
                {
                    Varint.SetInt32(result1, bytesPipe.Writer);

                    var reader = new SequenceReader <byte>(bytesPipe.Reader.GetSequence());
                    Varint.TryGetInt32(ref reader, out var result2);

                    Assert.Equal(result1, result2);

                    bytesPipe.Reset();
                }
            }
        }

        using (var bytesPipe = new BytesPipe())
        {
            for (int i = 0; i < 32; i++)
            {
                foreach (var result1 in GenRandomValue(random, 64).Select(n => (long)n))
                {
                    Varint.SetInt64(result1, bytesPipe.Writer);

                    var reader = new SequenceReader <byte>(bytesPipe.Reader.GetSequence());
                    Varint.TryGetInt64(ref reader, out var result2);

                    Assert.Equal(result1, result2);

                    bytesPipe.Reset();
                }
            }
        }
    }
Exemplo n.º 23
0
        static StringDeserializeBenchmark()
        {
            var charList = new char[] { 'A', 'B', 'C', 'D', 'E', '安', '以', '宇', '衣', '於' };

            string GetRandomString(Random random)
            {
                var sb = new StringBuilder();

                for (int i = random.Next(32, 256) - 1; i >= 0; i--)
                {
                    sb.Append(charList[random.Next(0, charList.Length)]);
                }

                return(sb.ToString());
            }

            {
                var random = new Random(0);

                var elementsList = new List <MessagePack_StringElements>();

                for (int i = 0; i < 32 * 1024; i++)
                {
                    var elements = new MessagePack_StringElements()
                    {
                        X0 = GetRandomString(random),
                        X1 = GetRandomString(random),
                        X2 = GetRandomString(random),
                        X3 = GetRandomString(random),
                        X4 = GetRandomString(random),
                        X5 = GetRandomString(random),
                        X6 = GetRandomString(random),
                        X7 = GetRandomString(random),
                        X8 = GetRandomString(random),
                        X9 = GetRandomString(random),
                    };

                    elementsList.Add(elements);
                }

                _messagePack_Bytes = MessagePack.MessagePackSerializer.Serialize(new MessagePack_StringElementsList()
                {
                    List = elementsList.ToArray()
                });
            }

            {
                var random    = new Random(0);
                var bytesPool = BytesPool.Shared;

                using (var bytesPipe = new BytesPipe(bytesPool))
                {
                    var elementsList = new List <RocketPack_StringElements>();

                    for (int i = 0; i < 32 * 1024; i++)
                    {
                        var X0 = GetRandomString(random);
                        var X1 = GetRandomString(random);
                        var X2 = GetRandomString(random);
                        var X3 = GetRandomString(random);
                        var X4 = GetRandomString(random);
                        var X5 = GetRandomString(random);
                        var X6 = GetRandomString(random);
                        var X7 = GetRandomString(random);
                        var X8 = GetRandomString(random);
                        var X9 = GetRandomString(random);

                        var elements = new RocketPack_StringElements(X0, X1, X2, X3, X4, X5, X6, X7, X8, X9);
                        elementsList.Add(elements);
                    }

                    var message = new RocketPack_StringElementsList(elementsList.ToArray());

                    message.Export(bytesPipe.Writer, BytesPool.Shared);

                    _rocketPack_Bytes = new byte[bytesPipe.Writer.WrittenBytes];
                    bytesPipe.Reader.GetSequence().CopyTo(_rocketPack_Bytes);
                }
            }
        }
Exemplo n.º 24
0
        static IntSerializeBenchmark()
        {
            {
                var random = new Random(0);

                var elementsList = new List <MessagePack_IntElements>();

                for (int i = 0; i < 32 * 1024; i++)
                {
                    var elements = new MessagePack_IntElements()
                    {
                        X0 = (uint)random.Next(0, 1024 * 256),
                        X1 = (uint)random.Next(0, 1024 * 256),
                        X2 = (uint)random.Next(0, 1024 * 256),
                        X3 = (uint)random.Next(0, 1024 * 256),
                        X4 = (uint)random.Next(0, 1024 * 256),
                        X5 = (uint)random.Next(0, 1024 * 256),
                        X6 = (uint)random.Next(0, 1024 * 256),
                        X7 = (uint)random.Next(0, 1024 * 256),
                        X8 = (uint)random.Next(0, 1024 * 256),
                        X9 = (uint)random.Next(0, 1024 * 256),
                    };

                    elementsList.Add(elements);
                }

                _messagePack_Message = new MessagePack_IntElementsList()
                {
                    List = elementsList.ToArray()
                };
            }

            {
                var random    = new Random(0);
                var bytesPool = BytesPool.Shared;

                using (var bytesPipe = new BytesPipe(bytesPool))
                {
                    var elementsList = new List <RocketPack_IntElements>();

                    for (int i = 0; i < 32 * 1024; i++)
                    {
                        var X0 = (uint)random.Next(0, 1024 * 256);
                        var X1 = (uint)random.Next(0, 1024 * 256);
                        var X2 = (uint)random.Next(0, 1024 * 256);
                        var X3 = (uint)random.Next(0, 1024 * 256);
                        var X4 = (uint)random.Next(0, 1024 * 256);
                        var X5 = (uint)random.Next(0, 1024 * 256);
                        var X6 = (uint)random.Next(0, 1024 * 256);
                        var X7 = (uint)random.Next(0, 1024 * 256);
                        var X8 = (uint)random.Next(0, 1024 * 256);
                        var X9 = (uint)random.Next(0, 1024 * 256);

                        var elements = new RocketPack_IntElements(X0, X1, X2, X3, X4, X5, X6, X7, X8, X9);
                        elementsList.Add(elements);
                    }

                    _rocketPack_Message = new RocketPack_IntElementsList(elementsList.ToArray());
                }
            }
        }
Exemplo n.º 25
0
        static BytesSerializeBenchmark()
        {
            {
                var random = new Random(0);

                var elementsList = new List <MessagePack_BytesElements>();

                for (int i = 0; i < 10; i++)
                {
                    var elements = new MessagePack_BytesElements()
                    {
                        X0 = new byte[random.Next(0, 1024 * 256)],
                        X1 = new byte[random.Next(0, 1024 * 256)],
                        X2 = new byte[random.Next(0, 1024 * 256)],
                        X3 = new byte[random.Next(0, 1024 * 256)],
                        X4 = new byte[random.Next(0, 1024 * 256)],
                        X5 = new byte[random.Next(0, 1024 * 256)],
                        X6 = new byte[random.Next(0, 1024 * 256)],
                        X7 = new byte[random.Next(0, 1024 * 256)],
                        X8 = new byte[random.Next(0, 1024 * 256)],
                        X9 = new byte[random.Next(0, 1024 * 256)],
                    };

                    elementsList.Add(elements);
                }

                _messagePack_Message = new MessagePack_BytesElementsList()
                {
                    List = elementsList.ToArray()
                };
            }

            {
                var random    = new Random(0);
                var bytesPool = BytesPool.Shared;

                using (var bytesPipe = new BytesPipe(bytesPool))
                {
                    var elementsList = new List <RocketPack_BytesElements>();

                    for (int i = 0; i < 10; i++)
                    {
                        var X0 = bytesPool.Memory.Rent(random.Next(0, 1024 * 256));
                        var X1 = bytesPool.Memory.Rent(random.Next(0, 1024 * 256));
                        var X2 = bytesPool.Memory.Rent(random.Next(0, 1024 * 256));
                        var X3 = bytesPool.Memory.Rent(random.Next(0, 1024 * 256));
                        var X4 = bytesPool.Memory.Rent(random.Next(0, 1024 * 256));
                        var X5 = bytesPool.Memory.Rent(random.Next(0, 1024 * 256));
                        var X6 = bytesPool.Memory.Rent(random.Next(0, 1024 * 256));
                        var X7 = bytesPool.Memory.Rent(random.Next(0, 1024 * 256));
                        var X8 = bytesPool.Memory.Rent(random.Next(0, 1024 * 256));
                        var X9 = bytesPool.Memory.Rent(random.Next(0, 1024 * 256));

                        var elements = new RocketPack_BytesElements(X0, X1, X2, X3, X4, X5, X6, X7, X8, X9);
                        elementsList.Add(elements);
                    }

                    _rocketPack_Message = new RocketPack_BytesElementsList(elementsList.ToArray());
                }
            }
        }
Exemplo n.º 26
0
        static BytesDeserializeBenchmark()
        {
            {
                var random = new Random(0);

                var elementsList = new List <MessagePack_BytesElements>();

                for (int i = 0; i < 10; i++)
                {
                    var elements = new MessagePack_BytesElements()
                    {
                        X0 = new byte[random.Next(0, 1024 * 256)],
                        X1 = new byte[random.Next(0, 1024 * 256)],
                        X2 = new byte[random.Next(0, 1024 * 256)],
                        X3 = new byte[random.Next(0, 1024 * 256)],
                        X4 = new byte[random.Next(0, 1024 * 256)],
                        X5 = new byte[random.Next(0, 1024 * 256)],
                        X6 = new byte[random.Next(0, 1024 * 256)],
                        X7 = new byte[random.Next(0, 1024 * 256)],
                        X8 = new byte[random.Next(0, 1024 * 256)],
                        X9 = new byte[random.Next(0, 1024 * 256)],
                    };

                    elementsList.Add(elements);
                }

                _messagePack_Bytes = MessagePack.MessagePackSerializer.Serialize(new MessagePack_BytesElementsList()
                {
                    List = elementsList.ToArray()
                });
            }

            {
                var bytesPool = BytesPool.Shared;
                var random    = new Random(0);
                using (var bytesPipe = new BytesPipe(bytesPool))
                {
                    var elementsList = new List <RocketPack_BytesElements>();

                    for (int i = 0; i < 10; i++)
                    {
                        var X0 = bytesPool.Memory.Rent(random.Next(0, 1024 * 256));
                        var X1 = bytesPool.Memory.Rent(random.Next(0, 1024 * 256));
                        var X2 = bytesPool.Memory.Rent(random.Next(0, 1024 * 256));
                        var X3 = bytesPool.Memory.Rent(random.Next(0, 1024 * 256));
                        var X4 = bytesPool.Memory.Rent(random.Next(0, 1024 * 256));
                        var X5 = bytesPool.Memory.Rent(random.Next(0, 1024 * 256));
                        var X6 = bytesPool.Memory.Rent(random.Next(0, 1024 * 256));
                        var X7 = bytesPool.Memory.Rent(random.Next(0, 1024 * 256));
                        var X8 = bytesPool.Memory.Rent(random.Next(0, 1024 * 256));
                        var X9 = bytesPool.Memory.Rent(random.Next(0, 1024 * 256));

                        var elements = new RocketPack_BytesElements(X0, X1, X2, X3, X4, X5, X6, X7, X8, X9);
                        elementsList.Add(elements);
                    }

                    var message = new RocketPack_BytesElementsList(elementsList.ToArray());

                    message.Export(bytesPipe.Writer, BytesPool.Shared);

                    _rocketPack_Bytes = new byte[bytesPipe.Writer.WrittenBytes];
                    bytesPipe.Reader.GetSequence().CopyTo(_rocketPack_Bytes);
                }
            }
        }