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

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

			IAsyncResult result = null;
			try {
				result = nstream.BeginWrite (buffer, offset, size, cb, state);
			} catch (Exception) {
				status = WebExceptionStatus.SendFailure;
				throw;
			}

			return result;
		}

        public override IAsyncResult BeginWrite(byte[] buffer, int offset, int size, AsyncCallback cb, object state)
        {
            if (request.Aborted)
            {
                throw new WebException("The request was canceled.", null, WebExceptionStatus.RequestCanceled);
            }
            if (isRead)
            {
                throw new NotSupportedException("this stream does not allow writing");
            }
            if (buffer == null)
            {
                throw new ArgumentNullException("buffer");
            }
            int num = buffer.Length;

            if (offset < 0 || num < offset)
            {
                throw new ArgumentOutOfRangeException("offset");
            }
            if (size < 0 || num - offset < size)
            {
                throw new ArgumentOutOfRangeException("size");
            }
            if (sendChunked)
            {
                lock (locker)
                {
                    pendingWrites++;
                    pending.Reset();
                }
            }
            WebAsyncResult webAsyncResult = new WebAsyncResult(cb, state);

            if (!sendChunked)
            {
                CheckWriteOverflow(request.ContentLength, totalWritten, size);
            }
            if (allowBuffering && !sendChunked)
            {
                if (writeBuffer == null)
                {
                    writeBuffer = new MemoryStream();
                }
                writeBuffer.Write(buffer, offset, size);
                totalWritten += size;
                if (request.ContentLength > 0 && totalWritten == request.ContentLength)
                {
                    try
                    {
                        webAsyncResult.AsyncWriteAll    = true;
                        webAsyncResult.InnerAsyncResult = WriteRequestAsync(WriteRequestAsyncCB, webAsyncResult);
                        if (webAsyncResult.InnerAsyncResult != null)
                        {
                            return(webAsyncResult);
                        }
                        if (!webAsyncResult.IsCompleted)
                        {
                            webAsyncResult.SetCompleted(synch: true, 0);
                        }
                        webAsyncResult.DoCallback();
                        return(webAsyncResult);
                    }
                    catch (Exception e)
                    {
                        webAsyncResult.SetCompleted(synch: true, e);
                        webAsyncResult.DoCallback();
                        return(webAsyncResult);
                    }
                }
                webAsyncResult.SetCompleted(synch: true, 0);
                webAsyncResult.DoCallback();
                return(webAsyncResult);
            }
            AsyncCallback cb2 = null;

            if (cb != null)
            {
                cb2 = WriteCallbackWrapper;
            }
            if (sendChunked)
            {
                WriteRequest();
                string s     = $"{size:X}\r\n";
                byte[] bytes = Encoding.ASCII.GetBytes(s);
                int    num2  = 2 + size + bytes.Length;
                byte[] array = new byte[num2];
                Buffer.BlockCopy(bytes, 0, array, 0, bytes.Length);
                Buffer.BlockCopy(buffer, offset, array, bytes.Length, size);
                Buffer.BlockCopy(crlf, 0, array, bytes.Length + size, crlf.Length);
                buffer = array;
                offset = 0;
                size   = num2;
            }
            webAsyncResult.InnerAsyncResult = cnc.BeginWrite(request, buffer, offset, size, cb2, webAsyncResult);
            totalWritten += size;
            return(webAsyncResult);
        }