System.Net.Sockets.Socket.ReceiveFromAsync C# (CSharp) Method

        public bool ReceiveFromAsync(SocketAsyncEventArgs e)
        {
            if (NetEventSource.IsEnabled) NetEventSource.Enter(this, e);
            bool retval;

            if (CleanedUp)
            {
                throw new ObjectDisposedException(GetType().FullName);
            }

            if (e == null)
            {
                throw new ArgumentNullException(nameof(e));
            }
            if (e.RemoteEndPoint == null)
            {
                throw new ArgumentNullException("RemoteEndPoint");
            }
            if (!CanTryAddressFamily(e.RemoteEndPoint.AddressFamily))
            {
                throw new ArgumentException(SR.Format(SR.net_InvalidEndPointAddressFamily, e.RemoteEndPoint.AddressFamily, _addressFamily), "RemoteEndPoint");
            }

            SocketPal.CheckDualModeReceiveSupport(this);

            // We don't do a CAS demand here because the contents of remoteEP aren't used by
            // WSARecvFrom; all that matters is that we generate a unique-to-this-call SocketAddress
            // with the right address family.
            EndPoint endPointSnapshot = e.RemoteEndPoint;
            e._socketAddress = SnapshotAndSerialize(ref endPointSnapshot);

            // DualMode sockets may have updated the endPointSnapshot, and it has to have the same AddressFamily as 
            // e.m_SocketAddres for Create to work later.
            e.RemoteEndPoint = endPointSnapshot;

            // Prepare for the native call.
            e.StartOperationCommon(this);
            e.StartOperationReceiveFrom();

            // Make the native call.
            SocketFlags flags;
            int bytesTransferred;
            SocketError socketError;

            try
            {
                socketError = e.DoOperationReceiveFrom(_handle, out flags, out bytesTransferred);
            }
            catch
            {
                // Clear in-use flag on event args object. 
                e.Complete();
                throw;
            }

            // Handle completion when completion port is not posted.
            if (socketError != SocketError.Success && socketError != SocketError.IOPending)
            {
                e.FinishOperationSyncFailure(socketError, bytesTransferred, flags);
                retval = false;
            }
            else
            {
                retval = true;
            }

            if (NetEventSource.IsEnabled) NetEventSource.Exit(this, retval);
            return retval;
        }

        /// <summary>
        /// Create a UdpCommunication object using an existing Socket.
        /// </summary>
        public UdpCommunication(Socket socket, IPEndPoint endPoint)
        {
            _socket = socket;
            _endPoint = endPoint;

            // Start asynchronous read
            try
            {
                _receiveArgs = new SocketAsyncEventArgs();
                _receiveArgs.UserToken = _socket;
                _receiveArgs.RemoteEndPoint = _endPoint;
                _readBuffer = new byte[READBUFFERSIZE];
                _receiveArgs.SetBuffer(_readBuffer, 0, _readBuffer.Length);
                _receiveArgs.Completed += new EventHandler<SocketAsyncEventArgs>(_socket_ReceivedData);
                if (_socket.ReceiveFromAsync(_receiveArgs) == false)  // Returns true if the I/O operation is pending. Returns false if the I/O operation completed synchronously and the SocketAsyncEventArgs.Completed event will not be raised.
                    _socket_ReceivedData(_socket, _receiveArgs);
            }
            catch (Exception ex)
            {
                // On failure free up the SocketAsyncEventArgs
                if (_receiveArgs != null)
                {
                    _receiveArgs.Completed -= new EventHandler<SocketAsyncEventArgs>(_socket_ReceivedData);
                    _receiveArgs.Dispose();
                    _receiveArgs = null;
                }

                throw;
            }
        }