c#网络编程，如何异步监听指定的端口！并响应客户端
using System.Text;
using System.Net;
using System.Net.Sockets;
using System.Threading;
using System.Collections;
using System;
using System.Collections.Generic;
namespace SocketLibrary
{
public delegate void BufferNotifyEventHandler(byte[] CaptureData,EndPoint FromIP);
/// <summary>
/// ----名称:UDP通讯类
/// ----建立:niefei
/// ----建立时间:2004-12-6
/// </summary>
/// <remarks>
/// ----使用说明与定义:
/// ----接到字符串 "NeedDownCards" 表示需要调用卡下载功能
/// </remarks>
public class UDPSocket
{
public class ClientEndPoint
{
public ClientEndPoint() { }
public ClientEndPoint(int cID, string remoteIP, int remotePort)
{
CID = cID;
RemoteIP = remoteIP;
RemotePort = remotePort;
}
public int CID;
public string RemoteIP = "192.168.0.255";
public int RemotePort = 9999;
}
public UDPPackage.UdpData PulseData;
#region 内部变量区
private IPEndPoint m_SendToIpEndPoint = null;
/// <summary>
/// 为了不让定义的事件在没有附加接收函数时出错，需要先加载一个空函数
/// </summary>
/// <param name="Msg"></param>
protected void EmptyFunction(string Msg) { }
protected ArrayList m_computers;
/// <summary>
/// 发送命令文本常量
/// </summary>
protected string m_sendText;
/// <summary>
/// 默认发送的字符串
/// </summary>
protected const string m_sendStr = "Hello!Server Is Running!";
/// <summary>
/// Udp对象
/// </summary>
protected UdpClient m_Client;
/// <summary>
/// 本地通讯端口(默认8888)
/// </summary>
protected int m_LocalPort;
/// <summary>
/// 本一IP(默认127.0.0.1)
/// </summary>
protected string m_LocalIP;
/// <summary>
/// 对方IP
/// </summary>
protected string m_SendToIP ="192.168.0.255";
/// <summary>
/// 远程通讯端口(默认8000)
/// </summary>
protected int m_RemotePort=9999;
/// <summary>
/// 当有多台客户机需要与服务器通讯时，这里记录了所有客户机的信息
/// </summary>
protected List<ClientEndPoint> m_ClientList = new List<ClientEndPoint>();
/// <summary>
/// 跟踪是否退出程序
/// </summary>
protected bool m_Done;
/// <summary>
/// 设置是否要发送
/// </summary>
protected bool m_flag;
#endregion
#region 属性区
/// <summary>
/// 定义委托
/// </summary>
public delegate void SOCKETDelegateArrive(string sReceived);
/// <summary>
/// 定义一个消息接收事件
/// </summary>
public SOCKETDelegateArrive SOCKETEventArrive;
/// <summary>
/// 定义一个接受线程
/// </summary>
public Thread recvThread;
/// <summary>
/// 定义一个检测发送线程
/// </summary>
public Thread checkSendThread;
/// <summary>
/// 下载标志
/// </summary>
public bool flag
{
set { this.m_flag = value; }
get { return this.m_flag; }
}
/// <summary>
/// 设置通讯端口
/// </summary>
public int LocalPort
{
set { m_LocalPort = value; }
get { return m_LocalPort; }
}
/// <summary>
/// 设置本地IP
/// </summary>
public string LocalIP
{
set { m_LocalIP = value; }
get{return m_LocalIP;}
}
/// <summary>
/// 设置对方IP地址 ,m_SendToIP
/// </summary>
public string RemoteIP
{
set
{
m_SendToIP = value;
m_SendToIpEndPoint =
new IPEndPoint(IPAddress.Parse(this.m_SendToIP), m_RemotePort);
}
get { return m_SendToIP; }
}
/// <summary>
/// 远程通讯端口
/// </summary>
public int RemotePort
{
set
{
m_RemotePort = value;
m_SendToIpEndPoint =
new IPEndPoint(IPAddress.Parse(this.m_SendToIP), m_RemotePort);
}
get { return m_RemotePort; }
}
/// <summary>
/// 设置多个远程接收端
/// </summary>
public List<ClientEndPoint> ClientList
{
get { return m_ClientList; }
set { m_ClientList = value; }
}
/// <summary>
/// 设置要发送的岗位对象
/// </summary>
public ArrayList computers
{
set { this.m_computers = value; }
get { return this.m_computers; }
}
/// <summary>
/// 收发开关，false为正常工作，true为关闭收发
/// </summary>
public bool Done
{
set { m_Done = value; }
get { return m_Done; }
}
#endregion
/// <summary>
/// 构造函数设置各项默认值
/// </summary>
public UDPSocket()
{
m_sendText = string.Empty;
m_computers = new ArrayList();
m_Done = false;
m_flag = false;
}
/// <summary>
/// 初始化
/// </summary>
public void Init()
{
//初始化UDP对象
try
{
//Dispose();
//SOCKETEventArrive += this.EmptyFunction;
if (m_LocalIP != null && m_LocalIP != "")
{
m_Client = new UdpClient(new IPEndPoint(IPAddress.Parse(m_LocalIP), m_LocalPort)); ;
}
else
{
m_Client = new UdpClient(m_LocalPort);
}
//m_Client = new UdpClient(m_LocalPort);
//SOCKETEventArrive("Initialize succeed by " + m_LocalPort.ToString() + " port");
}
catch
{
//SOCKETEventArrive("Initialize failed by " + m_LocalPort.ToString() + " port");
}
}
/// <summary>
/// 析构函数
/// </summary>
~UDPSocket() { Dispose(); }
/// <summary>
/// 关闭对象
/// </summary>
public void Dispose()
{
DisConnection();
m_computers = null;
}
/// <summary>
/// 关闭UDP对象
/// </summary>
public void DisConnection()
{
try
{
if (m_Client != null)
{
this.Done = true;
if (recvThread != null)
{
this.recvThread.Abort();
}
if (checkSendThread != null)
{
this.checkSendThread.Abort();
}
if (recvThread != null)
{
this.recvThread.Abort();
}
if (checkSendThread != null)
{
this.checkSendThread.Abort();
}
m_Client.Close();
m_Client = null;
}
}
catch
{
this.Done = true;
m_Client.Close();
m_Client = null;
}
finally
{
this.Done = true;
if (m_Client != null)
{
m_Client.Close();
m_Client = null;
}
}
}
#region 接收区
public event BufferNotifyEventHandler BufferNotify;
/// <summary>
/// 侦听线程
/// </summary>
public void StartRecvThreadListener()
{
try
{
// 启动等待连接的线程
recvThread = new Thread(new ThreadStart(Received));
recvThread.Priority = ThreadPriority.Normal;
recvThread.IsBackground = false;
recvThread.Start();
//SOCKETEventArrive("[Received]Thread Start....");
}
catch(Exception exp)
{
//SOCKETEventArrive("[Received]Thread Start failed!"+exp.Message);
}
}
/// <summary>
/// 循环接收，收到数据引发BufferNotifyEventHandler事件
/// </summary>
private void Received()
{
while (!m_Done)
{
//接收数据
try
{
IPEndPoint endpoint = null;
if (m_Client != null && recvThread.IsAlive)
{
m_Client.Client.Blocking = true;
Byte[] CaptureData = m_Client.Receive(ref endpoint);
BufferNotify(CaptureData, m_Client.Client.LocalEndPoint);
}
else if (!recvThread.IsAlive)
{
recvThread.Resume();
}
if (this.checkSendThread != null) //顺便检查发送线程是否工作正常
{
if (this.checkSendThread.ThreadState == ThreadState.Aborted
|| this.checkSendThread.ThreadState == ThreadState.Stopped)
{
checkSendThread.Abort();
checkSendThread = null;
checkSendThread = new Thread(new ThreadStart(ChekSendListener));
checkSendThread.IsBackground = false;
checkSendThread.Start();
}
}
}
catch (Exception exp)
{
//SOCKETEventArrive("ReceiveData:CaptureData. Nullerror"+exp.Message);
}
finally { }
Thread.Sleep(10); //防止系统资源耗尽
}
}
#endregion
#region 发送区
public Queue<byte[]> CaptureDataQueue = new Queue<byte[]>();
/// <summary>
/// 用于接收音频数据的入口
/// </summary>
/// <param name="CaptureData"></param>
public int ReceiveSound(byte[] CaptureData)
{
if (!m_Done)
{
CaptureDataQueue.Enqueue(CaptureData);
}
return CaptureData.Length;
}
/// <summary>
/// 启动检测发送侦听线程
/// </summary>
public void StartCheckSendListenerThread()
{
try
{
checkSendThread = new Thread(new ThreadStart(ChekSendListener));
checkSendThread.Priority = ThreadPriority.Normal;
checkSendThread.IsBackground = false;
checkSendThread.Start();
//SOCKETEventArrive("[ChekSendListener]Thread Start...");
}
catch
{
//SOCKETEventArrive("[ChekSendListener]Thread Start failed!");
}
}
/// <summary>
/// 如果当前发送队列中有数据，就启动发送
/// </summary>
private void ChekSendListener()
{
CaptureDataQueue.Clear();
while (!m_Done)
{
try
{
if (CaptureDataQueue.Count > 0)
{
this.sendData(CaptureDataQueue.Dequeue());
}
if (this.recvThread != null)
{
if (this.recvThread.ThreadState == ThreadState.Aborted
|| this.recvThread.ThreadState == ThreadState.Stopped)
{
recvThread.Abort();
recvThread = null;
recvThread = new Thread(new ThreadStart(Received));
recvThread.IsBackground = false;
recvThread.Start();
}
}
}
catch { }
finally { }
Thread.Sleep(1); //防止系统资源耗尽
}
}
#region 二进制发送区
/// <summary>
/// 发送字节流数据
/// </summary>
/// <param name="CaptureData"></param>
public void sendData(byte[] CaptureData/*UDPPackage.UDPData UdpData*/)
{
try
{
if (m_Client == null)
{
m_Client = new UdpClient(new IPEndPoint(IPAddress.Parse(m_LocalIP), m_LocalPort));
}
//m_Client.Connect(this.m_SendToIP, m_RemotePort);
//byte[] bytReceivedData = UdpData.ToByte();// new byte[CaptureData.Length];
//System.Buffer.BlockCopy(CaptureData, 0, bytReceivedData, 0, CaptureData.Length);
// 连接后传送一个消息给ip主机
//m_Client.Send(bytReceivedData, bytReceivedData.Length);
if (0 != this.m_ClientList.Count)
{
for (int i = 0; i < this.m_ClientList.Count; i++)
{
int m = m_Client.Send(CaptureData, CaptureData.Length,
new IPEndPoint(IPAddress.Parse(this.m_ClientList[i].RemoteIP), this.m_ClientList[i].RemotePort));
}
}
else
{
int i = m_Client.Send(CaptureData, CaptureData.Length, m_SendToIpEndPoint);
}
}
catch
{
}
finally
{
//m_Client.Close();
//m_Client = null;
}
}
#endregion
#endregion
#region 周期信号区
Thread PualseThread;
/// <summary>
/// 向服务器发送脉冲信号
/// </summary>
public void sendPulseSignal()
{
try
{
PualseThread = new Thread(new ThreadStart(PulseSingnal));
PualseThread.Priority = ThreadPriority.Normal;
PualseThread.Start();
//SOCKETEventArrive("[PulseSignal]Thread Start...");
}
catch
{
//SOCKETEventArrive("[PulseSignal]Thread Start failed!");
}
}
private void PulseSingnal()
{
while (true)
{
if (this.PulseData.EXP == 1)
{
this.sendData(UDPPackage.StructToBytes(this.PulseData));
}
Thread.Sleep(5000); //每五秒钟一次脉冲
}
}
#endregion
}
}
