Length

Otlp\Http\OtlpHttpEndpointsBuilder.cs (1)

191if (result.Buffer.Length > MaxRequestSize)

src\Shared\Http2cat\Http2Utilities.cs (2)

846Assert.True(buffer.Length > 0); 866_bytesReceived += buffer.Slice(buffer.Start, consumed).Length;

src\Shared\ServerInfrastructure\DuplexPipeStream.cs (1)

135var count = (int)Math.Min(readableBuffer.Length, destination.Length);

src\Shared\ServerInfrastructure\Http2\Http2FrameReader.cs (2)

43if (buffer.Length < HeaderLength) 59if (buffer.Length < frameLength)

src\Shared\Http2cat\Http2Utilities.cs (2)

846Assert.True(buffer.Length > 0); 866_bytesReceived += buffer.Slice(buffer.Start, consumed).Length;

src\Shared\ServerInfrastructure\DuplexPipeStream.cs (1)

135var count = (int)Math.Min(readableBuffer.Length, destination.Length);

src\Shared\ServerInfrastructure\Http2\Http2FrameReader.cs (2)

43if (buffer.Length < HeaderLength) 59if (buffer.Length < frameLength)

src\Shared\Http2cat\Http2Utilities.cs (2)

846Assert.True(buffer.Length > 0); 866_bytesReceived += buffer.Slice(buffer.Start, consumed).Length;

src\Shared\ServerInfrastructure\DuplexPipeStream.cs (1)

135var count = (int)Math.Min(readableBuffer.Length, destination.Length);

src\Shared\ServerInfrastructure\Http2\Http2FrameReader.cs (2)

43if (buffer.Length < HeaderLength) 59if (buffer.Length < frameLength)

src\Shared\Http2cat\Http2Utilities.cs (2)

846Assert.True(buffer.Length > 0); 866_bytesReceived += buffer.Slice(buffer.Start, consumed).Length;

src\Shared\ServerInfrastructure\DuplexPipeStream.cs (1)

135var count = (int)Math.Min(readableBuffer.Length, destination.Length);

src\Shared\ServerInfrastructure\Http2\Http2FrameReader.cs (2)

43if (buffer.Length < HeaderLength) 59if (buffer.Length < frameLength)

src\Shared\Http2cat\Http2Utilities.cs (2)

846Assert.True(buffer.Length > 0); 866_bytesReceived += buffer.Slice(buffer.Start, consumed).Length;

src\Shared\ServerInfrastructure\DuplexPipeStream.cs (1)

135var count = (int)Math.Min(readableBuffer.Length, destination.Length);

src\Shared\ServerInfrastructure\Http2\Http2FrameReader.cs (2)

43if (buffer.Length < HeaderLength) 59if (buffer.Length < frameLength)

src\Shared\ServerInfrastructure\DuplexPipeStream.cs (1)

135var count = (int)Math.Min(readableBuffer.Length, destination.Length);

src\Shared\ServerInfrastructure\Http2\Http2FrameReader.cs (2)

43if (buffer.Length < HeaderLength) 59if (buffer.Length < frameLength)

src\Shared\Http2cat\Http2Utilities.cs (2)

846Assert.True(buffer.Length > 0); 866_bytesReceived += buffer.Slice(buffer.Start, consumed).Length;

src\Shared\ServerInfrastructure\DuplexPipeStream.cs (1)

135var count = (int)Math.Min(readableBuffer.Length, destination.Length);

src\Shared\ServerInfrastructure\Http2\Http2FrameReader.cs (2)

43if (buffer.Length < HeaderLength) 59if (buffer.Length < frameLength)

Http2\Http2ConnectionTests.cs (2)

1404while (readResult.Buffer.Length != _maxData.Length * 4) 1413Assert.Equal(readResult.Buffer.Length, _maxData.Length * 5);

Http2\Http2StreamTests.cs (26)

Http2\Http2TestBase.cs (2)

1240Assert.True(buffer.Length > 0); 1260_bytesReceived += copyBuffer.Slice(copyBuffer.Start, consumed).Length;

Http3\Http3StreamTests.cs (5)

