ET9_WebGL_Dev/CSharp/Platform/ENet/ESocket.cs

using System;
using System.Collections.Generic;
using System.Runtime.InteropServices;
using System.Threading.Tasks;

namespace ENet
{
    public sealed class ESocket: IDisposable
    {
        private IntPtr peerPtr = IntPtr.Zero;
        private readonly EService service;
        private readonly LinkedList<byte[]> recvBuffer = new LinkedList<byte[]>();

        public Action<EEvent> Connected { get; set; }
        public Action<EEvent> Received { get; set; }
        public Action<EEvent> Disconnect { get; set; }
        public Action<int> Error { get; set; }

        public ESocket(EService service)
        {
            this.service = service;
        }

        public void Dispose()
        {
            if (this.peerPtr == IntPtr.Zero)
            {
                return;
            }
            NativeMethods.EnetPeerReset(this.peerPtr);
            this.peerPtr = IntPtr.Zero;
        }

        public IntPtr PeerPtr
        {
            get
            {
                return this.peerPtr;
            }
            set
            {
                this.peerPtr = value;
            }
        }

        private ENetPeer Struct
        {
            get
            {
                if (this.peerPtr == IntPtr.Zero)
                {
                    return new ENetPeer();
                }
                return (ENetPeer) Marshal.PtrToStructure(this.peerPtr, typeof (ENetPeer));
            }
            set
            {
                Marshal.StructureToPtr(value, this.peerPtr, false);
            }
        }

        public PeerState State
        {
            get
            {
                if (this.peerPtr == IntPtr.Zero)
                {
                    return PeerState.Uninitialized;
                }
                return this.Struct.State;
            }
        }

        public void Ping()
        {
            NativeMethods.EnetPeerPing(this.peerPtr);
        }

        public void ConfigureThrottle(uint interval, uint acceleration, uint deceleration)
        {
            NativeMethods.EnetPeerThrottleConfigure(this.peerPtr, interval, acceleration,
                    deceleration);
        }

        public Task<bool> ConnectAsync(
                string hostName, ushort port,
                uint channelLimit = NativeMethods.ENET_PROTOCOL_MAXIMUM_CHANNEL_COUNT, uint data = 0)
        {
            if (channelLimit > NativeMethods.ENET_PROTOCOL_MAXIMUM_CHANNEL_COUNT)
            {
                throw new ArgumentOutOfRangeException("channelLimit");
            }

            var tcs = new TaskCompletionSource<bool>();
            var address = new Address { HostName = hostName, Port = port };
            ENetAddress nativeAddress = address.Struct;
            this.peerPtr = NativeMethods.EnetHostConnect(this.service.HostPtr, ref nativeAddress,
                    channelLimit, data);
            if (this.peerPtr == IntPtr.Zero)
            {
                throw new EException("host connect call failed.");
            }
            this.service.PeersManager.Add(this.peerPtr, this);
            this.Connected = eEvent =>
            {
                if (eEvent.EventState == EventState.DISCONNECTED)
                {
                    tcs.TrySetException(new EException("socket disconnected in connect"));
                }
                tcs.TrySetResult(true);
            };
            return tcs.Task;
        }

        public Task<bool> AcceptAsync()
        {
            if (this.service.PeersManager.ContainsKey(IntPtr.Zero))
            {
                throw new EException("do not accept twice!");
            }

            var tcs = new TaskCompletionSource<bool>();

            // 如果有请求连接缓存的包,从缓存中取
            if (this.service.ConnEEvents.Count > 0)
            {
                EEvent eEvent = this.service.ConnEEvents.First.Value;
                this.service.ConnEEvents.RemoveFirst();

                this.PeerPtr = eEvent.PeerPtr;
                this.service.PeersManager.Add(this.PeerPtr, this);
                tcs.TrySetResult(true);
            }
            else
            {
                this.service.PeersManager.Add(this.PeerPtr, this);
                this.Connected = eEvent =>
                {
                    if (eEvent.EventState == EventState.DISCONNECTED)
                    {
                        tcs.TrySetException(new EException("socket disconnected in accpet"));
                    }

                    this.service.PeersManager.Remove(IntPtr.Zero);

                    this.PeerPtr = eEvent.PeerPtr;
                    this.service.PeersManager.Add(this.PeerPtr, this);
                    tcs.TrySetResult(true);
                };
            }
            return tcs.Task;
        }

        public void WriteAsync(
                byte[] data, byte channelID = 0, PacketFlags flags = PacketFlags.Reliable)
        {
            var packet = new EPacket(data, flags);
            NativeMethods.EnetPeerSend(this.peerPtr, channelID, packet.PacketPtr);
            // enet_peer_send函数会自动删除packet,设置为0,防止Dispose或者析构函数再次删除
            packet.PacketPtr = IntPtr.Zero;
        }

