/// <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())); }