631Assert.Equal(12, readResult.Buffer.Length); 3080Assert.Equal(sendSize, res.Buffer.Length); 3086Assert.Equal(sendSize - 1, res.Buffer.Length); 3174for (var i = 0; i < res.Buffer.Length; i++) 3299for (var i = 0; i < res.Buffer.Length; i++)

KestrelMetricsTests.cs (2)

176Assert.True(result.Buffer.Length > 0); 177Assert.Equal(result.Buffer.ToSpan(), "Hello World?"u8[..(int)result.Buffer.Length]);

RequestTests.cs (9)

1019Assert.Equal(5, readResult.Buffer.Length); 1051Assert.Equal(5, readResult.Buffer.Length); 1054Assert.Equal(5, readResult.Buffer.Length); 1086Assert.Equal(5, readResult.Buffer.Length); 1092Assert.Equal(5, readResult.Buffer.Length); 1167while (!result.IsCompleted && result.Buffer.Length < numBytes) 1173if (result.Buffer.Length < numBytes) 1185Assert.Equal(3, readResult.Buffer.Length); 1197Assert.Equal(5, readResult.Buffer.Length);

src\Servers\Kestrel\shared\test\Http3\Http3InMemory.cs (3)

560if (buffer.Length == 0) 577if (!result.IsCompleted || buffer.Length > 0) 597BytesReceived += copyBuffer.Slice(copyBuffer.Start, consumed).Length;

TlsListenerTests.cs (4)

45Logger.LogDebug("[Received TlsClientHelloBytesCallback] Connection: {0}; TLS client hello buffer: {1}", connection.ConnectionId, clientHelloBytes.Length); 47Assert.True(clientHelloBytes.Length > 32); 88Logger.LogDebug("[Received TlsClientHelloBytesCallback] Connection: {0}; TLS client hello buffer: {1}", connection.ConnectionId, clientHelloBytes.Length); 90Assert.True(clientHelloBytes.Length > 32);

HttpClientHttp2InteropTests.cs (5)

274while (!readResult.IsCompleted && readResult.Buffer.Length < "Hello World".Length) 287Assert.True(finalResult.IsCompleted && finalResult.Buffer.Length == 0); 331while (!readResult.IsCompleted && readResult.Buffer.Length < "Hello World".Length) 347while (!readResult.IsCompleted && readResult.Buffer.Length < "Hello World".Length) 358Assert.True(finalResult.IsCompleted && finalResult.Buffer.Length == 0);

BlazorPack\BlazorPackHubProtocolWorker.cs (1)

44else if (bytes.Value.Length == 0)

BlazorPack\SequenceOfT.cs (2)

95public long Length => this.AsReadOnlySequence.Length; 100private string DebuggerDisplay => $"Length = {AsReadOnlySequence.Length}";

src\SignalR\common\Shared\BinaryMessageParser.cs (3)

36var lengthPrefixBuffer = buffer.Slice(0, Math.Min(MaxLengthPrefixSize, buffer.Length)); 46while (numBytes < lengthPrefixBuffer.Length && ((byteRead & 0x80) != 0)); 61if (buffer.Length < length + numBytes)

src\submodules\MessagePack-CSharp\src\MessagePack.UnityClient\Assets\Scripts\MessagePack\ExtensionResult.cs (1)

32public ExtensionHeader Header => new ExtensionHeader(this.TypeCode, (uint)this.Data.Length);

src\submodules\MessagePack-CSharp\src\MessagePack.UnityClient\Assets\Scripts\MessagePack\MessagePackWriter.cs (2)

763int length = (int)src.Length; 839var length = (int)utf8stringBytes.Length;

src\submodules\MessagePack-CSharp\src\MessagePack.UnityClient\Assets\Scripts\MessagePack\SequenceReader.cs (1)

171this.length = this.Sequence.Length;

Internal\Transports\LongPollingServerTransport.cs (2)

52Log.LongPollingWritingMessage(_logger, buffer.Length); 54context.Response.ContentLength = buffer.Length;

Internal\Transports\ServerSentEventsServerTransport.cs (1)

63Log.SSEWritingMessage(_logger, buffer.Length);

Internal\Transports\WebSocketsServerTransport.cs (1)

