public void Start()
{
if (!IsRunning)
{
IsRunning = true;
udpClient.Bind(localPoint);
AsyncSocketState state = new AsyncSocketState(udpClient);
udpClient.BeginReceiveFrom(state.RecvDataBuffer, 0, state.RecvDataBuffer.Length, SocketFlags.None, ref sender, new AsyncCallback(DataHandler), state);
}
}
private void CommandSetPower(Message message)
{
Power power = ProtoBuf.Extensible.GetValue <Power>(message.command, 100);
AsyncSocketState reader = SeaechDev(message.command.DevID);
if (reader.com != "null")
{
readerHandle.SetPower(SeaechDev(message.command.DevID), (byte)power.readpower, (byte)power.writepower);
}
}
private void Close(AsyncSocketState state)
{
if (state != null && state.isRunning)
{
LogTool.Log("客户端已关闭");
state.Datagram = "";
state.isRunning = false;
//TODO 触发关闭事件
state.Close();
}
}
public void Close(AsyncSocketState state)
{
if (state != null && (!disposedValue))
{
LogTool.Log("客户端已关闭");
state.Datagram = "";
state.isRunning = false;
//TODO 触发关闭事件
state.Close();
}
}
public void Close(AsyncSocketState state)
{
if (state != null && !disposed)
{
if (clientDic.ContainsKey(state.ClientSocket.RemoteEndPoint))
{
clientDic.Remove(state.ClientSocket.RemoteEndPoint);
}
state.Datagram = null;
state.RecvDataBuffer = null;
//TODO 触发关闭事件
state.Close();
}
}
private AsyncSocketState SeaechDev(string devID)
{
List <AsyncSocketState> readers = readerHandle.GetClientInfo();
foreach (AsyncSocketState reader in readers)
{
if (devID == reader.dev)
{
return(reader);
}
}
AsyncSocketState VirtureReader = new AsyncSocketState("null");
return(VirtureReader);
}
private void listView_md_addr_SelectedIndexChanged(object sender, EventArgs e)
{
int row = 0;
if (listView_md_addr.SelectedItems.Count > 0)
{
row = listView_md_addr.SelectedIndices[0];
}
currentclient = clients[row];
if (currentclient.types == connect.net)
{
lblPort.Text = "设备：" + currentclient.dev;
}
else
{
lblPort.Text = "设备：" + currentclient.com;
}
}
/// <summary>
/// 处理客户端数据
/// </summary>
/// <param name="ar"></param>
private void HandleDataReceived(IAsyncResult ar)
{
if (isRunning)
{
AsyncSocketState state = (AsyncSocketState)ar.AsyncState;
Socket client = state.ClientSocket;
try
{
//如果两次开始了异步的接收,所以当客户端退出的时候
//会两次执行EndReceive
int recv = client.EndReceive(ar);
if (recv == 0)
{
//C- TODO 触发事件 (关闭客户端)
Close(state);
RaiseNetError(state);
return;
}
//TODO 处理已经读取的数据 ps:数据在state的RecvDataBuffer中
string msg = Encoding.UTF8.GetString(state.RecvDataBuffer, 0, recv);
//C- TODO 触发数据接收事件
RaiseDataReceived(msg, state);
}
catch (SocketException)
{
//C- TODO 异常处理
RaiseNetError(state);
}
finally
{
//继续接收来自来客户端的数据
client.BeginReceive(state.RecvDataBuffer, 0, state.RecvDataBuffer.Length, SocketFlags.None,
new AsyncCallback(HandleDataReceived), state);
}
}
}
public void DataReceived(IAsyncResult ar)
{
if (isRunning)
{
AsyncSocketState state = (AsyncSocketState)ar.AsyncState;
Socket client = state.ClientSocket;
try
{
//如果两次开始了异步的接收,所以当客户端退出的时候
//会两次执行EndReceive
int recv = client.EndReceiveFrom(ar, ref sender);
if (recv == 0)
{
//C- TODO 触发事件 (关闭客户端)
Close(state);
return;
}
//TODO 处理已经读取的数据 ps:数据在state的RecvDataBuffer中
string msg = Encoding.UTF8.GetString(state.RecvDataBuffer, 0, recv);
state.remote = (IPEndPoint)sender;
//C- TODO 触发数据接收事件
}
catch (SocketException e)
{
//C- TODO 异常处理
LogTool.Log(e.ToString());
}
finally
{
//继续接收来自来客户端的数据
client.BeginReceiveFrom(state.RecvDataBuffer, 0, state.RecvDataBuffer.Length, SocketFlags.None, ref sender,
new AsyncCallback(DataReceived), state);
}
}
}
/// <summary>
/// 开始监听回调
/// </summary>
/// <param name="result"></param>
private void ReceiveCallback(IAsyncResult result)
{
if (m_Client == null || !m_Client.Connected || !result.IsCompleted)
{
return;
}
try
{
AsyncSocketState state = (AsyncSocketState)result.AsyncState;
int length = m_Client.EndReceive(result);
if (length < 8 || state == null)
{
return;
}
CReadPacket readPacket = new CReadPacket(state.m_ReceiveBuffer, length);
readPacket.ReadData();
m_ReceivePacketList.Add(readPacket);
while (readPacket.GetPos() < length)
{
length = length - readPacket.GetPos();
byte[] nextReceiveBuffer = readPacket.ReadBlob(length);
readPacket = new CReadPacket(nextReceiveBuffer, length);
readPacket.ReadData();
m_ReceivePacketList.Add(readPacket);
}
state.m_ReceiveBuffer = null;
state = null;
}
catch (Exception)
{
}
finally
{
AsyncBeginReceive();
}
}
public void Receive()
{
AsyncSocketState state = new AsyncSocketState(socket);
socket.BeginReceiveFrom(state.RecvDataBuffer, 0, state.RecvDataBuffer.Length, SocketFlags.None, ref sender, new AsyncCallback(DataReceived), state);
}
public override bool Equals(object obj)
{
AsyncSocketState state = (AsyncSocketState)obj;
return(clientSocket.Equals(state));
}
private void RaiseOtherException(AsyncSocketState state)
{
RaiseOtherException(state, "");
}
public static async Task <Socket> ConnectAsync(string host, int port, IPEndPoint localEndPoint, bool doAsync, CancellationToken cancellationToken)
{
IPAddress [] ipAddresses;
Socket socket = null;
if (doAsync)
{
ipAddresses = await Dns.GetHostAddressesAsync(host).ConfigureAwait(false);
}
else
{
#if NETSTANDARD
ipAddresses = Dns.GetHostAddressesAsync(uri.DnsSafeHost).GetAwaiter().GetResult();
#else
ipAddresses = Dns.GetHostAddresses(host);
#endif
}
for (int i = 0; i < ipAddresses.Length; i++)
{
cancellationToken.ThrowIfCancellationRequested();
socket = new Socket(ipAddresses[i].AddressFamily, SocketType.Stream, ProtocolType.Tcp);
try {
if (localEndPoint != null)
{
socket.Bind(localEndPoint);
}
if (cancellationToken.CanBeCanceled)
{
var state = new AsyncSocketState(socket, cancellationToken);
var ar = socket.BeginConnect(ipAddresses[i], port, SocketConnected, state);
var waitHandles = new WaitHandle [] { ar.AsyncWaitHandle, cancellationToken.WaitHandle };
WaitHandle.WaitAny(waitHandles);
cancellationToken.ThrowIfCancellationRequested();
}
else
{
socket.Connect(ipAddresses[i], port);
}
break;
} catch (OperationCanceledException) {
if (socket.Connected)
{
socket.Disconnect(false);
}
socket.Dispose();
socket = null;
throw;
} catch {
socket.Dispose();
socket = null;
if (i + 1 == ipAddresses.Length)
{
throw;
}
}
}
if (socket == null)
{
throw new IOException(string.Format("Failed to resolve host: {0}", host));
}
return(socket);
}
public AsyncSocketEventArgs(string msg, AsyncSocketState state)
{
this.msg = msg;
this.state = state;
IsHandled = false;
}
private void RaiseOtherException(AsyncSocketState state)
{
if(NetError!=null)
NetError.Invoke(this, new AsyncSocketEventArgs(state));
}
public MyUserControl(SrDemo sd, AsyncSocketState CurrentClient)
{
this.sd = sd;
this.CurrentClient = CurrentClient;
}
/// <summary>
/// 读取数据参数回调
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void ShowEPC(object sender, Command.ShowEPCEventArgs e)
{
try
{
string[] result = e.CommandRespond.Split(',');
byte type = Convert.ToByte(result[1], 16);
switch (type)
{
//读取标签
case Types.READ_TAGS_RESPOND:
if (result[2] == "1" && result[3] == "000000000000000000000000")
{
string resultEPC = ReaderControllor.WriteTags(ReaderControllor.GetClientInfo()[0], "", 0x00, "", 0, 0, 4, txtKillPassword.Text + txtEPCpassWord.Text);
RFIDWriteState.Operate = RFIDWriteState.WritePassword;
}
else if (result[2] == "1" && result[3] != "000000000000000000000000")
{
//检测二维码标签是否与RFID标签相同
if (result[3] == ComReciveData[0])
{
//发送给PLC
Access.UpdataOneCheck(result[3], Access.Havewrite);
this.Invoke(UpDataTableWrite, new object[] { txtWriteData.Text, Access.Havewrite });
//发送写标成功信号,500毫秒的低电平，PLC电平触发任务
Sleep(500, 2);
}
else
{
Access.UpdataOneCheck(txtWriteData.Text, Access.FailCheck);
this.Invoke(UpDataTableCheck, new object[] { result[3], Access.FailCheck });
}
}
//标签损坏
else if (result[2] != "1")
{
Access.UpdataOneWirte(txtWriteData.Text, Access.WriteFail);
this.Invoke(UpDataTableWrite, new object[] { txtWriteData.Text, Access.WriteFail });
}
break;
//写标签
case Types.WRITE_TAGS_RESPOND:
if (result[2] == "1" && RFIDWriteState.Operate == RFIDWriteState.WritePassword)
{
AsyncSocketState WorkingReader = ReaderControllor.GetClientInfo()[0];
//判断数据长度是否为24位,若不是24位自动补够24位
String Writedata = txtWriteData.Text;
if (txtWriteData.Text.Length < 24)
{
Writedata = Writedata.PadRight(24, '0');
}
string resultRPC = ReaderControllor.WriteTags(ReaderControllor.GetClientInfo()[0], "", 0x00, "", 1, 2, 6, Writedata);
RFIDWriteState.Operate = RFIDWriteState.WriteEPC;
}
else if (result[2] == "1" && RFIDWriteState.Operate == RFIDWriteState.WriteEPC)
{
string resultEPCLock = ReaderControllor.LockTags(ReaderControllor.GetClientInfo()[0], txtEPCpassWord.Text, 254, "", new byte[] { 3, 192, 160 });
RFIDWriteState.Operate = RFIDWriteState.LockTags;
}
break;
//锁标签
case Types.LOCK_TAGS_RESPOND:
//锁RFID标签成功
if (result[2] == "1" && RFIDWriteState.Operate == RFIDWriteState.LockTags)
{
//跟新数据状态
Access.UpdataOneWirte(txtWriteData.Text, Access.Havewrite);
this.Invoke(UpDataTableWrite, new object[] { txtWriteData.Text, Access.Havewrite });
//发送写标成功信号,500毫秒的低电平，PLC电平触发任务
Sleep(500, 1);
//给激光喷码机发送数据
MarkingPort.Write(txtWriteData.Text);
}
break;
}
}
catch (Exception ex)
{
Console.Write(ex.Message);
}
}
