/// <summary>
/// 构造函数
/// </summary>
/// <param name="_client"></param>
public CommandHandler(AsyncTcpClient _client)
{
this._client = _client;
_handlerThread = new Thread(HandlerThread);
_handlerThread.IsBackground = true;
_handlerThread.Start();
}
void p1_tcp_client_MessageReceived(AsyncTcpClient client, Cmd cmd)
{
if (cmd == null || (cmd is HeartBeatCmd))
{
return;
}
if (!cmd.sender_name.ToLower().Contains("p1"))
{
return;
}
try
{
switch (cmd.id)
{
case CmdType.Get_All_Ready_Users_Cmd_Ack: OnGetAllReadyUsersAck(_p1_tcp_client, cmd as GetAllReadyUsersCmdAck); break;
case CmdType.Get_Changed_Ready_Users_Cmd_Ack: OnGetChangedUsersAck(_p1_tcp_client, cmd as GetChangedReadyUsersCmdAck); break;
}
}
catch (System.Exception ex)
{
EzLogger.GlobalLogger.debug(ex.Message);
}
}
public TcpClientAdapter(AsyncTcpClient tcpClient)
{
if (tcpClient != null)
{
this.tcpClient = tcpClient;
}
}
static void Main(string[] args)
{
LogFactory.Assign(new ConsoleLogFactory());
IPEndPoint remoteEP = new IPEndPoint(IPAddress.Parse("127.0.0.1"), 9999);
IPEndPoint localEP = new IPEndPoint(IPAddress.Parse("127.0.0.1"), 9998); // 测试用，可以不指定由系统选择端口
client = new AsyncTcpClient(remoteEP, localEP);
client.Encoding = Encoding.UTF8;
client.ServerExceptionOccurred += new EventHandler <TcpServerExceptionOccurredEventArgs>(client_ServerExceptionOccurred);
client.ServerConnected += new EventHandler <TcpServerConnectedEventArgs>(client_ServerConnected);
client.ServerDisconnected += new EventHandler <TcpServerDisconnectedEventArgs>(client_ServerDisconnected);
client.PlaintextReceived += new EventHandler <TcpDatagramReceivedEventArgs <string> >(client_PlaintextReceived);
client.Connect();
Console.WriteLine("TCP client has connected to server.");
Console.WriteLine("Type something to send to server...");
while (true)
{
try
{
string text = Console.ReadLine();
client.Send(text);
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
}
}
static void Main(string[] args)
{
try
{
int responseCount = 0;
System.Console.WriteLine("Please enter the IP Address of the server, or leave blank for 192.168.1.128: ");
var ipAddress = System.Console.ReadLine();
if (string.IsNullOrEmpty(ipAddress))
{
ipAddress = "192.168.1.128";
}
var client = new AsyncTcpClient();
client.DataReceived += (sender, e) => System.Console.WriteLine("{0}: Received from server something of size: {1}", ++responseCount, e.Value.Length);
client.Connect(IPAddress.Parse(ipAddress), 8080);
System.Console.WriteLine("Connected!");
System.Console.ReadKey();
}
catch (Exception ex)
{
System.Console.WriteLine(ex.Message);
}
}
private void p1_tcp_client_MessageReceived(AsyncTcpClient client, Cmd cmd)
{
if (cmd is HeartBeatCmd)
{
return;
}
}
public ExtendedDisplayViewController() : base("ExtendedDisplayViewController", null)
{
this.tcpClient = new AsyncTcpClient();
this.tcpClient.DataReceived += (sender, args) =>
{
var bitmapContainer = JsonConvert.DeserializeObject <BitmapContainer>(args.Value);
var image = bitmapContainer.EncodedBitmap.ToUIImage();
if (image != null)
{
UIImage oldImage = null;
this.InvokeOnMainThread(() =>
{
oldImage = imgDisplay.Image;
imgDisplay.Image = image;
});
if (oldImage != null)
{
oldImage.Dispose();
}
}
};
}
private static async Task SendCommandAsync(AsyncTcpClient asyncTcpClient, byte[] command)
{
await asyncTcpClient.Send(command);
byte[] crc = new byte[] { GetCrc(command) };
await asyncTcpClient.Send(crc);
}
/// <summary>
/// 初始化网络并连接
/// </summary>
public static void InitialNetWorkClient()
{
//TCPClient初始化
ControllerServer = new AsyncTcpClient(Parameters.TcpServerHost, Parameters.TcpServerPort);
//异常事件
ControllerServer.ServerExceptionOccurred +=
new EventHandler <TcpServerExceptionOccurredEventArgs>(ControllerServer_ServerExceptionOccurred);
//已连接到服务器
ControllerServer.ServerConnected +=
new EventHandler <TcpServerConnectedEventArgs>(ControllerServer_ServerConnected);
//与服务器断开连接
ControllerServer.ServerDisconnected +=
new EventHandler <TcpServerDisconnectedEventArgs>(ControllerServer_ServerDisconnected);
//接收到服务器的数据(字符串)
ControllerServer.PlaintextReceived +=
new EventHandler <TcpDatagramReceivedEventArgs <string> >(ControllerServer_PlaintextReceived);
//接收到服务器的数据(字节流)
ControllerServer.DatagramReceived +=
new EventHandler <TcpDatagramReceivedEventArgs <byte[]> >(ControllerServer_DatagramReceived);
//连接服务器
ControllerServer.Connect();
}
private void CreateTcpClient()
{
if (this.tcpClient != null)
{
this.tcpClient.Disconnect();
}
this.tcpClient = new AsyncTcpClient();
this.tcpClient.DataReceived += (sender, args) =>
{
var bitmapContainer = JsonConvert.DeserializeObject <BitmapContainer>(args.Value);
var image = bitmapContainer.EncodedBitmap.ToUIImage();
if (image != null)
{
UIImage oldImage = null;
this.InvokeOnMainThread(() =>
{
oldImage = imgScreenshot.Image;
imgScreenshot.Image = image;
});
if (oldImage != null)
{
oldImage.Dispose();
}
}
};
}
/// <summary>
/// 将一个数据组字节包装成当前的标准数据包
/// </summary>
/// <param name="datas"></param>
/// <param name="client"></param>
/// <returns></returns>
public byte[] AssembleBytes(ArraySegment <byte> datas, AsyncTcpClient client)
{
if (client.UsedPackageIdentification)
{
byte[] clientTypeBytes = new byte[1] {
(byte)client.ScadaClientType
};
byte[] lengthBytes = BitConverter.GetBytes(Convert.ToInt32(datas.Count));
int test_length = BitConverter.ToInt32(lengthBytes, 0);
byte[] newData = new byte[datas.Count + client.PackInvalidSize + lengthBytes.Length];
//构造新包,数据包的长度
System.Array.Copy(client.HeadPackBytes, 0, newData, 0, client.HeadPackSize); //头部标识
System.Array.Copy(client.MACBtyes, 0, newData, client.HeadPackSize, client.MACSize); //MAC地址
System.Array.Copy(clientTypeBytes, 0, newData, client.HeadPackSize + client.MACSize, client.ClientTypeSize); //标记当前客户端类型
System.Array.Copy(lengthBytes, 0, newData, client.HeadPackSize + client.ClientTypeSize + client.MACSize, lengthBytes.Length); //实际数据长度
System.Array.Copy(datas.Array, datas.Offset, newData, client.HeadPackSize + client.ClientTypeSize + client.MACSize + lengthBytes.Length, datas.Count); //内容体
System.Array.Copy(client.TailPackBytes, 0, newData, client.HeadPackSize + client.ClientTypeSize + client.MACSize + datas.Count + lengthBytes.Length, client.TailPackSize); //尾部标识
return(newData);
}
else
{
return(datas.ToArray());
}
}
private void Button_Click(object sender, RoutedEventArgs e)
{
tcpClient = new AsyncTcpClient(IPAddress.Parse(Settings.IpAddress), Settings.Port);
tcpClient.Encoding = Encoding.UTF8;
tcpClient.DatagramReceived += TcpClient_DatagramReceived;
tcpClient.PropertyChanged += TcpClient_PropertyChanged;
tcpClient.ServerDisconnected += TcpClient_ServerDisconnected;
tcpClient.ServerExceptionOccurred += TcpClient_ServerExceptionOccurred;
switch (Settings.DeviceType)
{
case DeviceType.W6:
emulator = new W6Emulator(tcpClient);
break;
case DeviceType.V6:
emulator = new V6Emulator(tcpClient);
break;
case DeviceType.CA310:
throw new NotImplementedException("ca310 emulator is not implemented.");
default:
break;
}
if (emulator == null)
{
return;
}
((TCPCOMMODE)emulator).MessageSent += W6Emulator_MessageSent;
tcpClient.Connect();
}
static void Main(string[] args)
{
try
{
cancellationSource = new CancellationTokenSource();
RemoteServerInfo rsi = new RemoteServerInfo
{
Host = IPAddress.Parse("127.0.0.1"),
Port = 900
};
AsyncTcpClient client = new AsyncTcpClient();
//client.OnDataReceived += HandleRecieved;
client.OnDataReceived = onData;
client.OnDisconnected = onDisconnect;
client.OnException = OnException;
client.OnException += OnExceptionStack;
//client.OnDisconnected += HandleDisconnected;
client.ConnectAsync(rsi, cancellationSource.Token).ContinueWith(t => client
.Recieve(cancellationSource.Token),
TaskContinuationOptions.OnlyOnRanToCompletion).Wait();
Console.WriteLine("here we are");
}
catch (System.Exception ex)
{
Console.Write(ex.Message);
}
Console.Read();
}
private async Task ClientConnected(AsyncTcpClient client, bool isReconnected)
{
await Task.Delay(500);
byte[] bytes = Encoding.UTF8.GetBytes($"Hello, {client.ServerTcpClient.Client.RemoteEndPoint}, my name is Server. Talk to me.");
await client.Send(new ArraySegment <byte>(bytes, 0, bytes.Length));
}
public async void ConnectDisconnect()
{
AsyncTcpClient client = new AsyncTcpClient();
await client.ConnectAsync(localhost, port);
Assert.True(client.IsConnected);
await client.CloseAsync();
}
private void OnGetChangedUsersAck(AsyncTcpClient client, GetChangedReadyUsersCmdAck ack)
{
lock (_users_lock)
{
//改变显示
UpdateChangedUsersToDisplay(ack);
}
}
/// <summary>
/// 初始化TCP Client
/// </summary>
private void InitNetWork()
{
client = new AsyncTcpClient(IPAddress.Parse("192.168.31.33"), Constants.SignatureDeviceIPPort);
client.Connect();
client.ServerConnected += new EventHandler <TcpServerConnectedEventArgs>(Connected);
client.ServerDisconnected += new EventHandler <TcpServerDisconnectedEventArgs>(Disconnected);
client.PlaintextReceived += new EventHandler <TcpDatagramReceivedEventArgs <string> >(PlainTextReceived);
client.DatagramReceived += new EventHandler <TcpDatagramReceivedEventArgs <byte[]> >(DatagramReceived);
}
private void OnGetAllReadyUsersAck(AsyncTcpClient client, GetAllReadyUsersCmdAck ack)
{
lock (_users_lock)
{
this._users = ack.users;
ReplaceAllUsersToDisplay(this._users);
}
scroll.Reset();
}
/// <summary>
/// 初始化TCP Client
/// </summary>
private void InitNetWork()
{
client = new AsyncTcpClient(IPAddress.Parse(ConfigurationManager.AppSettings["SignatureDeviceIP"]), Constants.SignatureDeviceIPPort);
client.Connect();
client.ServerConnected += new EventHandler <TcpServerConnectedEventArgs>(Connected);
client.ServerDisconnected += new EventHandler <TcpServerDisconnectedEventArgs>(Disconnected);
client.PlaintextReceived += new EventHandler <TcpDatagramReceivedEventArgs <string> >(PlainTextReceived);
client.DatagramReceived += new EventHandler <TcpDatagramReceivedEventArgs <byte[]> >(DatagramReceived);
}
public void Run()
{
Status = RunStatus.Init;
if (Setting.Interval < 50)
{
Setting.Interval = 50;
}
mCount = 0;
mClients = new List <BeetleX.Clients.AsyncTcpClient>(Setting.Connection);
for (int i = 0; i <= 50000 * IPAddress.Length; i++)
{
string ip = IPAddress[i % IPAddress.Length];
var port = GetPortResource(ip);
AsyncTcpClient client = BeetleX.SocketFactory.CreateClient <AsyncTcpClient>(Server.Host, Server.Port);
client.LocalEndPoint = new IPEndPoint(System.Net.IPAddress.Parse(ip), port.Next());
if (client.Connect())
{
client.DataReceive = OnClientReceive;
ClientToken token = new ClientToken();
client.Token = token;
mClients.Add(client);
mCount++;
if (Setting.Mode == "Interval")
{
token.Node = new LinkedListNode <AsyncTcpClient>(client);
mLinks[mCount % mLinks.Count].AddFirst(token.Node);
}
if (mClients.Count >= Setting.Connection)
{
Task.Run(() => BeginSend());
return;
}
}
else
{
SocketException se = client.LastError as SocketException;
if (se != null)
{
if (se.ErrorCode == (int)SocketError.AddressNotAvailable ||
se.ErrorCode == (int)SocketError.ConnectionRefused ||
se.ErrorCode == (int)SocketError.NetworkUnreachable)
{
Stop();
throw se;
}
}
}
}
if (mClients.Count > 0)
{
Task.Run(() => BeginSend());
}
return;
}
public ConnectedHiveClient(TcpClient tcpClient)
{
this.tcpClient = new AsyncTcpClient
{
ServerTcpClient = tcpClient,
ConnectedCallback = ClientConnected,
ReceivedCallback = MessageRecieved,
ClosedCallback = ClientClosed
};
}
/// <summary>
/// 连接到服务端
/// </summary>
public void ConnectToService()
{
client = new AsyncTcpClient(IPAddress.Parse(IP), Port);
client.ServerConnected += Client_ServerConnected; //连接成功
client.PlaintextReceived += Client_PlaintextReceived; //文本接收
client.DatagramReceived += Client_DatagramReceived; //字节接收
client.ServerDisconnected += Client_ServerDisconnected; //断开连接
client.ServerExceptionOccurred += Client_ServerExceptionOccurred; //
client.Connect();
}
public void InitializeSocket(string ip, int port, bool isDomain = false)
{
mStructCopyer = new StructCopyer();
mAsyncTcpClient = new AsyncTcpClient(ip, port, isDomain);
mAsyncTcpClient.ConnectedEventArgs += OnConnectedEventArgs;
mAsyncTcpClient.DisconnectedEventArgs += OnDisconnectedEventArgs;
mAsyncTcpClient.ExceptionEventArgs += OnExceptionEventArgs;
mAsyncTcpClient.DataPacketReceived += OnDataPacketReceived;
mAsyncTcpClient.Connect();
}
public void Connect()
{
if (IsConnected)
{
return;
}
lock (mLockConnect)
{
if (IsConnected)
{
return;
}
mWScompletionSource = new TaskCompletionSource <bool>();
if (mNetClient == null)
{
string protocol = Host.Scheme.ToLower();
if (!(protocol == "ws" || protocol == "wss"))
{
OnConnectResponse(new BXException("protocol error! host must [ws|wss]//host:port"), null);
mWScompletionSource.Task.Wait();
}
WSPacket wSPacket = new WSPacket
{
WSClient = this
};
if (Host.Scheme.ToLower() == "wss")
{
mNetClient = SocketFactory.CreateSslClient <AsyncTcpClient>(wSPacket, Host.Host, Host.Port, SSLAuthenticateName);
mNetClient.CertificateValidationCallback = CertificateValidationCallback;
}
else
{
mNetClient = SocketFactory.CreateClient <AsyncTcpClient>(wSPacket, Host.Host, Host.Port);
}
mNetClient.LittleEndian = false;
mNetClient.PacketReceive = OnPacketCompleted;
mNetClient.ClientError = OnClientError;
}
mDataFrames = new System.Collections.Concurrent.ConcurrentQueue <object>();
bool isNew;
if (mNetClient.Connect(out isNew))
{
OnWriteConnect();
}
else
{
OnConnectResponse(mNetClient.LastError, null);
}
mWScompletionSource.Task.Wait(5000);
if (!OnWSConnected)
{
throw new TimeoutException($"Connect {Host} websocket server timeout!");
}
}
}
/// <summary>
/// 发送一个下置命令消息到消息列表
/// </summary>
/// <param name="command"></param>
private bool SendNetMQ(IO_COMMANDS command)
{
try
{
///获取本地的IP地址
IPAddress AddressIP = IPAddress.Any;
foreach (IPAddress _IPAddress in Dns.GetHostEntry(Dns.GetHostName()).AddressList)
{
if (_IPAddress.AddressFamily.ToString() == "InterNetwork")
{
AddressIP = _IPAddress;
}
}
TcpData tcpData = new TcpData();
byte[] datas = tcpData.StringToTcpByte(command.GetCommandString(), ScadaTcpOperator.置命令);
AsyncTcpClient Client = new AsyncTcpClient
{
IPAddress = AddressIP,
Port = int.Parse(Configs.GetValue("Port")),
AutoReconnect = true,
ScadaClientType = ScadaClientType.WebSystem,
ConnectedCallback = async(c, isReconnected) =>
{
if (!c.IsClosing)
{
await c.WaitAsync(); // 等待服务器
//连接到服务器后向服务器发送心跳握手数据
}
},
ConnectedTimeoutCallback = (c, isReconnected) =>
{
},
ClosedCallback = (c, isReconnected) =>
{
},
ReceivedCallback = (c, count) =>
{
return(Task.CompletedTask);
}
};
Client.RunAsync().GetAwaiter();
Client.Send(new ArraySegment <byte>(datas));
return(true);
}
catch
{
return(false);
}
}
public void Start()
{
try
{
tcpClient = new AsyncTcpClient(new IPEndPoint(IPAddress.Parse(this._ip), this._port), _message, new AlgorithmCodecBuilder());
tcpClient.Connect().Wait();
}
catch (Exception ex)
{
}
}
private void startTCP()
{
if (!isStartTcp)
{
LogTool.Log("服务器连接成功" + serverPoint);
asyncTcpClient = new AsyncTcpClient();
asyncTcpClient.Connet(serverPoint);
asyncTcpClient.OnReceived += AsyncClientReceived;
isStartTcp = true;
}
}
public async Task OnServerDataReceived(AsyncTcpClient client, byte[] data, int offset, int count)
{
if (data == null)
{
return;
}
if (data.Length < 2)
{
return;
}
await this.OnMessage(data[0], data.Skip(1).Take(data.Length - 1).ToArray());
}
/// <summary>
/// 停止
/// </summary>
public async void Stop()
{
if (Client != null)
{
await Task.Delay(2 * 1000);
Client.Disconnect();
Task.WaitAll(TaskManager.ToArray());
Client.Dispose();
Client = null;
GC.Collect();
}
}
public async Task Connect()
{
_tcpClient = new AsyncTcpClient()
{
AutoReconnect = true,
HostName = _address,
Port = _port,
ConnectedCallback = ClientConnected,
ReceivedCallback = ClientReceived
};
await _tcpClient.RunAsync();
}
private void btnLogin_Click(object sender, RoutedEventArgs e)
{
client = new AsyncTcpClient(txtIpAddress.Text, remotePort);
client.Encoding = Encoding.UTF8;
//当收到服务器端文本数据的时候
client.PlaintextReceived += new EventHandler<ReceivedEventArgs<string>>(client_PlaintextReceived);
client.Connect();
System.Threading.Thread.Sleep(1000);
if (client.Connected)
{
btnExit.IsEnabled = true;
btnLogin.IsEnabled = false;
timer_current.Start();
lblStatus.Content = "已成功链接到服务器。";
btnUserLogin.IsEnabled = true;
}
}
