void OnWrite(IAsyncResult ar)
{
try
{
mNetworkStream.EndWrite(ar);
}
catch (Exception ex)
{
this.LogError("OnWrite--->>>" + ex.Message);
}
}
private void DataSent(IAsyncResult ar)
{
try
{
_baseStream.EndWrite(ar);
}
catch
{
Disconnect("Socket closing");
}
}
/// <summary>
/// 向链接写入数据流
/// </summary>
void OnWrite(IAsyncResult r)
{
try
{
outStream.EndWrite(r);
}
catch (Exception ex)
{
Debug.LogError("OnWrite--->>>" + ex.Message);
}
}
void AsyncWriteCallBack(IAsyncResult iar)
{
try
{
NetworkStream ns = (NetworkStream)iar.AsyncState;
ns.EndWrite(iar);
}
catch (Exception ex)
{
}
}
private void SendCallback(IAsyncResult ar)
{
try
{
networkStream.EndWrite(ar);
}
catch (Exception err)
{
consolelist.Invoke(setListBoxCallback, err.Message);
}
}
private void SendCallback(IAsyncResult ar)
{
try
{
netStream.EndWrite(ar);
}
catch (Exception err)
{
outputCallback(err.Message);
}
}
public void Send(byte[] buffer)
{
if (tcpClient != null && tcpClient.Connected)
{
NetworkStream networkStream = tcpClient.GetStream();
networkStream.BeginWrite(buffer, 0, buffer.Length, (ar) =>
{
NetworkStream ns = (NetworkStream)ar.AsyncState;
ns.EndWrite(ar);
}, networkStream);
}
}
private void writeCallback(IAsyncResult ar)
{
//
try {
//Retrieve the stream from the state object and
//complete sending the data to the remote server
NetworkStream stream = (NetworkStream)ar.AsyncState;
stream.EndWrite(ar);
read();
}
catch (Exception e) { Debug.Write(e.ToString() + "\n"); }
}
/// <summary>
/// 向链接写入数据流
/// </summary>
void OnWrite(IAsyncResult r)
{
try {
if ((uint)r.AsyncState != sessionid)
{
return;
}
outStream.EndWrite(r);
} catch (Exception ex) {
Debug.LogError("OnWrite--->>>" + ex.Message);
}
}
/// <summary>
/// 向链接写入数据流
/// </summary>
void OnWrite(IAsyncResult r)
{
try
{
outStream.EndWrite(r);
}
catch (Exception ex)
{
Debug.LogException(ex);
Debug.LogError(string.Format("OnWrite--->>>{0}", ex.Message));
}
}
private void SpeedReportCallback(IAsyncResult ar)
{
try
{
stream.EndWrite(ar);
}
catch
{
client.Close();
disconnectCallback(this);
}
}
void WriteBufferCallBack(IAsyncResult iAsyncResult)
{
bytesStream.EndWrite(iAsyncResult);
isWriting = false;
// Debug.Log("WriteEnd");
GlobalDebug.Addline("WriteEnd");
if (remoteManger.waitingAck)
{
// Debug.Log("WaitingAck...");
GlobalDebug.Addline("WaitingAck...");
}
}
//======================================================================
//----
private void AsyncWriteSomeBytes(NetworkStream strm, ISocketWrapper sock)
{
byte[] data = Encoding.ASCII.GetBytes("ABCDEFHIJK");
IAsyncResult ar = strm.BeginWrite(data, 0, data.Length, null, null);
Assert.IsTrue(sock.Connected, "after Begin expected to be Connected");
strm.EndWrite(ar);
if (!m_connectedMayBeFalseEarlier)
{
Assert.IsTrue(sock.Connected, "after End expected to be Connected");
}
}
//nakon upisivanja niza uzima drugi dio datoteke
private void OnWriteComplete(IAsyncResult ar)
{
networkStream.EndWrite(ar);
Console.WriteLine("Write complete");
//zapocinje ucitavanje ostatke datoteke
networkStream.BeginRead(
buffer, //cuva rezultate
0, //pomak
buffer.Length, //buffersize
myFileCallBack, //delegat povratnog poziva
null); //lokalni objekt stanja
}
/// <summary>
///
/// </summary>
/// <param name="ar"></param>
private void EndSendCallBackStatic(IAsyncResult ar)
{
try
{
m_Stream.EndWrite(ar);
m_Stream.Flush();
}
catch (Exception ex)
{
Logger.Warn(ex, "EndSendCallBackStatic");
}
}
private void HandleSendDataEnd(IAsyncResult ar)
{
TcpClient client = (TcpClient)ar.AsyncState;
NetworkStream ns = client.GetStream();
ns.EndWrite(ar);
if (CloseAfterSend)
{
ns.Close();
client.Close();
}
}
private void WriteCallback(IAsyncResult ar)
{
try
{
NetworkStream outStream = (NetworkStream)ar.AsyncState;
outStream.EndWrite(ar);
}
catch (Exception)
{
throw new Exception("Server is offline");
}
}
private static void SendCallback(IAsyncResult ar)
{
try {
// Retrieve the socket from the state object.
NetworkStream handler = (NetworkStream)ar.AsyncState;
// Complete sending the data to the remote device.
handler.EndWrite(ar);
} catch (Exception e) {
Debug.LogError(e);
}
}
/// <summary>
/// 完成发送数据动作后的回调函数
/// </summary>
/// <param name="iar"></param>
/// <date>2017-07-17</date>
/// <author>冯旗</author>
private void SendCallBack(IAsyncResult iar)
{
try
{
ns.EndWrite(iar);
}
catch (Exception e)
{
OnClientError(e.Message);
return;
}
}
private void AsyncWrite(IAsyncResult ar)
{
try
{
NetworkStream stream = _tcp.GetStream();
stream.EndWrite(ar);
}
catch (System.Exception ex)
{
OnException(ex);
}
}
protected void OnSendCallBack(IAsyncResult result)
{
try
{
networkStream.EndWrite(result);
}
catch (Exception ex)
{
OnError(this, new ExceptionEventArgs(ex));
Dispose();
}
}
void SendComplete(IAsyncResult result)
{
try
{
_networkStream.EndWrite(result);
}
catch (Exception e)
{
ProcessError(e);
return;
}
}
private void EndWriteCb(IAsyncResult ar)
{
try
{
m_ClientStream.EndWrite(ar);
}
catch (Exception ex)
{
AOutput.Log($"EndWriteCb {ex.Message}");
AddDisconectPacket();
}
}
/// <summary>
/// A callback when the ID has been sent to the server
/// </summary>
/// <param name="ar"></param>
private void ServerIDSentCallback(IAsyncResult ar)
{
try
{
server.EndWrite(ar);
if (dataLengthExpected)
{
client.BeginRead(packageIntReceiveBuffer, 0, IntSize, ClientLengthReceived, null);
}
else
{
ClientBeginListenForData();
}
}
catch (Exception ex)
{
Disconnect();
logError(ex);
}
}
/// <summary>
/// 向链接写入数据流
/// </summary>
void OnWrite(IAsyncResult r)
{
try
{
outStream.EndWrite(r);
}
catch (Exception ex)
{
// Util.Log("Catch Exception!:{0}", ex.StackTrace);
OnDisconnected(DisType.Exception, ex.Message + "OnWirte-----------" + ex.StackTrace);
}
}
private void SendCallback(IAsyncResult result)
{
if (!TcpClient.Connected)
{
return;
}
try {
NetworkStream networkStream = TcpClient.GetStream();
networkStream.EndWrite(result);
} catch { }
}
private void _WriteCallback(IAsyncResult ar)
{
Debug.Print("IdentHandler._WriteCallback( )");
try {
_stream.EndWrite(ar);
}
catch (Exception e) {
Debug.Print("IdentServer._WriteCallback: _buffer.EndWrite threw exception:\n{0}", e);
}
_stream.Close( );
_tcpClient.Close( );
}
/// <summary>
/// 向链接写入数据流
/// </summary>
void OnWrite(IAsyncResult r)
{
try
{
outStream.EndWrite(r);
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
ConsoleView.LogError(string.Format("OnWrite--->>>{0}", ex.Message));
}
}
/// <summary>
/// Sends the specified packet to the client
/// </summary>
/// <param name="packet">The packet to send</param>
/// <exception cref="Exception">Not connected</exception>
private void SendPacket(RemoteConPacket packet)
{
if (!_client.Connected)
{
throw new Exception("Not connected.");
}
var packetBytes = packet.GetBytes();
//_ns.Write(packetBytes, 0, packetBytes.Length);
_ns.BeginWrite(packetBytes, 0, packetBytes.Length - 1, ar => { _ns.EndWrite(ar); }, null);
}
private void writeCallback(IAsyncResult ar)
{
try
{
netStream.EndWrite(ar);
WriteCompleted?.Invoke(this, new NetworkMessageWriterWriteCompletedEventArgs(ar.AsyncState as NetworkMessage, TcpClient));
}
catch (Exception ex)
{
WriteError?.Invoke(this, new NetworkMessageWriterWriteErrorEventArgs(ar.AsyncState as NetworkMessage, TcpClient, ex));
}
}
/// <summary>
/// Envia un mensaje a la red mediante esta maquina remota
/// </summary>
/// <param name="netMessage">el mensaje a enviar</param>
/// <param name="timeOutWriteTCP">el tiempo maximo de espera para el envio</param>
public void sendNetMessage(NetMessage netMessage, Int32 timeOutWriteTCP)
{
lock (sendTCPLock)
{
Fails++;
senderStream = new NetworkStream(TcpClient.Client, false);
try
{
//senderStream.WriteTimeout = timeOutWriteTCP;
byte[] lenght = BitConverter.GetBytes(netMessage.getSize());
byte[] netByteMessage = new byte[4 + netMessage.getSize()];
IAsyncResult result = senderStream.BeginWrite(lenght, 0, 4, null, null);
bool success = result.AsyncWaitHandle.WaitOne(timeOutWriteTCP, false);
if (!success)
{
throw new Exception("TCP: intento de conexión ha tardado demasiado");
}
else
{
senderStream.EndWrite(result);
}
result = senderStream.BeginWrite(netMessage.Body, 0, netMessage.getSize(), null, null);
success = result.AsyncWaitHandle.WaitOne(timeOutWriteTCP, false);
if (!success)
{
throw new Exception("TCP: intento de conexión ha tardado demasiado");
}
else
{
senderStream.EndWrite(result);
}
senderStream.Close();
Fails = 0;
}
catch (ThreadAbortException e)
{
try
{
senderStream.Close();
}
catch (Exception)
{
}
throw e;
}
catch (Exception)
{
try
{
senderStream.Close();
}
catch (Exception)
{
}
throw;
}
}
}
