/// <inheritdoc />
        protected override Task <bool> SendInternalAsync(IByteStreamHandler byteStreamHandler, ReadOnlySpan <char> rawMessage)
        {
            byteStreamHandler.MustNotBeNull(nameof(byteStreamHandler));

            // Check for valid message
            if (rawMessage.Length > _length)
            {
                throw new ArgumentException(
                          "Given message too long. " +
                          $"Maximum length: {(_length)}, " +
                          $"given message length: {rawMessage.Length}",
                          nameof(rawMessage));
            }

            // Perform message formatting
            var sendBuffer = StringBuffer.Acquire(_length);

            byte[]? bytes = null;
            try
            {
                if (rawMessage.Length > 0)
                {
                    sendBuffer.Append(rawMessage);
                }
                while (sendBuffer.Count < _length)
                {
                    sendBuffer.Append(_fillSymbol);
                }
                sendBuffer.GetInternalData(out var buffer, out var currentCount);

                var sendMessageByteLength = _encoding.GetByteCount(buffer, 0, currentCount);
                bytes = ByteArrayPool.Take(sendMessageByteLength);

                _encoding.GetBytes(buffer, 0, currentCount, bytes, 0);
                StringBuffer.Release(sendBuffer);
                sendBuffer = null;

                return(byteStreamHandler.SendAsync(
                           new ArraySegment <byte>(bytes, 0, sendMessageByteLength)));
            }
            finally
            {
                if (bytes != null)
                {
                    ByteArrayPool.Return(bytes);
                }
                if (sendBuffer != null)
                {
                    StringBuffer.Release(sendBuffer);
                }
            }
        }
        /// <inheritdoc />
        protected override Task <bool> SendInternalAsync(IByteStreamHandler byteStreamHandler, ReadOnlySpan <char> rawMessage)
        {
            byteStreamHandler.MustNotBeNull(nameof(byteStreamHandler));

            // Check for start- and endsymbols inside the message
            TcpCommunicatorUtil.EnsureNoEndsymbolsInMessage(rawMessage, _endSymbols);

            // Perform message formatting
            var sendBuffer = StringBuffer.Acquire(rawMessage.Length + _endSymbols.Length);

            byte[]? bytes = null;
            try
            {
                sendBuffer.Append(_startSymbols, 0, _startSymbols.Length);
                if (rawMessage.Length > 0)
                {
                    sendBuffer.Append(rawMessage);
                }
                sendBuffer.Append(_endSymbols, 0, _endSymbols.Length);
                sendBuffer.GetInternalData(out var buffer, out var currentCount);

                var sendMessageByteLength = _encoding.GetByteCount(buffer, 0, currentCount);
                bytes = ByteArrayPool.Take(sendMessageByteLength);

                _encoding.GetBytes(buffer, 0, currentCount, bytes, 0);
                StringBuffer.Release(sendBuffer);
                sendBuffer = null;

                return(byteStreamHandler.SendAsync(
                           new ArraySegment <byte>(bytes, 0, sendMessageByteLength)));
            }
            finally
            {
                if (bytes != null)
                {
                    ByteArrayPool.Return(bytes);
                }
                if (sendBuffer != null)
                {
                    StringBuffer.Release(sendBuffer);
                }
            }
        }
        /// <inheritdoc />
        protected override Task <bool> SendInternalAsync(IByteStreamHandler byteStreamHandler, ReadOnlySpan <char> rawMessage)
        {
            byteStreamHandler.MustNotBeNull(nameof(byteStreamHandler));

            var rawMessageLength = rawMessage.Length;
            var lengthDigitCount = TcpCommunicatorUtil.GetCountOfDigits(rawMessageLength);
            var sendBuffer       = StringBuffer.Acquire(rawMessageLength + 3 + lengthDigitCount);

            byte[]? bytes = null;
            try
            {
                sendBuffer.Append(SYMBOL_START);
                sendBuffer.Append(rawMessageLength, StringView.Empty);
                sendBuffer.Append(SYMBOL_DELIMITER);
                if (rawMessage.Length > 0)
                {
                    sendBuffer.Append(rawMessage);
                }
                sendBuffer.Append(SYMBOL_END);
                sendBuffer.GetInternalData(out var buffer, out var currentCount);

                var sendMessageByteLength = _encoding.GetByteCount(buffer, 0, currentCount);
                bytes = ByteArrayPool.Take(sendMessageByteLength);

                _encoding.GetBytes(buffer, 0, currentCount, bytes, 0);
                StringBuffer.Release(sendBuffer);
                sendBuffer = null;

                return(byteStreamHandler.SendAsync(
                           new ArraySegment <byte>(bytes, 0, sendMessageByteLength)));
            }
            finally
            {
                if (bytes != null)
                {
                    ByteArrayPool.Return(bytes);
                }
                if (sendBuffer != null)
                {
                    StringBuffer.Release(sendBuffer);
                }
            }
        }
        /// <inheritdoc />
        protected override Task <bool> SendInternalAsync(IByteStreamHandler byteStreamHandler, ReadOnlySpan <char> rawMessage)
        {
            byteStreamHandler.MustNotBeNull(nameof(byteStreamHandler));
            rawMessage.MustBeLongerThan(0, nameof(rawMessage));

            // Perform message formatting
            var sendBuffer = StringBuffer.Acquire(rawMessage.Length);

            byte[]? bytes = null;
            try
            {
                sendBuffer.Append(rawMessage);
                sendBuffer.GetInternalData(out var buffer, out var currentCount);

                var sendMessageByteLength = _encoding.GetByteCount(buffer, 0, currentCount);
                bytes = ByteArrayPool.Take(sendMessageByteLength);

                _encoding.GetBytes(buffer, 0, currentCount, bytes, 0);
                StringBuffer.Release(sendBuffer);
                sendBuffer = null;

                return(byteStreamHandler.SendAsync(
                           new ArraySegment <byte>(bytes, 0, sendMessageByteLength)));
            }
            finally
            {
                if (bytes != null)
                {
                    ByteArrayPool.Return(bytes);
                }
                if (sendBuffer != null)
                {
                    StringBuffer.Release(sendBuffer);
                }
            }
        }
 protected abstract Task <bool> SendInternalAsync(IByteStreamHandler byteStreamHandler, ReadOnlySpan <char> rawMessage);