226Log.SendPayload(_logger, buffer.Length);

ServerSentEventsMessageFormatter.cs (3)

20if (payload.Length > 0) 50var totalLength = source.Length; 84if (lineSegment.Length > 1)

Internal\SendUtils.cs (2)

40Log.SendingMessages(logger, buffer.Length, sendUrl); 107length = _buffer.Length;

Internal\WebSocketsTransport.cs (1)

558Log.ReceivedFromApp(_logger, buffer.Length);

RequestDelegateGenerator\RequestDelegateCreationTests.JsonBody.cs (4)

250Assert.Equal(requestBodyBytes.Length, result.Buffer.Length); 291Assert.Equal(requestBodyBytes.Length, result.Buffer.Length); 332Assert.Equal(0, result.Buffer.Length); 373Assert.Equal(0, result.Buffer.Length);

CacheEntryHelpers.cs (1)

29size += cachedResponse.Body.Length;

OutputCacheEntry.cs (1)

116headers.ContentLength = Body.Length;

OutputCacheEntryFormatter.cs (1)

179writer.Write7BitEncodedInt(checked((int)body.Length));

OutputCacheMiddleware.cs (2)

427if (!contentLength.HasValue || contentLength == cachedResponseBody.Length 428|| (cachedResponseBody.Length == 0

EndToEndBenchmarks.cs (1)

193if (body.Length != PayloadLength)

RedisOutputCacheStore.cs (1)

256int len = checked((int)value.Length);

OutputCacheEntryFormatterTests.cs (3)

170Assert.Equal(expected.Body.Length, actual.Body.Length); 198var len = checked((int)value.Length);

src\Shared\Http2cat\Http2Utilities.cs (2)

846Assert.True(buffer.Length > 0); 866_bytesReceived += buffer.Slice(buffer.Start, consumed).Length;

src\Shared\ServerInfrastructure\DuplexPipeStream.cs (1)

135var count = (int)Math.Min(readableBuffer.Length, destination.Length);

src\Shared\ServerInfrastructure\Http2\Http2FrameReader.cs (2)

43if (buffer.Length < HeaderLength) 59if (buffer.Length < frameLength)

Core\IISHttpContext.IO.cs (1)

36var actual = Math.Min(readableBuffer.Length, memory.Length);

Core\IO\AsyncWriteOperationBase.cs (2)

28if (_buffer.Length > int.MaxValue) 36var bufferLength = (int)_buffer.Length;

src\Shared\ServerInfrastructure\DuplexPipeStream.cs (1)

135var count = (int)Math.Min(readableBuffer.Length, destination.Length);

Internal\Http\Http1ChunkedEncodingMessageBody.cs (8)

49CountBytesRead(readResult.Buffer.Length); 74StopTimingRead(_readResult.Buffer.Length); 362AddAndCheckObservedBytes(buffer.Length); 367var charsToByteCRExclusive = buffer.Slice(0, extensionCursor).Length; 370if (suffixBuffer.Length < 2) 402var actual = Math.Min(buffer.Length, _inputLength); 421if (buffer.Length < 2) 449if (buffer.Length < 2)

Internal\Http\Http1Connection.cs (1)

861&& requestData.Length >= PrefaceLineLength)

Internal\Http\Http1ContentLengthMessageBody.cs (1)

187var initialLength = _readResult.Buffer.Length;

Internal\Http\HttpParser.cs (1)

378if (headerLength == currentSlice.Length - 1)

Internal\Http\HttpRequestStream.cs (1)

126var length = buffer.Length;

Internal\Http\MessageBody.cs (4)

286examinedLength = readResult.Buffer.Slice(readResult.Buffer.Start, examined).Length; 291consumedLength = readResult.Buffer.Slice(readResult.Buffer.Start, consumed).Length; 292examinedLength = consumedLength + readResult.Buffer.Slice(consumed, examined).Length; 301totalLength = readResult.Buffer.Length;

Internal\Http2\Http2Connection.cs (6)

564if (readableBuffer.Length >= ClientPreface.Length) 637var reader = new SequenceReader<byte>(buffer.Length > Limits.MaxRequestLineSize ? buffer.Slice(0, Limits.MaxRequestLineSize) : buffer); 650if (buffer.Length > Limits.MaxRequestLineSize) 663Debug.Assert(buffer.Length >= ClientPreface.Length, "Not enough content to match preface."); 1859if ((readResult.IsCompleted && readResult.Buffer.Length == 0) || readResult.IsCanceled) 1867var copyAmount = (int)Math.Min(outputBuffer.Length, readResult.Buffer.Length);

Internal\Http2\Http2FrameWriter.cs (9)

196var actual = producer.CheckStreamWindow(buffer.Length); 213if (actual < buffer.Length) 233(var hasMoreData, var reschedule, currentState, var waitingForWindowUpdates) = producer.ObserveDataAndState(buffer.Length, observed); 282if (buffer.Length != 0) 302flushResult = await WriteDataAsync(stream, buffer, buffer.Length, endStream, flushHeaders); 566var dataLength = data.Length; 717Debug.Assert(dataLength == data.Length); 744Debug.Assert(dataLength == data.Length); 967Debug.Assert(payload.Length == _outgoingFrame.PayloadLength); // 8

Internal\Http2\Http2MessageBody.cs (2)

93CountBytesRead(readResult.Buffer.Length); 120StopTimingRead(_readResult.Buffer.Length);

Internal\Http2\Http2Stream.cs (4)

473if (dataPayload.Length > 0) 486_inputFlowControl.Advance((int)dataPayload.Length); 493if (dataPayload.Length > InputRemaining.Value) 498InputRemaining -= dataPayload.Length;

Internal\Http3\Http3ControlStream.cs (6)

274Debug.Assert(incomingFrame.RemainingLength >= framePayload.Length); 285if (incomingFrame.RemainingLength == framePayload.Length) 287Debug.Assert(framePayload.Slice(0, consumed).Length == framePayload.Length); 294incomingFrame.RemainingLength -= framePayload.Slice(0, consumed).Length; 495if (incomingFrame.RemainingLength > payload.Slice(0, consumed).Length)

Internal\Http3\Http3FrameReader.cs (1)

51length = Math.Min(startOfFramePayload.Length, length);

Internal\Http3\Http3FrameWriter.cs (3)

163var dataLength = data.Length; 179Debug.Assert(dataLength == data.Length); 202Debug.Assert(dataLength == data.Length);

Internal\Http3\Http3MessageBody.cs (2)

61CountBytesRead(readResult.Buffer.Length); 88StopTimingRead(_readResult.Buffer.Length);

Internal\Http3\Http3OutputProducer.cs (2)

427if (readResult.Buffer.Length > 0) 437if (readResult.Buffer.Length != 0)

Internal\Http3\Http3Stream.cs (4)

635incomingFrame.RemainingLength -= framePayload.Length; 805var endHeaders = payload.Length == incomingFrame.RemainingLength; 917if (payload.Length > InputRemaining.Value) 922InputRemaining -= payload.Length;

Middleware\TlsListener.cs (4)

37if (result.IsCompleted && buffer.Length < 6) 92if (recordLength != -1 && buffer.Length < 5 + recordLength) 104if (buffer.Length < 6) 139if (buffer.Length < 5 + recordLength)

src\Shared\ServerInfrastructure\DuplexPipeStream.cs (1)

135var count = (int)Math.Min(readableBuffer.Length, destination.Length);

src\Shared\ServerInfrastructure\Http2\Http2FrameReader.cs (2)

43if (buffer.Length < HeaderLength) 59if (buffer.Length < frameLength)

BufferWriterTests.cs (1)

206Assert.Equal(13, readResult.Buffer.Length);

Http2\Http2FrameWriterTests.cs (1)

107if (!buffer.IsEmpty && buffer.Length >= length)

HttpParserTests.cs (2)

266Assert.Equal(buffer.Length, buffer.Slice(reader.Consumed).Length);

MessageBodyTests.cs (8)

71Assert.Equal(5, readResult.Buffer.Length); 98Assert.Equal(5, readResult.Buffer.Length); 740Assert.Equal(1, readResult.Buffer.Length); 767Assert.Equal(1, readResult.Buffer.Length); 896Assert.Equal(6, readResult.Buffer.Length); 902Assert.Equal(6, readResult.Buffer.Length); 956Assert.Equal(1, readResult.Buffer.Length); 1416Assert.Equal(bytes.Length, actual.Length);

PipelineExtensionTests.cs (2)

124Assert.Equal(0, reader.Buffer.Length); 144Assert.Equal(input.Length, reader.Buffer.Length);

TlsListenerTests.cs (5)

154Assert.Equal(5, readResult.Buffer.Length); 183Assert.Equal(fullLength, data.Length); 210Assert.Equal(fullLength, readResult.Buffer.Length); 234Assert.Equal(packetBytes.Length, data.Length); 247Assert.Equal(packetBytes.Length, readResult.Buffer.Length);

InMemoryTransportBenchmark.cs (2)

198length -= (int)buffer.Length; 220if (buffer.Length >= length)

PipeThroughputBenchmark.cs (1)

45remaining -= result.Buffer.Length;

src\Servers\Kestrel\shared\test\Http3\Http3InMemory.cs (3)

560if (buffer.Length == 0) 577if (!result.IsCompleted || buffer.Length > 0) 597BytesReceived += copyBuffer.Slice(copyBuffer.Start, consumed).Length;

src\Shared\ServerInfrastructure\DuplexPipeStream.cs (1)

135var count = (int)Math.Min(readableBuffer.Length, destination.Length);

src\Shared\ServerInfrastructure\Http2\Http2FrameReader.cs (2)

43if (buffer.Length < HeaderLength) 59if (buffer.Length < frameLength)

HubConnection.cs (1)

1652Log.ProcessingMessage(_logger, buffer.Length);

Internal\Formatters\BinaryMessageParserTests.cs (4)

23Assert.Equal(0, span.Length); 58Assert.Equal(0, span.Length); 105Assert.Equal(0, buffer.Length); 119Assert.Equal(encoded.Length, buffer.Length);

src\SignalR\common\Shared\BinaryMessageParser.cs (3)

36var lengthPrefixBuffer = buffer.Slice(0, Math.Min(MaxLengthPrefixSize, buffer.Length)); 46while (numBytes < lengthPrefixBuffer.Length && ((byteRead & 0x80) != 0)); 61if (buffer.Length < length + numBytes)

HubConnectionContext.cs (1)

530if (_maxMessageSize != null && buffer.Length > _maxMessageSize.Value)

HubConnectionHandler.cs (1)

312if (segment.Length > maxMessageSize)

src\SignalR\common\Http.Connections\src\ServerSentEventsMessageFormatter.cs (3)

20if (payload.Length > 0) 50var totalLength = source.Length; 84if (lineSegment.Length > 1)

src\SignalR\common\Shared\BinaryMessageParser.cs (3)

36var lengthPrefixBuffer = buffer.Slice(0, Math.Min(MaxLengthPrefixSize, buffer.Length)); 46while (numBytes < lengthPrefixBuffer.Length && ((byteRead & 0x80) != 0)); 61if (buffer.Length < length + numBytes)

src\SignalR\common\Shared\BinaryMessageParser.cs (3)

36var lengthPrefixBuffer = buffer.Slice(0, Math.Min(MaxLengthPrefixSize, buffer.Length)); 46while (numBytes < lengthPrefixBuffer.Length && ((byteRead & 0x80) != 0)); 61if (buffer.Length < length + numBytes)

PipeReaderExtensions.cs (2)

58if (result.Buffer.Length < numBytes) 90if (result.Buffer.Length < numBytes)

ResponseBodyReaderStream.cs (1)

102var actual = Math.Min(readableBuffer.Length, buffer.Length);

FormPipeReader.cs (8)

263sequenceReader.Advance(keyValuePair.Length); 280if (key.Length > KeyLengthLimit) 286if (value.Length > ValueLengthLimit) 294if (keyValuePair.Length > KeyLengthLimit) 352if (ros.Length < StackAllocThreshold) 354Span<byte> buffer = stackalloc byte[StackAllocThreshold].Slice(0, (int)ros.Length); 360var byteArray = ArrayPool<byte>.Shared.Rent((int)ros.Length); 364Span<byte> buffer = byteArray.AsSpan(0, (int)ros.Length);

Protocol\Internal\Converters\VSInternalExtensionUtilities.cs (1)

82var valueLength = reader.HasValueSequence ? reader.ValueSequence.Length : reader.ValueSpan.Length;

Embeddings\BinaryEmbedding.cs (1)

64int length = reader.HasValueSequence ? checked((int)reader.ValueSequence.Length) : reader.ValueSpan.Length;

Internal\HybridCachePayload.cs (1)

106int payloadLength = checked((int)payload.Length);

Internal\InbuiltTypeSerializer.cs (1)

42int length = checked((int)source.Length);

DistributedCacheTests.cs (1)

319Assert.Equal(size, payload.Length);

SerializerTests.cs (1)

306if (!value.IsSingleSegment || value.Length <= 1)

SqlServerCache.cs (1)

249var length = checked((int)value.Length);

RedisCache.cs (1)

140var length = checked((int)value.Length);

System\IO\Pipelines\PipeReader.cs (1)

73if (buffer.Length >= minimumSize || result.IsCompleted || result.IsCanceled)

System\IO\Pipelines\PipeReaderStream.cs (1)

119long bufferLength = sequence.Length;

System\IO\Pipelines\SequencePipeReader.cs (1)

79if (isCancellationRequested || _sequence.Length > 0)

System\IO\Pipelines\StreamPipeReader.cs (1)

226|| readResult.Buffer.Length >= minimumSize

System\Buffers\BuffersExtensions.cs (2)

80if (sequence.Length > destination.Length) 104var array = new T[sequence.Length];

System\Buffers\ReadOnlySequence.cs (4)

36public bool IsEmpty => Length == 0; 501if (Length < int.MaxValue) 503return string.Create((int)Length, charSequence, (span, sequence) => sequence.CopyTo(span)); 507return $"System.Buffers.ReadOnlySequence<{typeof(T).Name}>[{Length}]";

System\Buffers\SequenceReader.cs (1)

102Unsafe.AsRef(in _length) = Sequence.Length;

System\Buffers\SequenceReader.Search.cs (2)

78Debug.Assert(sequence.Length > 0); 439Debug.Assert(sequence.Length > 0);

System\Text\Json\Document\JsonDocument.Parse.cs (3)

86int length = checked((int)utf8Json.Length); 599payloadLength += reader.ValueSequence.Length; 644int length = valueSpan.IsEmpty ? checked((int)valueSequence.Length) : valueSpan.Length;

System\Text\Json\Reader\JsonReaderHelper.Unescaping.cs (3)

124Debug.Assert(utf8Source.Length >= other.Length && utf8Source.Length / JsonConstants.MaxExpansionFactorWhileEscaping <= other.Length); 129int length = checked((int)utf8Source.Length);

System\Text\Json\Reader\Utf8JsonReader.cs (4)

55internal readonly int ValueLength => HasValueSequence ? checked((int)ValueSequence.Length) : ValueSpan.Length; 587if (localSequence.Length != other.Length) 637long sequenceLength = localSequence.Length; 729long sourceLength = ValueSequence.Length;

System\Text\Json\Reader\Utf8JsonReader.MultiSegment.cs (1)

2202commentSequence = commentSequence.Slice(2, commentSequence.Length - 2 - tailBytesToIgnore);

System\Text\Json\Reader\Utf8JsonReader.TryGet.cs (6)

100bytesWritten = (int)valueSequence.Length; 169valueLength = checked((int)valueSequence.Length); 206int sequenceLength = checked((int)valueSequence.Length); 1250long sequenceLength = ValueSequence.Length; 1295long sequenceLength = ValueSequence.Length; 1341long sequenceLength = ValueSequence.Length;

System\Text\Json\Serialization\JsonSerializer.Read.Utf8JsonReader.cs (1)

419? reader.ValueSequence.Length + 2

System\Text\Json\Writer\Utf8JsonWriter.WriteValues.Raw.cs (1)

141long utf8JsonLen = utf8Json.Length;