Length

Otlp\Http\OtlpHttpEndpointsBuilder.cs (1)

266if (result.Buffer.Length > MaxRequestSize)

BlazorPack\BlazorPackHubProtocolWorker.cs (1)

BlazorPack\SequenceOfT.cs (2)

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

src\aspnetcore\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\aspnetcore\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\aspnetcore\src\submodules\MessagePack-CSharp\src\MessagePack.UnityClient\Assets\Scripts\MessagePack\MessagePackWriter.cs (2)

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

src\aspnetcore\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);

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)

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

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\aspnetcore\src\Shared\ServerInfrastructure\DuplexPipeStream.cs (1)

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

Internal\Http\Http1ChunkedEncodingMessageBody.cs (8)

52CountBytesRead(readResult.Buffer.Length); 77StopTimingRead(_readResult.Buffer.Length); 381AddAndCheckObservedBytes(buffer.Length); 387var charsToByteCRExclusive = buffer.Slice(0, extensionCursor).Length; 390if (suffixBuffer.Length < 2) 433var actual = Math.Min(buffer.Length, _inputLength); 452if (buffer.Length < 2) 480if (buffer.Length < 2)

Internal\Http\Http1Connection.cs (2)

1047parseResult.ErrorOffset + parseResult.ErrorLength <= buffer.Length) 1086&& requestData.Length >= PrefaceLineLength)

Internal\Http\Http1ContentLengthMessageBody.cs (1)

188var initialLength = _readResult.Buffer.Length;

Internal\Http\HttpParser.cs (2)

173if (length == currentSlice.Length - 1) 392if (_showErrorDetails && result.ErrorLength > 0 && result.ErrorOffset + result.ErrorLength <= buffer.Length)

Internal\Http\HttpRequestStream.cs (1)

127var 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)

568if (readableBuffer.Length >= ClientPreface.Length) 641var reader = new SequenceReader<byte>(buffer.Length > Limits.MaxRequestLineSize ? buffer.Slice(0, Limits.MaxRequestLineSize) : buffer); 654if (buffer.Length > Limits.MaxRequestLineSize) 667Debug.Assert(buffer.Length >= ClientPreface.Length, "Not enough content to match preface."); 1899if ((readResult.IsCompleted && readResult.Buffer.Length == 0) || readResult.IsCanceled) 1907var 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); 121StopTimingRead(_readResult.Buffer.Length);

Internal\Http2\Http2Stream.cs (4)

475if (dataPayload.Length > 0) 488_inputFlowControl.Advance((int)dataPayload.Length); 495if (dataPayload.Length > InputRemaining.Value) 500InputRemaining -= dataPayload.Length;

Internal\Http3\Http3ControlStream.cs (6)

275Debug.Assert(incomingFrame.RemainingLength >= framePayload.Length); 286if (incomingFrame.RemainingLength == framePayload.Length) 288Debug.Assert(framePayload.Slice(0, consumed).Length == framePayload.Length); 295incomingFrame.RemainingLength -= framePayload.Slice(0, consumed).Length; 486if (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); 89StopTimingRead(_readResult.Buffer.Length);

Internal\Http3\Http3OutputProducer.cs (2)

425if (readResult.Buffer.Length > 0) 435if (readResult.Buffer.Length != 0)

Internal\Http3\Http3Stream.cs (4)

663incomingFrame.RemainingLength -= framePayload.Length; 833var endHeaders = payload.Length == incomingFrame.RemainingLength; 947if (payload.Length > InputRemaining.Value) 952InputRemaining -= payload.Length;

Middleware\TlsListener.cs (4)

40if (result.IsCompleted && buffer.Length < 6) 95if (recordLength != -1 && buffer.Length < 5 + recordLength) 107if (buffer.Length < 6) 147if (buffer.Length < 5 + recordLength)

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

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

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

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

HubConnection.cs (1)

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

HubConnectionContext.cs (1)

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

HubConnectionHandler.cs (1)

383if (segment.Length > maxMessageSize)

src\aspnetcore\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)

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);

Embeddings\BinaryEmbedding.cs (1)

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

Internal\HybridCachePayload.cs (1)

104int 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)

228|| 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\ReadOnlySequenceStream.cs (10)

54return _sequence.Length; 71if (value >= _sequence.Length) 100if (_absolutePosition >= _sequence.Length) 106int n = (int)Math.Min(remaining.Length, buffer.Length); 162if (_absolutePosition >= _sequence.Length) 174_absolutePosition = _sequence.Length; 188if (_absolutePosition >= _sequence.Length) 205_absolutePosition = _sequence.Length; 229SeekOrigin.End => _sequence.Length, 242if (absolutePosition >= _sequence.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 (2)

398bytePositionInLine -= valueSequence.Length; 437? reader.ValueSequence.Length + 2

System\Text\Json\Serialization\Metadata\JsonTypeInfoOfT.ReadHelper.cs (2)

147Debug.Assert(reader.BytesConsumed <= bufferState.Bytes.Length); 148Debug.Assert(!bufferState.IsFinalBlock || reader.AllowMultipleValues || reader.BytesConsumed == bufferState.Bytes.Length,

System\Text\Json\Serialization\PipeReadBufferState.cs (2)

39long leftOver = _sequence.Length; 103if (_sequence.Length > 0)

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

141long utf8JsonLen = utf8Json.Length;