        public Task<byte[]> ReadAsync()
        {
            var tcs = new TaskCompletionSource<byte[]>();

            // 如果有缓存的包,从缓存中取
            if (this.recvBuffer.Count > 0)
            {
                var bytes = this.recvBuffer.First.Value;
                this.recvBuffer.RemoveFirst();
                tcs.TrySetResult(bytes);
            }
                    // 没有缓存封包,设置回调等待
            else
            {
                this.Received = eEvent =>
                {
                    if (eEvent.EventState == EventState.DISCONNECTED)
                    {
                        tcs.TrySetException(new EException("socket disconnected in receive"));
                    }

                    using (var packet = new EPacket(eEvent.PacketPtr))
                    {
                        var bytes = packet.Bytes;
                        tcs.TrySetResult(bytes);
                    }
                };
            }
            return tcs.Task;
        }

        public void WriteAsync(
                Action<int> action, byte[] data, byte channelID = 0,
                PacketFlags flags = PacketFlags.Reliable)
        {
            var packet = new EPacket(data, flags);
            int ret = NativeMethods.EnetPeerSend(this.peerPtr, channelID, packet.PacketPtr);
            // enet_peer_send函数会自动删除packet,设置为0,防止Dispose或者析构函数再次删除
            packet.PacketPtr = IntPtr.Zero;
            action(ret);
        }

        public void ReadAsync(Action<byte[], int> action)
        {
            // 如果有缓存的包,从缓存中取
            if (this.recvBuffer.Count > 0)
            {
                var bytes = this.recvBuffer.First.Value;
                this.recvBuffer.RemoveFirst();
                action(bytes, 0);
            }
                    // 没有缓存封包,设置回调等待
            else
            {
                this.Received = eEvent =>
                {
                    if (eEvent.EventState == EventState.DISCONNECTED)
                    {
                        action(new byte[0], -1);
                    }

                    using (var packet = new EPacket(eEvent.PacketPtr))
                    {
                        var bytes = packet.Bytes;
                        action(bytes, 0);
                    }
                };
            }
        }

        public Task<bool> DisconnectAsync(uint data = 0)
        {
            NativeMethods.EnetPeerDisconnect(this.peerPtr, data);
            // EnetPeerDisconnect会reset Peer,这里设置为0,防止再次Dispose
            this.PeerPtr = IntPtr.Zero;
            var tcs = new TaskCompletionSource<bool>();
            this.Disconnect = eEvent => tcs.TrySetResult(true);
            return tcs.Task;
        }

        public Task<bool> DisconnectLaterAsync(uint data = 0)
        {
            NativeMethods.EnetPeerDisconnectLater(this.peerPtr, data);
            // EnetPeerDisconnect会reset Peer,这里设置为0,防止再次Dispose
            this.PeerPtr = IntPtr.Zero;
            var tcs = new TaskCompletionSource<bool>();
            this.Disconnect = eEvent => tcs.TrySetResult(true);
            return tcs.Task;
        }

        public void DisconnectNow(uint data)
        {
            NativeMethods.EnetPeerDisconnectNow(this.peerPtr, data);
            // EnetPeerDisconnect会reset Peer,这里设置为0,防止再次Dispose
            this.PeerPtr = IntPtr.Zero;
        }

        internal void OnConnected(EEvent eEvent)
        {
            if (this.Connected == null)
            {
                return;
            }
            Action<EEvent> localConnected = this.Connected;
            this.Connected = null;
            // 此调用将让await ConnectAsync返回,所以null必须在此之前设置
            localConnected(eEvent);
        }

        internal void OnReceived(EEvent eEvent)
        {
            // 如果应用层还未调用readasync则将包放到缓存队列
            if (this.Received == null)
            {
                using (var packet = new EPacket(eEvent.PacketPtr))
                {
                    var bytes = packet.Bytes;
                    this.recvBuffer.AddLast(bytes);
                }
            }
            else
            {
                Action<EEvent> localReceived = this.Received;
                this.Received = null;
                // 此调用将让await ReadAsync返回,所以null必须在此之前设置
                localReceived(eEvent);
            }
        }

        internal void OnDisconnect(EEvent eEvent)
        {
            if (this.Disconnect == null)
            {
                return;
            }
            this.Disconnect(eEvent);
        }

        internal void OnError(int errorCode)
        {
            if (this.Error == null)
            {
                return;
            }
            this.Error(errorCode);
        }
    }
}