// UDP Consumer
static async Task <BufferBlockWrapperUDP> ConsumeAsyncUDP(ISourceBlock <BufferBlockWrapperUDP> source)
{
// Read from the source buffer
while (await source.OutputAvailableAsync())
{
BufferBlockWrapperUDP wrapper = await source.ReceiveAsync();
UDPMessage msg = wrapper.message;
int netID = wrapper.netID;
ConsumeMessageUDP(msg, netID);
}
return(null);
}
void udpMain_ReceiveMessage(object sender, UDPMessage e)
{
dgvMessages.Rows.Add(
new object[]
{
e.MessageType.ToString(),
e.Title,
e.Message,
e.FromIP,
e.ToIP,
e.FromName,
e.DateSended.ToString(),
e.Port.ToString()
}
);
}
private void cmdSend_Click(object sender, EventArgs e)
{
UDPMessage udpMens = new UDPMessage();
//udpMens.MessageType = UDPMessage.UDPMessageType.udpm_CrossCheck;
udpMens.Title = txtTitle.Text;
udpMens.Port = int.Parse(txtPort.Text);
udpMens.Message = txtMessage.Text;
udpMens.ToIP = txtTarget.Text;
udpMain.Send(udpMens);
udpMens = null;
txtLog.Text += "Enviado:" + txtMessage.Text + Environment.NewLine;
txtMessage.Text = "";
txtMessage.Focus();
//udpMain.Dispose();
//udpMain = null;
}
/// <summary>
/// Is called on NetworkMessage arrival,
/// and calls the method accompanied to it
/// on either the secondary or main thread.
/// </summary>
public void OnMessageReceived(UDPMessage message)
{
// Calls the function corresponding with the message's type.
NetworkMessage networkMessage = (NetworkMessage)message;
string methodName = networkMessage.Type.ToString();
MethodInfo method = GetType().GetMethod(methodName);
Action methodCall = delegate { method.Invoke(this, new object[] { networkMessage }); };
if (method.GetCustomAttributes(typeof(ExecuteOnMainThread), true).Any())
{
actionQueue.Enqueue(methodCall);
}
else
{
methodCall.Invoke();
}
}
/// <summary>
/// Sendet einen Broadcast ins Netzwerk
/// Wenn einer darauf antwortet, dann mit seiner IPAdresse
/// </summary>
/// <returns></returns>
private void BroadCastSend(UDPMessage udpMessage, UdpClient udpClient, IPEndPoint remoteEndPoint)
{
IsLocalServer = true;
try
{
//Broadcast wird versendet
udpClient.Send(udpMessage.DataInBytes, udpMessage.Data.Length, udpMessage.TargetAddress, udpMessage.Port);
try
{
//Daten werden aus dem udpStream gelesen
udpMessage.DataInBytes = udpClient.Receive(ref remoteEndPoint);
String messageFromServer = udpMessage.ReadBytes(udpMessage.DataInBytes);
if (null != messageFromServer)
{
ConnectionString = messageFromServer;
udpClient.Close();
}
else //Keine Antwort zurück bekommen
{
// Server im Internet wird verwendet
udpClient.Close();
udpClient.Client.Disconnect(true);
// Wenn man die Verbindung über das Internet laufen lassen möchte
//ConnectionString = Properties.Settings.Default.ConnectionString;
//IsLocalServer = false;
}
}
catch (Exception timeout)
{
udpClient.Close();
// Wenn man die Verbindung über das Internet laufen lassen möchte
//ConnectionString = Properties.Settings.Default.ConnectionString;
IsLocalServer = false;
}
}
catch (Exception exc)
{
Console.WriteLine(exc.Message); //TODO:
}
}
private void OnLoad_Connect(object sender, EventArgs e)
{
this.button_Exit.Enabled = false;
serverIP = IPAddress.Any;
backgroundClient = new UDPMessage();
listenBroadcast = new Thread(
() =>
{
backgroundClient.OnListenBroadcast(
threadID: 9999,
port: Port.DEFAULT_BROADCAST_PORT,
ver: VerMessage.PUBLIC_VERIFICATION,
serverIP: out serverIP
);
}
);
listenBroadcast.Start();
Thread watcher = new Thread(WatchServerIP);
watcher.Start();
}
private void cmdSend_Click(object sender, EventArgs e)
{
UDPMessage udpMes = new UDPMessage();
udpMes.Port = int.Parse(txtPort.Text);
udpMes.Message = txtMessage.Text;
udpMes.ToIP = "192.168.14.61";
udpMain.Send(udpMes);
udpMes = null;
//int intIndex;
//for ( intIndex = 0 ; intIndex < trvPC.Nodes [ 0 ].Nodes.Count ; intIndex++ )
//{
// if ( trvPC.Nodes [ 0 ].Nodes [ intIndex ].Checked )
// {
// udpMes.ToIP = trvPC.Nodes [ 0 ].Nodes [ intIndex ].Tag.ToString();
// udpMain.Send( udpMes );
// }
//}
}
//Method called when a command is received from a controller
private void HandleMessage(string udpMessage, string source)
{
//Here we check if controller sending the command is known or not. If not, we call the NewControllerDelegate
if (!ConnectedControllers.ContainsKey(source))
{
if (ncDelegate != null)
{
ncDelegate(source);
}
}
//Parse the message from JSON
UDPMessage message = JsonUtility.FromJson <UDPMessage>(udpMessage);
try
{
ConnectedControllers[source].actions[message.type](message.x, message.y, message.z);
} catch (Exception e)
{
Debug.Log(e);
}
}
public static void UDPReceiveCallback(IAsyncResult ar)
{
UdpClient u = (UdpClient)((UDPState)(ar.AsyncState)).u;
IPEndPoint e = (IPEndPoint)((UDPState)(ar.AsyncState)).e;
Byte[] receiveBytes = u.EndReceive(ar, ref e);
//Console.WriteLine("Bytes received: {0}", receiveBytes.Length);
messageReceived = true;
UDPState s = (UDPState)ar.AsyncState;
UDPMessage msg = UDPMessage.Parser.ParseFrom(receiveBytes);
BufferBlockWrapperUDP wrap = new BufferBlockWrapperUDP();
wrap.message = msg;
wrap.netID = clients.Find(c => ((IPEndPoint)c.workSocket.RemoteEndPoint).Address.Equals(e.Address)).netID;
asyncQueueUDP.SendAsync(wrap);
u.BeginReceive(new AsyncCallback(UDPReceiveCallback), s);
}
public void StartReceive()
{
try
{
//Create a UDP socket.
soUdp = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
soUdp.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, true);
soUdp.ReceiveTimeout = 2000;
IPEndPoint localIpEndPoint = new IPEndPoint(IPAddress.Parse(udpAddress.HostIP), (int)udpAddress.Sp);
soUdp.Bind(localIpEndPoint);
byte[] received = new Byte[UDP_MAX_PACKET_SIZE];
byte[] msgBuffer = null;
Dictionary<int, byte[]> messageDict = new Dictionary<int, byte[]>(100);
while (isRunning)
{
EndPoint remoteEP = (EndPoint)(new IPEndPoint(IPAddress.Any, 0));
int size = 0;
try
{
if (soUdp!=null && soUdp.IsBound)
size = soUdp.ReceiveFrom(received, ref remoteEP);
}
catch (SocketException seInner)
{
if (seInner.ErrorCode == (int)SocketError.TimedOut)
Console.WriteLine("Socket timedout " + udpAddress);
else
throw seInner;
}
if (size > 0)
{
byte[] data = new byte[size];
Buffer.BlockCopy(received, 0, data, 0, size);
//Console.WriteLine("received from "+ servicePort+":" + received);
UDPMessage udpMsg = new UDPMessage(data);
if (!messageDict.ContainsKey(udpMsg.MessageID))
{ // init buffer
msgBuffer = new byte[udpMsg.MessageSize];
messageDict.Add(udpMsg.MessageID, msgBuffer);
}
else
{
messageDict.TryGetValue(udpMsg.MessageID, out msgBuffer);
}
Buffer.BlockCopy(udpMsg.Data, 0, msgBuffer, udpMsg.MessageOffset, udpMsg.Data.Length);
if (udpMsg.MessageOffset + udpMsg.Data.Length >= udpMsg.MessageSize - 1)
{
owner.receiveMsg(msgBuffer);
messageDict.Remove(udpMsg.MessageID);
msgBuffer = null;
}
//String dataReceived = System.Text.Encoding.ASCII.GetString(received);
//Byte[] returningByte = System.Text.Encoding.ASCII.GetBytes(returningString.ToCharArray());
//soUdp.SendTo(returningByte, remoteEP);
}
}
}
catch (SocketException se)
{
Console.WriteLine("A Socket Exception has occurred!" + se.ToString());
}
}
public void OnMessageReceived(UDPMessage message)
{
LogMessage((T)message);
}
private void Form_Main_Load(object sender, EventArgs e)
{
__tmp__ = new NotStatic();
onlineUsers = new ClientTable();
// 加载用户列表
rtUserPath = System.AppDomain.CurrentDomain.SetupInformation.ApplicationBase + "uesrs.bin";
FileInfo fi = new FileInfo(rtUserPath);
if (fi.Exists)
{
LoadUsersData(rtUserPath);
}
else
{
FileStream fs = fi.Create(); fs.Close();
users = new UserSet();
SaveUsersData(rtUserPath);
}
// 调整窗口属性
uid = Registry.ReadKey4Registry("PublishServer", "CurrentUserID");
int idNumeric = int.Parse(uid);
uid = idNumeric.ToString("D6");
uac = Registry.ReadKey4Registry("PublishServer", "CurrentUserAccount");
ucl = Registry.ReadKey4Registry("PublishServer", "CurrentUserName");
this.Text = "教材补助经费评估软件 [" + ucl + "]" + " [#" + uid + "]";
// 开始 UDP 广播
backgroundServer = new UDPMessage();
Thread udpThread = new Thread(
() => {
backgroundServer.OnBroadcast(
threadID: 9999,
port: Port.DEFAULT_BROADCAST_PORT,
ver: VerMessage.PUBLIC_VERIFICATION
);
}
);
udpThread.IsBackground = true;
udpThread.Start();
// 初始化用户个人信息
this.label_AdminTitle.Text += "[#" + uid + "]";
this.label_AdminName.Text = ucl;
// 所有 TCP 监听端口就绪
tcpServerLogin = new TcpListenerP(new IPEndPoint(IPAddress.Any, Port.TCP_LOGIN_PORT));
tcpServerLogin.OnThreadTaskRequest += new TcpListenerP.ThreadTaskRequest(OnListenClient);
tcpServerBookEvau = new TcpListenerP(new IPEndPoint(IPAddress.Any, Port.TCP_BOOK_EVALUATION_PORT));
tcpServerBookEvau.OnThreadTaskRequest += new TcpListenerP.ThreadTaskRequest(OnListenBookEvau);
// 所有 TCP 客户端使用前初始化
// tcpClientUserFile = new TcpClientP();
// 初始化教材列表
BookList = new BookDetailList();
BookEval = new BookEvaluaionList();
// 初始化列表显示
ResetListView_Books();
ResetListView_Users();
}
void EvalCommand(UDPMessage e)
{
string strStatus = "-";
string strFree = "Liberado";
string strLocked = "Reservado";
string strNotFound = "notfound";
//PARA PONER ESTADO DE ARCHIVO
if (e.Title.Trim() == "setrecerved")
{
strStatus = strLocked;
}
if (e.Title.Trim() == "setaccesible")
{
strStatus = strFree;
}
if (strStatus == strFree || strStatus == strLocked)
{
int IndexResult = ExistItem("FileName", e.Message, dgvDataActivity);
if (IndexResult == -1)
{
dgvDataActivity.Rows.Add(e.Message, e.FromName + " " + e.FromIP, strStatus, e.DateSended.ToString(), "");
}
else
{
dgvDataActivity["Status", IndexResult].Value = strStatus;
//Envio de notificación de archivo
if (dgvDataActivity["Requests", IndexResult].Value.ToString().Contains(';'))
{
string[] IpList = dgvDataActivity["Requests", IndexResult].Value.ToString().Split(';');
foreach (string IpItem in IpList)
{
UDPMessage udpMens = new UDPMessage();
udpMens.MessageType = UDPMessage.UDPMessageType.udpm_Common;
udpMens.Title = "Archivo Liberado";
udpMens.Port = e.Port;
udpMens.Message = e.Message;
udpMens.ToIP = IpItem;
udpMain.Send(udpMens);
udpMens = null;
}
}
}
}
//PETICION DE ESTADO DE ARCHIVO
if (e.Title.Trim() == "retreivestatusfile")
{
//dgvMessages.Rows.Add(new object[] { "Peticion de estado de archivos" ,
// "" ,
// "" ,
// "",
// "",
// "",
// e.DateSended.ToString(),
// e.Port.ToString()});
int IndexResult = ExistItem("FileName", e.Message, dgvDataActivity);
UDPMessage udpMens = new UDPMessage();
udpMens.MessageType = UDPMessage.UDPMessageType.udpm_Command;
udpMens.Title = "retreivestatusfileresult";
udpMens.Port = e.Port;
if (IndexResult > -1)
{
udpMens.Message = e.Message + ";" + dgvDataActivity["Status", IndexResult].Value.ToString();
dgvDataActivity["Requests", IndexResult].Value += e.FromIP + ";";
}
else
{
udpMens.Message = e.Message + ";" + strNotFound;
}
udpMens.ToIP = e.FromIP;
udpMain.Send(udpMens);
udpMens = null;
dgvMessages.Rows.Add(new object[] { "Peticion de estado de archivos enviada a " + e.FromIP + " " + e.FromName,
"",
"",
"",
"",
"",
e.DateSended.ToString(),
e.Port.ToString() });
}
}
public bool Send(UDPMessage udpMessage)
{
bool blReturn = true;
int pRet;
UdpClient udpClient = new UdpClient();
string strMessageObjArray = "";
/**********************/
udpMessage.FromName = Dns.GetHostName();
IPAddress[] ipaRank;
ipaRank = Dns.GetHostAddresses(Dns.GetHostName());
foreach (IPAddress ip in ipaRank)
{
udpMessage.FromIP += ip.ToString() + ";";
}
/**********************/
try
{
GLOIP = IPAddress.Parse(udpMessage.ToIP);
GLOINTPORT = udpMessage.Port;
udpClient.Connect(GLOIP, GLOINTPORT);
//Console.WriteLine("Connected to client");
/**/
strMessageObjArray =
udpMessage.MessageType.ToString() + m_separator[0] +
udpMessage.Title + m_separator[0] +
udpMessage.Message + m_separator[0] +
udpMessage.FromIP + m_separator[0] +
udpMessage.ToIP + m_separator[0] +
udpMessage.FromName + m_separator[0] +
udpMessage.DateSended.ToString() + m_separator[0] +
udpMessage.Port.ToString() + m_separator[0] +
udpMessage.ID.ToString() + m_separator[0] +
udpMessage.IDSource.ToString() + m_separator[0] +
udpMessage.RequireReceived.ToString() + m_separator[0];
/**/
//Console.WriteLine("Message created");
//bytCommand = Encoding.ASCII.GetBytes( udpMessage.Message );
bytCommand = Encoding.ASCII.GetBytes(strMessageObjArray);
pRet = udpClient.Send(bytCommand, bytCommand.Length);
//Console.WriteLine("Sended");
if (ReceiveInfo != null)
{
ReceiveInfo(this, new UDPInfo(UDPInfo.UDPInfoType.udpm_SendedConfirm, "Enviado", udpMessage.ToIP));
}
}
catch (Exception e)
{
//Raise
if (ReceiveException != null)
{
ReceiveException(this, e);
}
blReturn = false;
}
finally
{
udpClient.Close();
udpClient = null;
}
return(blReturn);
}
/// <summary>
/// 受信したメッセージの内容によって処理を行う
/// </summary>
/// <param name="unit">受信情報</param>
void Parse(ReceivedUnit unit)
{
//なるべくメッセージごと１関数で実装する
UDPMessage type = unit.message.ToUDPMessage();
int ackRegisteredIndex = ackWaiting.IndexOfPort(unit.senderEP.Port);
int connectedIndex = connectedPlayerEPs.IndexOfPort(unit.senderEP.Port);
print("メッセージを受信");
switch (type)
{
case UDPMessage.Ack:
{
print(ackRegisteredIndex);
if (ackRegisteredIndex == -1)
{
break;
}
connectedPlayerEPs.Add(unit.senderEP);
ackWaiting.RemoveAt(ackRegisteredIndex);
if (connectedPlayerEPs.Count == 1)
{
sendThread = new Thread(new ThreadStart(ThreadSend));
sendThread.Start();
}
print("他の人から接続がありました");
byte[] message = UDPMessage.AckComplete.ToByte();
client.SendAsync(message, message.Length, unit.senderEP);
otherPlayerObjects[connectedPlayerEPs.Count - 1].SetActive(true);
break;
}
case UDPMessage.AckComplete:
{
print(ackRegisteredIndex);
if (ackRegisteredIndex == -1)
{
break;
}
connectedPlayerEPs.Add(unit.senderEP);
ackWaiting.RemoveAt(ackRegisteredIndex);
if (connectedPlayerEPs.Count == 1)
{
sendThread = new Thread(new ThreadStart(ThreadSend));
sendThread.Start();
}
print("他の人から接続がありました");
otherPlayerObjects[connectedPlayerEPs.Count - 1].SetActive(true);
break;
}
case UDPMessage.PosUpdate:
{
Vector3 pos = unit.message.ToVector3(4);
float Yrot = BitConverter.ToSingle(unit.message, 16);
if (otherPlayerInfo.Count <= connectedIndex)
{
//プレイヤーのSmoothedMovementがない場合
PositionAndRotation newPlayer = new PositionAndRotation(sendPerSecond);
newPlayer.UpdateInformation(pos, Yrot);
otherPlayerInfo.Add(newPlayer);
}
else
{
otherPlayerInfo[connectedIndex].UpdateInformation(pos, Yrot);
}
break;
}
default:
{
print("malformed packet!!!!!!!!!");
break;
}
}
}
static void ConsumeMessageUDP(UDPMessage msg, int netID)
{
switch (msg.MsgCase)
{
// Lock Step
case UDPMessage.MsgOneofCase.Lockstepmsg:
{
break;
}
// Snapshot
case UDPMessage.MsgOneofCase.Snapshotmsg:
{
//if (clients.Find(c => c.netID == netID).host)
//Console.WriteLine("id" + netID + "id2 " + hostID);
if (netID == hostID)
{
// Send to clients
UDPSendMessageToAllButHost(msg);
}
else
{
// Send to host
UDPSendMessageToClient(msg, hostID);
}
break;
}
// State
case UDPMessage.MsgOneofCase.Statemsg:
{
if (netID == hostID)
{
// Send to clients
UDPSendMessageToAllButHost(msg);
}
else
{
// Send to host
UDPSendMessageToClient(msg, hostID);
}
break;
}
// Client Message
case UDPMessage.MsgOneofCase.Udpstringmsg:
{
char delimiterChar = ':';
string[] messageSplit = msg.Udpstringmsg.Msg.Split(delimiterChar);
if (messageSplit[0] == "snapshotack")
{
// Send to host
UDPSendMessageToClient(msg, hostID);
}
break;
}
// Client Input Message
case UDPMessage.MsgOneofCase.Snapshotinputmsg:
{
// Apply NetID
//msg.Snapshotinputmsg.Sequence = netID;
// Send to host
UDPSendMessageToClient(msg, hostID);
break;
}
// Client Input Message
case UDPMessage.MsgOneofCase.Stateack:
{
// Apply NetID
//msg.Snapshotinputmsg.Sequence = netID;
// Send to host
UDPSendMessageToClient(msg, hostID);
break;
}
// State Update
case UDPMessage.MsgOneofCase.Predictionreconciliationmsg:
{
if (netID == hostID)
{
// Send to clients
UDPSendMessageToAllButHost(msg);
}
else
{
// Send to host
UDPSendMessageToClient(msg, hostID);
}
break;
}
// State Update
case UDPMessage.MsgOneofCase.Predictionreconciliationinputmsg:
{
// Apply NetID
msg.Predictionreconciliationinputmsg.Netid = netID;
// Send to host
UDPSendMessageToClient(msg, hostID);
break;
}
// State Update
case UDPMessage.MsgOneofCase.Servertimerequestmsg:
{
// Apply NetID
if (netID == hostID)
{
// Send to clients
UDPSendMessageToAllButHost(msg);
}
else
{
// Send to host
msg.Servertimerequestmsg.ClientID = netID;
UDPSendMessageToClient(msg, hostID);
}
break;
}
}
}
private void ReceiveMessages()
{
try
{
string strIP;
string strResult;
if (receivingUdpClient == null)
{
return;
}
Byte [] receiveBytes = receivingUdpClient.Receive(ref RemoteIpEndPoint);
BitArray BitDet;
BitDet = new BitArray(receiveBytes);
strResult = Encoding.ASCII.GetString(receiveBytes);
string[] strResults = strResult.Split(m_separator, StringSplitOptions.None);
strIP = RemoteIpEndPoint.Address.ToString();
UDPMessage udpMes = new UDPMessage();
udpMes.MessageType = (UDPMessage.UDPMessageType)
Enum.Parse(typeof(UDPMessage.UDPMessageType), strResults[0]);
udpMes.Title = strResults[1];
udpMes.Message = strResults[2];
udpMes.FromIP = strIP; //strResults[4];
udpMes.ToIP = strResults[4];
udpMes.FromName = strResults[5];
udpMes.DateSended = strResults[6];
udpMes.Port = int.Parse(strResults[7]);
udpMes.ID = int.Parse(strResults[8]);
udpMes.IDSource = int.Parse(strResults[9]);
udpMes.RequireReceived = bool.Parse(strResults[10]);
if (udpMes.MessageType == UDPMessage.UDPMessageType.udpm_Common &&
udpMes.RequireReceived)
{
UDPMessage udpConf = new UDPMessage();
udpConf.MessageType = UDPMessage.UDPMessageType.udpm_ReceivedConfirm;
udpConf.Message = "Mensaje recibido en " + udpMes.ToIP;
udpConf.ToIP = strIP;
udpConf.Port = udpMes.Port;
Send(udpConf);
udpConf = null;
}
if (udpMes.MessageType == UDPMessage.UDPMessageType.udpm_CrossCheck)
{
UDPMessage udpConf = new UDPMessage();
udpConf.MessageType = UDPMessage.UDPMessageType.udpm_ReceivedConfirm;
udpConf.Message = ">>>" + udpMes.ToIP;
udpConf.ToIP = strIP;
udpConf.Port = udpMes.Port;
Send(udpConf);
udpConf = null;
}
if (ReceiveMessage != null)
{
ReceiveMessage(this, udpMes);
}
NewInitialize();
//udpMes = null;
//receiveBytes = null;
//BitDet = null;
}
catch (Exception e)
{
//Raise
if (ReceiveException != null)
{
ReceiveException(this, e);
}
}
}
/// <summary>
/// 接收发送给本机ip对应端口号的数据报
/// </summary>
public void ReciveMsg(CancellationToken token)
{
Task.Factory.StartNew(() =>
{
int cNumber = 0; //客户端个数
while (!token.IsCancellationRequested)
{
EndPoint point = new IPEndPoint(IPAddress.Any, 0); //用来保存发送方的ip和端口号
byte[] buffer = new byte[1024];
int length = server.ReceiveFrom(buffer, ref point); //接收数据报
string message = Encoding.UTF8.GetString(buffer, 0, length);
string reciveTime = DateTime.Now.ToString("yyyy-MM-dd hh:mm:ss.fff"); //接收时间
UDPMessage msgObj = JsonConvert.DeserializeObject <UDPMessage>(message);
LogRealize.GetInstance().WriteLog(msgObj); //写日志
string tempLevel = string.Empty; //日志级别
switch (msgObj.Level)
{
case LogLevel.Debug:
tempLevel = "Debug";
break;
case LogLevel.Info:
tempLevel = "Info";
break;
case LogLevel.Error:
tempLevel = "Error";
break;
case LogLevel.Warn:
tempLevel = "Warn";
break;
case LogLevel.Fatal:
tempLevel = "Fatal";
break;
}
LogMessage uiMsgObj = new LogMessage()
{
RTime = reciveTime,
LogLevel = tempLevel,
Message = msgObj.Message,
Exception = msgObj.Exception
};
var cPoint = point.ToString();
if (logPages.Count > 0)
{
var logPageObj = logPages.Find(p => p.Point.Equals(cPoint));
if (logPageObj != null)
{
if (logPageObj.QMesages.Count > 1000)
{
logPages.Find(p => p.Point.Equals(cPoint)).QMesages.Dequeue();
}
logPages.Find(p => p.Point.Equals(cPoint)).QMesages.Enqueue(uiMsgObj);
MesageQueueEvent(logPages.Find(p => p.Point.Equals(cPoint)));
}
else
{
cNumber += 1;
logPages.Add(new LogPage()
{
Point = cPoint,
QMesages = new Queue <LogMessage>()
});
logPages.Find(p => p.Point.Equals(cPoint)).QMesages.Enqueue(uiMsgObj);
LogPageQueueEvent();
}
}
else
{
logPages.Add(new LogPage()
{
Point = cPoint,
QMesages = new Queue <LogMessage>()
});
logPages.Find(p => p.Point.Equals(cPoint)).QMesages.Enqueue(uiMsgObj);
LogPageQueueEvent();
}
}
}, token);
}
public void sendMessage(IMessage msg, int msgID)
{
int dataLen = UDPServer.UDP_MAX_PACKET_SIZE - UDPMessage.getHeaderSize();
byte[] buffer = msg.toByteArray();
for (int i = 0; i < buffer.Length; i = i + dataLen)
{
UDPMessage udpMsg = null;
if (i + dataLen < buffer.Length)
{
udpMsg = new UDPMessage(dataLen);
}
else
{
udpMsg = new UDPMessage(buffer.Length - i);
}
Buffer.BlockCopy(buffer, i, udpMsg.Data, 0, udpMsg.Data.Length);
udpMsg.MessageID = msgID;
udpMsg.MessageOffset = i;
udpMsg.MessageSize = buffer.Length;
sendData(udpMsg);
}
}
static void UDPSendMessageToClient(UDPMessage message, int netID)
{
UDPSendMessage(((IPEndPoint)clients[netID - 1].workSocket.RemoteEndPoint).Address.ToString(), message.ToByteArray());
}
public void sendData(UDPMessage udpMessage)
{
try
{
//IPHostEntry remoteHostEntry = Dns.GetHostEntry(host);
IPEndPoint remoteIpEndPoint = new IPEndPoint(IPAddress.Parse(udpAddress.HostIP), (int)udpAddress.Sp);
EndPoint remoteEndPoint = (remoteIpEndPoint);
int nBytesSent = so.SendTo(udpMessage.toByteArray(), remoteIpEndPoint);
}
catch (Exception e)
{
Console.WriteLine("An Exception Occurred - sendData!" + e.ToString());
}
}
public static byte[] ToByte(this UDPMessage udpm)
{
return(BitConverter.GetBytes((int)udpm));
}
