UDPSession.cs 5.3 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176
  1. //using System;
  2. //using System.Net;
  3. //using System.Net.Sockets;
  4. //namespace IFramework.Net.KCP
  5. //{
  6. // class UDPSession
  7. // {
  8. // private Socket mSocket = null;
  9. // private KCP mKCP = null;
  10. // private ByteBuffer mRecvBuffer = ByteBuffer.Allocate(1024 * 32);
  11. // private UInt32 mNextUpdateTime = 0;
  12. // public bool IsConnected { get { return mSocket != null && mSocket.Connected; } }
  13. // public bool WriteDelay { get; set; }
  14. // public bool AckNoDelay { get; set; }
  15. // public IPEndPoint RemoteAddress { get; private set; }
  16. // public IPEndPoint LocalAddress { get; private set; }
  17. // public void Connect(string host, int port)
  18. // {
  19. // IPHostEntry hostEntry = Dns.GetHostEntry(host);
  20. // if (hostEntry.AddressList.Length == 0)
  21. // {
  22. // throw new Exception("Unable to resolve host: " + host);
  23. // }
  24. // var endpoint = hostEntry.AddressList[0];
  25. // mSocket = new Socket(endpoint.AddressFamily, SocketType.Dgram, ProtocolType.Udp);
  26. // mSocket.Connect(endpoint, port);
  27. // RemoteAddress = (IPEndPoint)mSocket.RemoteEndPoint;
  28. // LocalAddress = (IPEndPoint)mSocket.LocalEndPoint;
  29. // mKCP = new KCP((uint)(new Random().Next(1, Int32.MaxValue)), null);
  30. // // normal: 0, 40, 2, 1
  31. // // fast: 0, 30, 2, 1
  32. // // fast2: 1, 20, 2, 1
  33. // // fast3: 1, 10, 2, 1
  34. // mKCP.NoDelay(0, 30, 2, true);
  35. // mKCP.stream=true;
  36. // mRecvBuffer.Clear();
  37. // }
  38. // public void Close()
  39. // {
  40. // if (mSocket != null)
  41. // {
  42. // mSocket.Close();
  43. // mSocket = null;
  44. // mRecvBuffer.Clear();
  45. // }
  46. // }
  47. // public int Send(byte[] data, int index, int length)
  48. // {
  49. // if (mSocket == null)
  50. // return -1;
  51. // var waitsnd = mKCP.waitToSend;
  52. // if (waitsnd < mKCP.sendWindow && waitsnd < mKCP.RmtWnd)
  53. // {
  54. // var sendBytes = 0;
  55. // do
  56. // {
  57. // var n = Math.Min((int)mKCP.Mss, length - sendBytes);
  58. // mKCP.Send(data, index + sendBytes, n);
  59. // sendBytes += n;
  60. // } while (sendBytes < length);
  61. // waitsnd = mKCP.waitToSend;
  62. // if (waitsnd >= mKCP.sendWindow || waitsnd >= mKCP.RmtWnd || !WriteDelay)
  63. // {
  64. // mKCP.Flush(false);
  65. // }
  66. // return length;
  67. // }
  68. // return 0;
  69. // }
  70. // public int Recv(byte[] data, int index, int length)
  71. // {
  72. // // 上次剩下的部分
  73. // if (mRecvBuffer.canRead > 0)
  74. // {
  75. // var recvBytes = Math.Min(mRecvBuffer.canRead, length);
  76. // Buffer.BlockCopy(mRecvBuffer.buffer, mRecvBuffer.reader, data, index, recvBytes);
  77. // mRecvBuffer.reader += recvBytes;
  78. // // 读完重置读写指针
  79. // if (mRecvBuffer.reader == mRecvBuffer.writer)
  80. // {
  81. // mRecvBuffer.Clear();
  82. // }
  83. // return recvBytes;
  84. // }
  85. // if (mSocket == null)
  86. // return -1;
  87. // if (!mSocket.Poll(0, SelectMode.SelectRead))
  88. // {
  89. // return 0;
  90. // }
  91. // var rn = 0;
  92. // try
  93. // {
  94. // rn = mSocket.Receive(mRecvBuffer.buffer, mRecvBuffer.writer, mRecvBuffer.canWrite, SocketFlags.None);
  95. // }
  96. // catch (Exception ex)
  97. // {
  98. // Console.WriteLine(ex);
  99. // rn = -1;
  100. // }
  101. // if (rn <= 0)
  102. // {
  103. // return rn;
  104. // }
  105. // mRecvBuffer.writer += rn;
  106. // var inputN = mKCP.Input(mRecvBuffer.buffer, mRecvBuffer.reader, mRecvBuffer.canRead, true, AckNoDelay);
  107. // if (inputN < 0)
  108. // {
  109. // mRecvBuffer.Clear();
  110. // return inputN;
  111. // }
  112. // mRecvBuffer.Clear();
  113. // // 读完所有完整的消息
  114. // for (; ; )
  115. // {
  116. // var size = mKCP.PeekSize();
  117. // if (size <= 0) break;
  118. // mRecvBuffer.EnsureWritableBytes(size);
  119. // var n = mKCP.Recv(mRecvBuffer.buffer, mRecvBuffer.writer, size);
  120. // if (n > 0) mRecvBuffer.writer += n;
  121. // }
  122. // // 有数据待接收
  123. // if (mRecvBuffer.canRead > 0)
  124. // {
  125. // return Recv(data, index, length);
  126. // }
  127. // return 0;
  128. // }
  129. // public void Update()
  130. // {
  131. // if (mSocket == null)
  132. // return;
  133. // if (0 == mNextUpdateTime || mKCP.time >= mNextUpdateTime)
  134. // {
  135. // mKCP.Update();
  136. // mNextUpdateTime = mKCP.Check();
  137. // }
  138. // }
  139. // public void Send(byte[] buffer, int length)
  140. // {
  141. // if (mSocket != null)
  142. // {
  143. // mSocket.Send(buffer, length, SocketFlags.None);
  144. // }
  145. // }
  146. // }
  147. //}