/// <summary>
/// Recupera o hashcode da mensagem inforamda.
/// </summary>
/// <param name="obj"></param>
/// <returns></returns>
public override int GetHashCode(IMessageFormattable obj)
{
if (obj == null)
{
throw new ArgumentNullException("obj");
}
if (this._ignoreCase)
{
return(StringComparer.InvariantCultureIgnoreCase.GetHashCode(obj.Format(_culture)));
}
return(StringComparer.InvariantCulture.GetHashCode(obj.Format(_culture)));
}
/// <summary>
/// Compara as instancias informadas.
/// </summary>
/// <param name="x"></param>
/// <param name="y"></param>
/// <returns></returns>
public override bool Equals(IMessageFormattable x, IMessageFormattable y)
{
if (object.ReferenceEquals(x, y))
{
return(true);
}
if ((x == null) || (y == null))
{
return(false);
}
return(_compareInfo.Compare(x.Format(_culture), y.Format(_culture), _ignoreCase ? CompareOptions.IgnoreCase : CompareOptions.None) == 0);
}
/// <summary>
/// Compara as instancias informadas.
/// </summary>
/// <param name="x"></param>
/// <param name="y"></param>
/// <returns></returns>
public override int Compare(IMessageFormattable x, IMessageFormattable y)
{
if (object.ReferenceEquals(x, y))
{
return(0);
}
if (x == null)
{
return(-1);
}
if (y == null)
{
return(1);
}
return(_compareInfo.Compare(x.Format(_culture), y.Format(_culture), _ignoreCase ? System.Globalization.CompareOptions.IgnoreCase : System.Globalization.CompareOptions.None));
}
/// <summary>
/// Verifica se as instancias informadas são iguais.
/// </summary>
/// <param name="x"></param>
/// <param name="y"></param>
/// <returns></returns>
public override bool Equals(IMessageFormattable x, IMessageFormattable y)
{
if (object.ReferenceEquals(x, y))
{
return(true);
}
if ((x == null) || (y == null))
{
return(false);
}
if (!_ignoreCase)
{
return(x.Equals(y));
}
var xStr = x.Format(_culture);
var yStr = y.Format(_culture);
if (xStr.Length != yStr.Length)
{
return(false);
}
return(StringComparer.OrdinalIgnoreCase.Compare(xStr, yStr) == 0);
}
/// <summary>
/// Compar as instancias informadas.
/// </summary>
/// <param name="x"></param>
/// <param name="y"></param>
/// <returns></returns>
public override int Compare(IMessageFormattable x, IMessageFormattable y)
{
if (object.ReferenceEquals(x, y))
{
return(0);
}
if (x == null)
{
return(-1);
}
if (y == null)
{
return(1);
}
var xStr = x.Format(_culture);
var yStr = y.Format(_culture);
if (_ignoreCase)
{
return(StringComparer.OrdinalIgnoreCase.Compare(xStr, yStr));
}
return(string.CompareOrdinal(xStr, yStr));
}
/// <summary>
/// Escreve uma nava entrada de log do tipo de Exception.
/// </summary>
/// <param name="message">Mensagem do corpo do log.</param>
/// <param name="exception">Instancia da exception ocorrida.</param>
/// <param name="priority">Prioridade do log.</param>
/// <returns>True se o log foi salvo com sucesso.</returns>
public override bool Write(IMessageFormattable message, Exception exception, Priority priority)
{
if (exception != null)
{
var exceptionMessage = exception.Message;
var stackTrace = exception.StackTrace;
var exceptionText = new StringBuilder();
while (exception != null)
{
exceptionText.AppendFormat("{0} : {1}\r\n", exception.GetType().Name, exception.Message);
exception = exception.InnerException;
}
message = string.Format("Message: {0}\r\nException: {1} : {2}", message != null ? message.Format(CultureInfo.InvariantCulture) : exceptionMessage, exceptionText.ToString(), stackTrace).GetFormatter();
}
return(Write(message, Category.Exception, priority));
}
/// <summary>
/// Escreve uma nova entrada de log com uma categoria e prioridade especificada.
/// </summary>
/// <param name="message">Mensagem do corpo do log.</param>
/// <param name="category">Categoria da entrada.</param>
/// <param name="priority">Prioridade da entrada.</param>
/// <returns>True se o log foi salvo com sucesso.</returns>
public override bool Write(IMessageFormattable message, Category category, Priority priority)
{
string messageToLog = String.Format(CultureInfo.InvariantCulture, Colosoft.Properties.Resources.DefaultTextLoggerPattern, DateTime.Now, category.ToString().ToUpper(CultureInfo.InvariantCulture), message.Format(CultureInfo.CurrentCulture), priority.ToString());
try
{
System.Diagnostics.Trace.WriteLine(messageToLog);
return(true);
}
catch
{
return(false);
}
}
/// <summary>
/// Verifica se as instancia são equivalentes
/// </summary>
/// <param name="other"></param>
/// <returns></returns>
public bool Equals(IMessageFormattable other)
{
if (other == null)
{
return(false);
}
return(StringComparer.Ordinal.Equals(this.Format(System.Globalization.CultureInfo.InvariantCulture, _parameters), other.Format(System.Globalization.CultureInfo.InvariantCulture, _parameters)));
}
/// <summary>
/// Escreve uma nova entrada de log com uma categoria e prioridade especificada.
/// </summary>
/// <param name="message">Mensagem do corpo do log.</param>
/// <param name="category">Categoria da entrada.</param>
/// <param name="priority">Prioridade da entrada.</param>
/// <returns>True se o log foi salvo com sucesso.</returns>
public override bool Write(IMessageFormattable message, Category category, Priority priority)
{
string messageToLog = String.Format(CultureInfo.InvariantCulture, Colosoft.Properties.Resources.FileLoggerPattern, DateTime.Now.ToString("MM/dd/yy H:mm:ss.fffffff"), category.ToString().ToUpper(CultureInfo.InvariantCulture), message.Format(CultureInfo.CurrentCulture), priority.ToString());
try
{
if (File.Exists(FilePath))
{
using (var writer = File.AppendText(FilePath))
{
writer.WriteLine(messageToLog);
}
}
else
{
using (var writer = File.CreateText(FilePath))
{
writer.WriteLine(messageToLog);
}
}
return(true);
}
catch
{
return(false);
}
}
/// <summary>
/// Verifica se o valor da mensagem é nulo ou vazio.
/// </summary>
/// <param name="message"></param>
/// <returns></returns>
public static bool IsNullOrEmpty(this IMessageFormattable message)
{
return(message == null || string.IsNullOrEmpty(message.Format()));
}
/// <summary>
/// Formata o valor da mensagem, caso ela seja nula retorna o valor null.
/// </summary>
/// <param name="message"></param>
/// <returns></returns>
public static string FormatOrNull(this IMessageFormattable message)
{
return(message == null ? null : message.Format());
}
/// <summary>
/// Construtor padrão.
/// </summary>
/// <param name="message">Instancia da mensagem formatável.</param>
/// <param name="innerException"></param>
public DetailsException(IMessageFormattable message, Exception innerException) : base(message != null ? message.Format() : "", innerException)
{
_messageFormattable = message;
}
/// <summary>
/// Construtor padrão.
/// </summary>
/// <param name="message">Instancia da mensagem formatável.</param>
public DetailsException(IMessageFormattable message) : base(message != null ? message.Format() : "")
{
_messageFormattable = message;
}
/// <summary>
/// Construtor padrão.
/// </summary>
/// <param name="message">Instancia da mensagem formatável.</param>
public DetailsInvalidOperationException(IMessageFormattable message) : base(message != null ? message.Format() : "")
{
}
/// <summary>
/// Formata a mensagem.
/// </summary>
/// <returns>Texto da mensagem formatada.</returns>
public string Format()
{
return(string.Format("{0}{1}{2}", _leftMessage.Format(), _separator, _rightMessage.Format()));
}
