/// <summary>
/// Method ProcessReceive.
/// </summary>
/// <param name="receiveSocketAsyncEventArgs">Instance of SocketAsyncEventArgs.</param>
private void ProcessReceive(SocketAsyncEventArgs receiveSocketAsyncEventArgs)
{
if (receiveSocketAsyncEventArgs != null && receiveSocketAsyncEventArgs.BytesTransferred > 0 && receiveSocketAsyncEventArgs.SocketError == SocketError.Success)
{
IPEndPoint sessionIPEndPoint = null;
try
{
sessionIPEndPoint = this._clientSocket.LocalEndPoint as IPEndPoint;
}
catch
{
}
try
{
Interlocked.Add(ref this._totalBytesReceived, receiveSocketAsyncEventArgs.BytesTransferred);
this.RaiseEvent(
this.DataReceived,
new AsyncSocketSessionEventArgs(
this.SessionId,
sessionIPEndPoint,
receiveSocketAsyncEventArgs.Buffer,
receiveSocketAsyncEventArgs.BytesTransferred,
receiveSocketAsyncEventArgs.Offset,
receiveSocketAsyncEventArgs.UserToken));
try
{
bool willRaiseEvent = this._clientSocket.ReceiveAsync(receiveSocketAsyncEventArgs);
if (!willRaiseEvent)
{
this.ProcessReceive(receiveSocketAsyncEventArgs);
}
}
catch
{
throw;
}
}
catch (Exception e)
{
InternalLogger.Log(e);
this.RaiseEvent(
this.ErrorOccurred,
new AsyncSocketErrorEventArgs(
AsyncSocketTcpClientConstants.TcpClientReceiveException,
e,
AsyncSocketErrorCodeEnum.TcpClientReceiveException));
}
}
else
{
IPEndPoint sessionIPEndPoint = null;
try
{
sessionIPEndPoint = this._clientSocket.LocalEndPoint as IPEndPoint;
}
catch
{
}
this.RaiseEvent(this.Disconnected, new AsyncSocketSessionEventArgs(this.SessionId, sessionIPEndPoint));
}
}
public bool Send(int sessionId, byte[] buffer)
{
this.CheckDisposed();
if (!this.IsListening)
{
return(false);
}
SocketAsyncEventArgs sessionSocketAsyncEventArgs = null;
lock (this._syncRoot)
{
if (this._sessionDictionary.ContainsKey(sessionId))
{
sessionSocketAsyncEventArgs = this._sessionDictionary[sessionId];
}
}
if (sessionSocketAsyncEventArgs != null)
{
Socket sessionSocket = sessionSocketAsyncEventArgs.UserToken as Socket;
if (sessionSocket != null)
{
SocketAsyncEventArgs sendSocketAsyncEventArgs = null;
try
{
sendSocketAsyncEventArgs = new SocketAsyncEventArgs();
sendSocketAsyncEventArgs.UserToken = sessionSocket;
sendSocketAsyncEventArgs.SetBuffer(buffer, 0, buffer.Length);
sendSocketAsyncEventArgs.Completed += this.SendSocketAsyncEventArgsCompleted;
try
{
bool willRaiseEvent = sessionSocket.SendAsync(sendSocketAsyncEventArgs);
if (!willRaiseEvent)
{
this.ProcessSend(sendSocketAsyncEventArgs);
}
return(true);
}
catch
{
throw;
}
}
catch (Exception e)
{
if (sendSocketAsyncEventArgs != null)
{
sendSocketAsyncEventArgs.Completed -= this.SendSocketAsyncEventArgsCompleted;
sendSocketAsyncEventArgs.UserToken = null;
sendSocketAsyncEventArgs.Dispose();
sendSocketAsyncEventArgs = null;
}
InternalLogger.Log(e);
this.RaiseEvent(
this.ErrorOccurred,
new AsyncSocketErrorEventArgs(
AsyncSocketTcpServerConstants.TcpServerSendException,
e,
AsyncSocketErrorCodeEnum.TcpServerSendException));
}
}
}
return(false);
}
/// <summary>
/// Establishes a connection to a remote host.
/// </summary>
/// <param name="throwOnError">true to throw any exception that occurs.-or- false to ignore any exception that occurs.</param>
/// <returns>true if succeeded; otherwise, false.</returns>
public bool Start(bool throwOnError = false)
{
this.CheckDisposed();
if (!this.IsConnected)
{
try
{
IPEndPoint remoteIPEndPoint = new IPEndPoint(IPAddress.Parse(this.RemoteIP), this.RemotePort);
this.CloseConnectSocketAsyncEventArgs();
this.CloseClientSocket();
this.CloseReceiveSocketAsyncEventArgs();
this._clientSocket = new Socket(remoteIPEndPoint.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
this._clientSocket.SetSocketOption(SocketOptionLevel.Tcp, SocketOptionName.NoDelay, true);
this._clientSocket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, true);
this._clientSocket.UseOnlyOverlappedIO = true;
this._connectSocketAsyncEventArgs = new SocketAsyncEventArgs();
this._connectSocketAsyncEventArgs.RemoteEndPoint = remoteIPEndPoint;
this._connectSocketAsyncEventArgs.UserToken = this._clientSocket;
this._connectSocketAsyncEventArgs.Completed += this.ConnectSocketAsyncEventArgsCompleted;
this.SessionId = this._clientSocket.GetHashCode();
try
{
bool willRaiseEvent = this._clientSocket.ConnectAsync(this._connectSocketAsyncEventArgs);
if (!willRaiseEvent)
{
this.ProcessConnect();
}
Debug.WriteLine(AsyncSocketTcpClientConstants.TcpClientStartSucceeded);
this.RaiseEvent(this.Started);
return(true);
}
catch
{
throw;
}
}
catch (Exception e)
{
Debug.WriteLine(AsyncSocketTcpClientConstants.TcpClientStartException);
InternalLogger.Log(e);
this.RaiseEvent(
this.ErrorOccurred,
new AsyncSocketErrorEventArgs(
AsyncSocketTcpClientConstants.TcpClientStartException,
e,
AsyncSocketErrorCodeEnum.TcpClientStartException));
if (throwOnError)
{
throw;
}
}
}
return(false);
}
public void WriteToStringWriterTests()
{
try
{
// Expected result is the same for both types of method invocation.
const string expected = "Warn WWW\nError EEE\nFatal FFF\nTrace TTT\nDebug DDD\nInfo III\n";
InternalLogger.LogLevel = LogLevel.Trace;
InternalLogger.IncludeTimestamp = false;
{
StringWriter writer1 = new StringWriter()
{
NewLine = "\n"
};
InternalLogger.LogWriter = writer1;
// Named (based on LogLevel) public methods.
InternalLogger.Warn("WWW");
InternalLogger.Error("EEE");
InternalLogger.Fatal("FFF");
InternalLogger.Trace("TTT");
InternalLogger.Debug("DDD");
InternalLogger.Info("III");
TestWriter(expected, writer1);
}
{
//
// Reconfigure the LogWriter.
StringWriter writer2 = new StringWriter()
{
NewLine = "\n"
};
InternalLogger.LogWriter = writer2;
// Invoke Log(LogLevel, string) for every log level.
InternalLogger.Log(LogLevel.Warn, "WWW");
InternalLogger.Log(LogLevel.Error, "EEE");
InternalLogger.Log(LogLevel.Fatal, "FFF");
InternalLogger.Log(LogLevel.Trace, "TTT");
InternalLogger.Log(LogLevel.Debug, "DDD");
InternalLogger.Log(LogLevel.Info, "III");
TestWriter(expected, writer2);
}
{
//
// Reconfigure the LogWriter.
StringWriter writer2 = new StringWriter()
{
NewLine = "\n"
};
InternalLogger.LogWriter = writer2;
// Invoke Log(LogLevel, string) for every log level.
InternalLogger.Log(LogLevel.Warn, () => "WWW");
InternalLogger.Log(LogLevel.Error, () => "EEE");
InternalLogger.Log(LogLevel.Fatal, () => "FFF");
InternalLogger.Log(LogLevel.Trace, () => "TTT");
InternalLogger.Log(LogLevel.Debug, () => "DDD");
InternalLogger.Log(LogLevel.Info, () => "III");
TestWriter(expected, writer2);
}
}
finally
{
InternalLogger.Reset();
}
}
public void ExceptionTests()
{
using (new InternalLoggerScope())
{
InternalLogger.LogLevel = LogLevel.Trace;
InternalLogger.IncludeTimestamp = false;
var ex1 = new Exception("e1");
var ex2 = new Exception("e2", new Exception("inner"));
var ex3 = new NLogConfigurationException("config error");
var ex4 = new NLogConfigurationException("config error", ex2);
var ex5 = new PathTooLongException();
ex5.Data["key1"] = "value1";
Exception ex6 = null;
const string prefix = " Exception: ";
{
string expected =
"Warn WWW1" + prefix + ex1 + Environment.NewLine +
"Error EEE1" + prefix + ex2 + Environment.NewLine +
"Fatal FFF1" + prefix + ex3 + Environment.NewLine +
"Trace TTT1" + prefix + ex4 + Environment.NewLine +
"Debug DDD1" + prefix + ex5 + Environment.NewLine +
"Info III1" + Environment.NewLine;
StringWriter consoleOutWriter = new StringWriter()
{
NewLine = Environment.NewLine
};
// Redirect the console output to a StringWriter.
InternalLogger.LogWriter = consoleOutWriter;
// Named (based on LogLevel) public methods.
InternalLogger.Warn(ex1, "WWW1");
InternalLogger.Error(ex2, "EEE1");
InternalLogger.Fatal(ex3, "FFF1");
InternalLogger.Trace(ex4, "TTT1");
InternalLogger.Debug(ex5, "DDD1");
InternalLogger.Info(ex6, "III1");
consoleOutWriter.Flush();
var strings = consoleOutWriter.ToString();
Assert.Equal(expected, strings);
}
{
string expected =
"Warn WWW2" + prefix + ex1 + Environment.NewLine +
"Error EEE2" + prefix + ex2 + Environment.NewLine +
"Fatal FFF2" + prefix + ex3 + Environment.NewLine +
"Trace TTT2" + prefix + ex4 + Environment.NewLine +
"Debug DDD2" + prefix + ex5 + Environment.NewLine +
"Info III2" + Environment.NewLine;
StringWriter consoleOutWriter = new StringWriter()
{
NewLine = Environment.NewLine
};
// Redirect the console output to a StringWriter.
InternalLogger.LogWriter = consoleOutWriter;
// Named (based on LogLevel) public methods.
InternalLogger.Warn(ex1, () => "WWW2");
InternalLogger.Error(ex2, () => "EEE2");
InternalLogger.Fatal(ex3, () => "FFF2");
InternalLogger.Trace(ex4, () => "TTT2");
InternalLogger.Debug(ex5, () => "DDD2");
InternalLogger.Info(ex6, () => "III2");
consoleOutWriter.Flush();
var strings = consoleOutWriter.ToString();
Assert.Equal(expected, strings);
}
{
string expected =
"Warn WWW3" + prefix + ex1 + Environment.NewLine +
"Error EEE3" + prefix + ex2 + Environment.NewLine +
"Fatal FFF3" + prefix + ex3 + Environment.NewLine +
"Trace TTT3" + prefix + ex4 + Environment.NewLine +
"Debug DDD3" + prefix + ex5 + Environment.NewLine +
"Info III3" + Environment.NewLine;
StringWriter consoleOutWriter = new StringWriter()
{
NewLine = Environment.NewLine
};
// Redirect the console output to a StringWriter.
InternalLogger.LogWriter = consoleOutWriter;
// Named (based on LogLevel) public methods.
InternalLogger.Log(ex1, LogLevel.Warn, "WWW3");
InternalLogger.Log(ex2, LogLevel.Error, "EEE3");
InternalLogger.Log(ex3, LogLevel.Fatal, "FFF3");
InternalLogger.Log(ex4, LogLevel.Trace, "TTT3");
InternalLogger.Log(ex5, LogLevel.Debug, "DDD3");
InternalLogger.Log(ex6, LogLevel.Info, "III3");
consoleOutWriter.Flush();
var strings = consoleOutWriter.ToString();
Assert.Equal(expected, strings);
}
{
string expected =
"Warn WWW4" + prefix + ex1 + Environment.NewLine +
"Error EEE4" + prefix + ex2 + Environment.NewLine +
"Fatal FFF4" + prefix + ex3 + Environment.NewLine +
"Trace TTT4" + prefix + ex4 + Environment.NewLine +
"Debug DDD4" + prefix + ex5 + Environment.NewLine +
"Info III4" + Environment.NewLine;
StringWriter consoleOutWriter = new StringWriter()
{
NewLine = Environment.NewLine
};
// Redirect the console output to a StringWriter.
InternalLogger.LogWriter = consoleOutWriter;
// Named (based on LogLevel) public methods.
InternalLogger.Log(ex1, LogLevel.Warn, () => "WWW4");
InternalLogger.Log(ex2, LogLevel.Error, () => "EEE4");
InternalLogger.Log(ex3, LogLevel.Fatal, () => "FFF4");
InternalLogger.Log(ex4, LogLevel.Trace, () => "TTT4");
InternalLogger.Log(ex5, LogLevel.Debug, () => "DDD4");
InternalLogger.Log(ex6, LogLevel.Info, () => "III4");
var strings = consoleOutWriter.ToString();
Assert.Equal(expected, strings);
}
}
}
public void WriteToConsoleOutTests()
{
// Expected result is the same for both types of method invocation.
const string expected = "Warn WWW\nError EEE\nFatal FFF\nTrace TTT\nDebug DDD\nInfo III\n";
using (var loggerScope = new InternalLoggerScope(true))
{
InternalLogger.LogLevel = LogLevel.Trace;
InternalLogger.IncludeTimestamp = false;
InternalLogger.LogToConsole = true;
{
StringWriter consoleOutWriter1 = new StringWriter()
{
NewLine = "\n"
};
// Redirect the console output to a StringWriter.
loggerScope.SetConsoleOutput(consoleOutWriter1);
// Named (based on LogLevel) public methods.
InternalLogger.Warn("WWW");
InternalLogger.Error("EEE");
InternalLogger.Fatal("FFF");
InternalLogger.Trace("TTT");
InternalLogger.Debug("DDD");
InternalLogger.Info("III");
TestWriter(expected, consoleOutWriter1);
}
//
// Redirect the console output to another StringWriter.
{
StringWriter consoleOutWriter2 = new StringWriter()
{
NewLine = "\n"
};
loggerScope.SetConsoleOutput(consoleOutWriter2);
// Invoke Log(LogLevel, string) for every log level.
InternalLogger.Log(LogLevel.Warn, "WWW");
InternalLogger.Log(LogLevel.Error, "EEE");
InternalLogger.Log(LogLevel.Fatal, "FFF");
InternalLogger.Log(LogLevel.Trace, "TTT");
InternalLogger.Log(LogLevel.Debug, "DDD");
InternalLogger.Log(LogLevel.Info, "III");
TestWriter(expected, consoleOutWriter2);
}
//lambdas
{
StringWriter consoleOutWriter1 = new StringWriter()
{
NewLine = "\n"
};
// Redirect the console output to a StringWriter.
loggerScope.SetConsoleOutput(consoleOutWriter1);
// Named (based on LogLevel) public methods.
InternalLogger.Warn(() => "WWW");
InternalLogger.Error(() => "EEE");
InternalLogger.Fatal(() => "FFF");
InternalLogger.Trace(() => "TTT");
InternalLogger.Debug(() => "DDD");
InternalLogger.Info(() => "III");
TestWriter(expected, consoleOutWriter1);
}
}
}
public void Log <TState>(LogLevel logLevel, EventId eventId, TState state, Exception exception, Func <TState, Exception, string> formatter)
{
InternalLogger.Log(logLevel, eventId, state, exception, formatter);
XLog(logLevel, formatter.Invoke(state, exception));
}
