System.Net.WebConnection.Read C# (CSharp) Method

		internal int Read (HttpWebRequest request, byte [] buffer, int offset, int size)
		{
			lock (this) {
				if (Data.request != request)
					throw new ObjectDisposedException (typeof (NetworkStream).FullName);
				if (nstream == null)
					return 0;
			}

			int result = 0;
			try {
				bool done = false;
				if (!chunkedRead) {
					result = nstream.Read (buffer, offset, size);
					done = (result == 0);
				}

				if (chunkedRead) {
					try {
						chunkStream.WriteAndReadBack (buffer, offset, size, ref result);
						if (!done && result == 0 && chunkStream.WantMore)
							result = EnsureRead (buffer, offset, size);
					} catch (Exception e) {
						HandleError (WebExceptionStatus.ReceiveFailure, e, "chunked Read1");
						throw;
					}

					if ((done || result == 0) && chunkStream.WantMore) {
						HandleError (WebExceptionStatus.ReceiveFailure, null, "chunked Read2");
						throw new WebException ("Read error", null, WebExceptionStatus.ReceiveFailure, null);
					}
				}
			} catch (Exception e) {
				HandleError (WebExceptionStatus.ReceiveFailure, e, "Read");
			}

			return result;
		}

        internal void ReadAll()
        {
            if (!isRead || read_eof || totalRead >= contentLength || nextReadCalled)
            {
                if (isRead && !nextReadCalled)
                {
                    nextReadCalled = true;
                    cnc.NextRead();
                }
                return;
            }

            if (!pending.WaitOne(ReadTimeout))
            {
                throw new WebException("The operation has timed out.", WebExceptionStatus.Timeout);
            }
            lock (locker) {
                if (totalRead >= contentLength)
                {
                    return;
                }

                byte [] b    = null;
                int     diff = readBufferSize - readBufferOffset;
                int     new_size;

                if (contentLength == Int64.MaxValue)
                {
                    MemoryStream ms     = new MemoryStream();
                    byte []      buffer = null;
                    if (readBuffer != null && diff > 0)
                    {
                        ms.Write(readBuffer, readBufferOffset, diff);
                        if (readBufferSize >= 8192)
                        {
                            buffer = readBuffer;
                        }
                    }

                    if (buffer == null)
                    {
                        buffer = new byte [8192];
                    }

                    int read;
                    while ((read = cnc.Read(request, buffer, 0, buffer.Length)) != 0)
                    {
                        ms.Write(buffer, 0, read);
                    }

                    b             = ms.GetBuffer();
                    new_size      = (int)ms.Length;
                    contentLength = new_size;
                }
                else
                {
                    new_size = (int)(contentLength - totalRead);
                    b        = new byte [new_size];
                    if (readBuffer != null && diff > 0)
                    {
                        if (diff > new_size)
                        {
                            diff = new_size;
                        }

                        Buffer.BlockCopy(readBuffer, readBufferOffset, b, 0, diff);
                    }

                    int remaining = new_size - diff;
                    int r         = -1;
                    while (remaining > 0 && r != 0)
                    {
                        r          = cnc.Read(request, b, diff, remaining);
                        remaining -= r;
                        diff      += r;
                    }
                }

                readBuffer       = b;
                readBufferOffset = 0;
                readBufferSize   = new_size;
                totalRead        = 0;
                nextReadCalled   = true;
            }

            cnc.NextRead();
        }