Select()

static unsafe SocketError System.Net.Sockets.SocketPal.Select ( IList checkRead, IList checkWrite, IList checkError, int microseconds )

inlinestatic

Definition at line 711 of file SocketPal.cs.

    {
        IntPtr[] lease2 = null;
        IntPtr[] lease3 = null;
        IntPtr[] lease4 = null;
        int refsAdded = 0;
        try
        {
            Span<IntPtr> span2;
            Span<IntPtr> span3 = ((!ShouldStackAlloc(checkRead, ref lease2, out span2)) ? span2 : stackalloc IntPtr[64]);
            Span<IntPtr> span4 = span3;
            Socket.SocketListToFileDescriptorSet(checkRead, span4, ref refsAdded);
            Span<IntPtr> span5 = ((!ShouldStackAlloc(checkWrite, ref lease3, out span2)) ? span2 : stackalloc IntPtr[64]);
            Span<IntPtr> span6 = span5;
            Socket.SocketListToFileDescriptorSet(checkWrite, span6, ref refsAdded);
            Span<IntPtr> span7 = ((!ShouldStackAlloc(checkError, ref lease4, out span2)) ? span2 : stackalloc IntPtr[64]);
            Span<IntPtr> span8 = span7;
            Socket.SocketListToFileDescriptorSet(checkError, span8, ref refsAdded);
            int num;
            fixed (IntPtr* readfds = &MemoryMarshal.GetReference(span4))
            {
                fixed (IntPtr* writefds = &MemoryMarshal.GetReference(span6))
                {
                    fixed (IntPtr* exceptfds = &MemoryMarshal.GetReference(span8))
                    {
                        if (microseconds != -1)
                        {
                            global::Interop.Winsock.TimeValue socketTime = default(global::Interop.Winsock.TimeValue);
                            MicrosecondsToTimeValue((uint)microseconds, ref socketTime);
                            num = global::Interop.Winsock.select(0, readfds, writefds, exceptfds, ref socketTime);
                        }
                        else
                        {
                            num = global::Interop.Winsock.select(0, readfds, writefds, exceptfds, IntPtr.Zero);
                        }
                    }
                }
            }
            if (System.Net.NetEventSource.Log.IsEnabled())
            {
                System.Net.NetEventSource.Info(null, $"Interop.Winsock.select returns socketCount:{num}", "Select");
            }
            if (num == -1)
            {
                return GetLastSocketError();
            }
            Socket.SelectFileDescriptor(checkRead, span4, ref refsAdded);
            Socket.SelectFileDescriptor(checkWrite, span6, ref refsAdded);
            Socket.SelectFileDescriptor(checkError, span8, ref refsAdded);
            return SocketError.Success;
        }
        finally
        {
            if (lease2 != null)
            {
                ArrayPool<IntPtr>.Shared.Return(lease2);
            }
            if (lease3 != null)
            {
                ArrayPool<IntPtr>.Shared.Return(lease3);
            }
            if (lease4 != null)
            {
                ArrayPool<IntPtr>.Shared.Return(lease4);
            }
            Socket.SocketListDangerousReleaseRefs(checkRead, ref refsAdded);
            Socket.SocketListDangerousReleaseRefs(checkWrite, ref refsAdded);
            Socket.SocketListDangerousReleaseRefs(checkError, ref refsAdded);
        }
        static bool ShouldStackAlloc(IList list, ref IntPtr[] lease, out Span<IntPtr> span)
        {
            int count;
            if (list == null || (count = list.Count) == 0)
            {
                span = default(Span<IntPtr>);
                return false;
            }
            if (count >= 64)
            {
                span = (lease = ArrayPool<IntPtr>.Shared.Rent(count + 1));
                return false;
            }
            span = default(Span<IntPtr>);
            return true;
        }
    }

References System.count, System.Net.Sockets.SocketPal.GetLastSocketError(), System.Net.NetEventSource.Info(), System.list, System.Net.NetEventSource.Log, System.Net.Sockets.SocketPal.MicrosecondsToTimeValue(), System.Net.Sockets.Socket.SelectFileDescriptor(), System.Net.Sockets.Socket.SocketListDangerousReleaseRefs(), System.Net.Sockets.Socket.SocketListToFileDescriptorSet(), and System.IntPtr.Zero.

Referenced by System.Net.Sockets.Socket.Select().