#pragma warning disable CS1998 // 异步方法缺少 "await" 运算符，将以同步方式运行
private async Task ReadWorker_DoWork(CancellationToken token)
#pragma warning restore CS1998 // 异步方法缺少 "await" 运算符，将以同步方式运行
{
Action cleanup = () =>
{
_client?.Dispose();
_client = null;
};
token.Register(cleanup);
while (!token.IsCancellationRequested && _client.Client != null)
{
Packet packet = null;
try
{
packet = ReadPacket();
}
catch (SocketException se)
{
//如果是网络异常，退出。
#if DEBUG
//Env1.Instance.ShowMessage($"desc={se.Message}\nStack={se.StackTrace}");
#endif
//如果在事件句柄里面DisposeTcpChannel，它会wait这个循环结束。而这里又在等待这个事件句柄执行完毕，所以就死锁了。
#pragma warning disable 4014
Task.Run(() =>
{
ErrorHappened?.Invoke(ErrorType.SocketError);
}, token);
#pragma warning restore 4014
break;
}
catch (Exception ex)
{
Env.ShowMessage($"desc={ex.Message}\nStack={ex.StackTrace}");
}
if (packet != null)
{
try
{
//Env.Logger.Log($"Packet received {packet}");
PacketReceived?.Invoke(packet);
}
catch (Exception e)
{
#if DEBUG
Env.ShowMessage("逻辑层处理消息异常。请检查\n" + e.Message + "\n" + e.StackTrace);
#else
Env.Logger.Log(e.StackTrace);
#endif
}
}
} //end while
cleanup();
Env.Logger.Log("ReceiveMessage: Receiving thread end...");
}
private void CallEvent(string sqlString, Dictionary <string, object> param, string message)
{
try
{
var args = new SqlExEventArgs(sqlString, param, message);
ErrorHappened?.Invoke(this, args);
}
catch { }
}
protected void CallEvent(string sqlString, TheDynamicParameters param, string message)
{
try
{
var args = new DapperExEventArgs(sqlString, param, message);
ErrorHappened?.Invoke(this, args);
}
catch { }
}
private void ReadWorker_DoWork(object sender, DoWorkEventArgs args)
{
var worker = sender as BackgroundWorker;
if (worker == null)
{
return;
}
Env.Instance.Logger.Trace("ReceiveMessage: Receiving thread start...");
IsWorking = true;
while (!worker.CancellationPending && client.Client != null)
{
Packet packet = null;
try
{
packet = ReadPacket();
}
catch (SocketException se)
{
//如果是网络异常，退出。
#if DEBUG
//Env.Instance.ShowMessage($"desc={se.Message}\nStack={se.StackTrace}");
#endif
ErrorHappened?.Invoke(ErrorType.SocketError);
break;
}
catch (Exception ex)
{
Env.Instance.ShowMessage($"desc={ex.Message}\nStack={ex.StackTrace}");
}
if (packet != null)
{
try
{
PacketReceived?.Invoke(packet);
}
catch (Exception e)
{
#if DEBUG
Env.Instance.ShowMessage("逻辑层处理消息异常。请检查\n" + e.Message + "\n" + e.StackTrace);
#else
Env.Instance.Logger.Error(e);
#endif
}
}
}//end while
IsWorking = false;
Env.Instance.Logger.Trace("ReceiveMessage: Receiving thread end...");
}
public void Close()
{
if (client != null)
{
try
{
client.Close();
}
catch (Exception e) {
ErrorHappened?.Invoke(e.ToString());
}
}
}
public async void WriteTestAsync()
{
if (client != null && GetState(client) == TcpState.Established)
{
byte[] pocket = Encoding.ASCII.GetBytes(counter.ToString("D4"));
var message = testMessage;
if (message.Length > (SIZE - pocket.Length))
{
message = message.Remove(SIZE - pocket.Length);
}
byte[] array = Encoding.ASCII.GetBytes(message);
byte[] data = new byte[SIZE];
pocket.CopyTo(data, 0);
array.CopyTo(data, pocket.Length);
data[SIZE - 1] = Encoding.ASCII.GetBytes("\r")[0];
data[SIZE - 2] = Encoding.ASCII.GetBytes("\n")[0];
try
{
var ws = client.GetStream();
await ws.WriteAsync(data, 0, data.Length).ConfigureAwait(false);
//await ws.WriteAsync(data, 0, data.Length);
await ws.FlushAsync().ConfigureAwait(false);
while (client.Available > 0)
{
var rs = client.GetStream();
//await rs.ReadAsync(data, 0, data.Length);
await rs.ReadAsync(data, 0, data.Length).ConfigureAwait(false);
//await ws.FlushAsync().ConfigureAwait(false);
}
}
catch (Exception e)
{
ErrorHappened?.Invoke(e.ToString());
}
counter = counter >= 9999 ? 0 : ++counter;
}
else
{
ErrorHappened?.Invoke("Connection is empty.");
}
}
public void AcceptTCPClient()
{
if (server != null)
{
server.Start();
try
{
client = new Client.TCPClientWorker(server.AcceptTcpClient());
client.ErrorHappened += OnErrorHappened;
}
catch (Exception e)
{
ErrorHappened?.Invoke(e.ToString());
}
}
}
public void Send(Packet packet)
{
try
{
byte[] buffer = packet.ToBytes(Crypto);
if (buffer == null)
{
return;
}
////TODO 应该检查packet的长度，禁止发送太大的packet,强制上层发送大对象的时候用SequencableItem.
int sentCount = 0;
do
{
sentCount += client.Client.Send(buffer, sentCount, buffer.Length - sentCount, SocketFlags.None);
} while (sentCount < buffer.Length);
}
catch (Exception e)
{
ErrorHappened?.Invoke(ErrorType.SocketError);
}
}
public void Error(string message) => ErrorHappened?.Invoke(this, new MessageEventArgs()
{
Message = message
});
//Mutex appModelMutex;
private AppModel(Env container)
{
//container.Logger.Error("Test Log");
var cfg = Env.Instance.Config;
Devices = new HashSet <Device>();
Conversations = new Dictionary <string, Conversation>();
LocalDevice = cfg.LocalDevice;
var sm = Env.Instance.SecurityManager;
var localConnectCode = sm.LoadString(SecurityManager.LOCAL_CONNECT_CODE);
if (localConnectCode == null)
{
localConnectCode = StringHelper.NewRandomPassword();
sm.SaveString(SecurityManager.LOCAL_CONNECT_CODE, localConnectCode);
}
LocalDevice.ConnectCode = localConnectCode;
LocalDevice.DeviceType = container.DeviceType;
container.InitLocalDeviceIPAdress(LocalDevice);
ChannelManager = new ChannelManager(ChannelPort);
ChannelManager.ChannelCreated += (channel) =>
{
Action <Packet> packetReceiver = null;
packetReceiver = (Packet packet) =>
{
Message message = Message.FromPacket(packet);
ConnectMessage cm = message as ConnectMessage;
//一个新连接的socket，在发送ConnectMessage之前发送其它Message，是不会理会的。
if (cm != null)
{
channel.PacketReceived -= packetReceiver;
var device = AddOrUpdateDevice(cm.Device);
if (device != null)
{
if (PacketHeader.DefaultVersion == packet.Header.version)
{
device.OnConnectMessageReceived(channel, cm);
}
else
{
device.CallPacketProtocolVersionError(PacketHeader.DefaultVersion > packet.Header.version);
}
}
}
;
};
channel.PacketReceived += packetReceiver;
};
ChannelManager.PortOccupiedError += (int port) =>
{
Error error = new Error(Error.PortOccupied);
error.AddError("port", port);
ErrorHappened?.Invoke(error);
};
Discoverer = new LANDiscoverer(LocalDevice, DiscoverPort);
container.NetworkChanged += (ips) =>
{
if (!string.IsNullOrEmpty(ips))
{
container.InitLocalDeviceIPAdress(LocalDevice);
Discoverer.StartBroadcast();
}
};
}
void IXSpi.ProcessError(ErrorField error)
{
ErrorHappened?.Invoke(this, error);
}
private void OnErrorHappened(string message)
{
ErrorHappened?.Invoke(message);
}
