internal RuntimeException(string message, string errorId, ErrorCategory category, object target)
     : base(message, null)
 {
     Id = errorId;
     Category = category;
     TargetObject = target;
 }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="fullyQualifiedErrorId"></param>
        /// <param name="errorCategory"></param>
        /// <param name="innerException"></param>
        /// <param name="resourceId"></param>
        /// <param name="resourceParms"></param>
        /// <returns></returns>
        internal static ErrorRecord CreateErrorRecord(
            string fullyQualifiedErrorId,
            ErrorCategory errorCategory,
            Exception innerException,
            string resourceId,
            params object[] resourceParms)
        {
            InvalidOperationException invalidOperationException;

            string errorMessage = string.Format(
                CultureInfo.CurrentCulture,
                resourceId,
                resourceParms);

            if (innerException != null)
            {
                invalidOperationException = new InvalidOperationException(errorMessage, innerException);
            }
            else
            {
                invalidOperationException = new InvalidOperationException(errorMessage);
            }

            ErrorRecord errorRecord = new ErrorRecord(
                invalidOperationException,
                fullyQualifiedErrorId,
                errorCategory,
                null);

            return errorRecord;
        }

 /// <summary>
 /// Class constructor
 /// </summary>
 /// <param name="errorId">FullyQualifiedErrorId</param>
 /// <param name="message">exception message</param>
 /// <param name="cat">category</param>
 /// <param name="targetObject">target object</param>
 /// <param name="innerException">inner exception</param>
 internal UpdatableHelpSystemException(string errorId, string message, ErrorCategory cat, object targetObject, Exception innerException)
     : base(message, innerException)
 {
     FullyQualifiedErrorId = errorId;
     ErrorCategory = cat;
     TargetObject = targetObject;
 }

 public static void SetUpException(ref Exception exception, string errorCode, ErrorCategory errorCategory,
                                   object target)
 {
     exception.Data[ERROR_CODE] = errorCode;
     exception.Data[ERROR_CATEGORY] = errorCategory;
     exception.Data[ERROR_TARGET] = target;
 }

 internal PSInvalidOperationException(string message, string id, ErrorCategory errorCategory,
                                      Exception innerException, bool terminating = true)
     : base(message, innerException)
 {
     Terminating = terminating;
     ErrorRecord = new ErrorRecord(this, id, errorCategory, null);
 }

 protected SessionStateException(SerializationInfo info, StreamingContext context) : base(info, context)
 {
     this._itemName = string.Empty;
     this._errorId = "SessionStateException";
     this._errorCategory = ErrorCategory.InvalidArgument;
     this._sessionStateCategory = (System.Management.Automation.SessionStateCategory) info.GetInt32("SessionStateCategory");
 }

        //public EventHandler<NavigationRequestedEventArgs> NavigationRequested { get; set; }
        private void DisplayErrors(ErrorCategory category)
        {
            lvErrors.Items.Clear();
            if (errors == null)
                return;

            int errorCount = 0, warningCount = 0, messageCount = 0;
            foreach (Error error in errors)
            {
                if ((error.Category & category) != 0)
                {
                    ListViewItem item = new ListViewItem();
                    item.Text = error.Location.ToString();
                    item.SubItems.Add(error.Message);
                    item.Tag = error;
                    lvErrors.Items.Add(item);
                }
                switch (error.Category)
                {
                    case ErrorCategory.Error: errorCount++; break;
                    case ErrorCategory.Warning: warningCount++; break;
                    case ErrorCategory.Message: messageCount++; break;
                }
            }

            btnErrors.Text = errorCount + " Errors";
            btnWarnings.Text = warningCount + " Warnings";
            btnMessages.Text = messageCount + " Messages";

            btnErrors.Enabled = (errorCount > 0);
            btnWarnings.Enabled = (warningCount > 0);
            btnMessages.Enabled = (messageCount > 0);
        }

 public ErrorRecord(Exception exception, string errorId, ErrorCategory errorCategory, object targetObject)
 {
     Exception = exception;
     ErrorId = errorId;
     TargetObject = targetObject;
     CategoryInfo = new ErrorCategoryInfo(exception, errorCategory);
 }

 internal ErrorCategoryInfo(Exception exception, ErrorCategory category)
 {
     this.Category = category;
     this.Activity = string.Empty;
     this.Reason = exception.GetType().Name;
     this.TargetName = string.Empty;
     this.TargetType = string.Empty;
 }

 internal CommandNotFoundException(string commandName, Exception innerException, string errorIdAndResourceId, string resourceStr, params object[] messageArgs) : base(BuildMessage(commandName, errorIdAndResourceId, resourceStr, messageArgs), innerException)
 {
     this.commandName = string.Empty;
     this._errorId = "CommandNotFoundException";
     this._errorCategory = ErrorCategory.ObjectNotFound;
     this.commandName = commandName;
     this._errorId = errorIdAndResourceId;
 }

 /// <summary>
 /// Throws a terminating error.
 /// </summary>
 /// <param name="targetObject">Object which caused this exception.</param>
 /// <param name="errorId">ErrorId for this error.</param>
 /// <param name="innerException">Complete exception object.</param>
 /// <param name="category">ErrorCategory for this exception.</param>
 internal void ThrowError(
     Object targetObject,
     string errorId,
     Exception innerException,
     ErrorCategory category)
 {
     ThrowTerminatingError(new ErrorRecord(innerException, errorId, category, targetObject));
 }

 /// <summary>
 /// Initializes a new instance of the <see cref="OrchardProviderException"/> class.
 /// </summary>
 /// <param name="message">The exception's message.</param>
 /// <param name="fatal">if set to <c>true</c> indicates that the error is fatal.</param>
 /// <param name="errorId">The error identifier.</param>
 /// <param name="category">The error category.</param>
 public OrchardProviderException(
     string message, 
     bool fatal, 
     string errorId, 
     ErrorCategory category = ErrorCategory.NotSpecified) 
     : base(message, fatal, errorId, category) 
 {
 }

 public ReportableException(string message, Exception innerException, ErrorCategory category,
                            string errorId, object targetObject)
     : base(message, innerException)
 {
     _category = category;
     _errorId = errorId;
     _targetObject = targetObject;
 }

 internal ParameterBindingValidationException(Exception innerException, ErrorCategory errorCategory, InvocationInfo invocationInfo, IScriptExtent errorPosition, string parameterName, Type parameterType, Type typeSpecified, string resourceBaseName, string errorIdAndResourceId, params object[] args) : base(innerException, errorCategory, invocationInfo, errorPosition, parameterName, parameterType, typeSpecified, resourceBaseName, errorIdAndResourceId, args)
 {
     ValidationMetadataException exception = innerException as ValidationMetadataException;
     if ((exception != null) && exception.SwallowException)
     {
         this._swallowException = true;
     }
 }

 internal PSInvalidOperationException(string message, Exception innerException, string errorId, ErrorCategory errorCategory, object target) : base(message, innerException)
 {
     this._errorId = "InvalidOperation";
     this._errorCategory = ErrorCategory.InvalidOperation;
     this._errorId = errorId;
     this._errorCategory = errorCategory;
     this._target = target;
 }

        /// <summary>
        /// See <see cref="ILogHelper.DefineFatalLogMessage"/> for more details.
        /// </summary>
        /// <param name="message">
        /// The message to be logged.
        /// </param>
        /// <param name="errorCategory">
        /// The specifics of the error origin.
        /// </param>
        /// <param name="errorType">
        /// The type of error being logged.
        /// </param>
        /// <param name="exception">
        /// The exception (if one exists) associated with the error.
        /// </param>
        /// <returns>
        /// A new, initalised <see cref="LogMessage"/> instance.
        /// </returns>
        public LogMessage DefineFatalLogMessage(string message, ErrorCategory errorCategory, ErrorType errorType, BaseException exception = null)
        {
            var logMessage = new LogMessage(TraceEventType.Critical);

            logMessage.Exception = exception;
            logMessage.Message = message;
            logMessage.ErrorCode = new ErrorCode(Severity.Critical, errorCategory, errorType);

            return logMessage;
        }

        public void CreateFromException_WithExceptionAndErrorCategory_ReturnsErrorRecordWithSameErrorCategory(
        ErrorCategory errorCategory,
        Exception exception)
        {
            // When
            var result = ErrorRecordFactory.CreateFromException(exception, errorCategory);

            // Then
            Assert.Equal(errorCategory, result.CategoryInfo.Category);
        }

 public static void GenerateSecurityExceptionResponse(this HttpActionContext actionContext, Type responsePayloadType, string exceptionCode, string exceptionDescription, ErrorCategory category = ErrorCategory.Security, ErrorSeverity severity = ErrorSeverity.Error)
 {
     GenerateExceptionResponse(actionContext, responsePayloadType, new ResponseMessage
     {
         Code = exceptionCode,
         Description = exceptionDescription,
         Category = category,
         Severity = severity
     });
 }

 internal SessionStateException(string itemName, SessionStateCategory sessionStateCategory, 
                                string errorIdAndResourceId, ErrorCategory errorCategory,
                                params object[] messageArgs)
     : base(String.Format("The {0} \"{1}\" ({2}) caused the following error: {3}",
                          new object[] {sessionStateCategory.ToString(), itemName, errorIdAndResourceId, 
                                        errorCategory.ToString()}))
 {
     //TODO: make this better
     SessionStateCategory = sessionStateCategory;
     ErrorRecord = new ErrorRecord(this, errorIdAndResourceId, errorCategory, null);
 }

 /// <summary>
 /// Creates an instance of ErrorForm and show
 /// </summary>
 /// <param name="exception">exception as any</param>
 /// <param name="category">error category</param>
 /// <param name="currentLanguageID">current user language</param>
 public static void ShowError(Exception exception, ErrorCategory category, int currentLanguageID)
 {
     ErrorForm form = new ErrorForm(exception, category, currentLanguageID);
     if (null != MainForm.Singleton && MainForm.Singleton.Visible)
         form.ShowDialog(MainForm.Singleton);
     else
     {
         form.StartPosition = FormStartPosition.CenterScreen;
         form.ShowDialog();
     }
 }