コード例 #1
0
            public HelloMessage Deserialize(Omnix.Serialization.RocketPack.RocketPackReader r, int rank)
            {
                if (rank > 256)
                {
                    throw new System.FormatException();
                }

                // Read property count
                uint propertyCount = r.GetUInt32();

                OmniSecureConnectionVersion[] p_versions = System.Array.Empty <OmniSecureConnectionVersion>();

                for (; propertyCount > 0; propertyCount--)
                {
                    uint id = r.GetUInt32();
                    switch (id)
                    {
                    case 0:     // Versions
                    {
                        var length = r.GetUInt32();
                        p_versions = new OmniSecureConnectionVersion[length];
                        for (int i = 0; i < p_versions.Length; i++)
                        {
                            p_versions[i] = (OmniSecureConnectionVersion)r.GetUInt64();
                        }
                        break;
                    }
                    }
                }

                return(new HelloMessage(p_versions));
            }
コード例 #2
0
    private async ValueTask HelloAsync(CancellationToken cancellationToken)
    {
        var versions = new List <OmniSecureConnectionVersion>();

        if (_secureConnection_v1 is not null)
        {
            versions.Add(OmniSecureConnectionVersion.Version1);
        }

        var sendHelloMessage    = new HelloMessage(versions.ToArray());
        var receiveHelloMessage = await _connection.ExchangeAsync(sendHelloMessage, cancellationToken);

        _version = EnumHelper.GetOverlappedMaxValue(sendHelloMessage.Versions, receiveHelloMessage.Versions) ?? OmniSecureConnectionVersion.Unknown;
    }
コード例 #3
0
        private async ValueTask HelloAsync(CancellationToken cancellationToken)
        {
            HelloMessage sendHelloMessage;
            HelloMessage?receiveHelloMessage = null;

            {
                sendHelloMessage = new HelloMessage(new[] { _version });

                var enqueueTask = _connection.EnqueueAsync((bufferWriter) => sendHelloMessage.Export(bufferWriter, _bytesPool), cancellationToken);
                var dequeueTask = _connection.DequeueAsync((sequence) => receiveHelloMessage = HelloMessage.Import(sequence, _bytesPool), cancellationToken);

                await ValueTaskHelper.WhenAll(enqueueTask, dequeueTask);

                if (receiveHelloMessage is null)
                {
                    throw new NullReferenceException();
                }
            }

            _version = GetOverlapMaxEnum(sendHelloMessage.Versions, receiveHelloMessage.Versions);
        }