public override string Log(Error error)
		{
			if (error == null)
			{
				throw new ArgumentNullException(nameof(error));
			}

			var errorXml = ErrorXml.EncodeString(error);

			using (var scope = DataAccessScope.CreateReadCommitted())
			{
				var dbElmahError = dataModel.ElmahErrors.Create();

				dbElmahError.Application = ApplicationName;
				dbElmahError.Host = error.HostName;
				dbElmahError.Type = error.Type;
				dbElmahError.Source = error.Source;
				dbElmahError.Message = error.Message;
				dbElmahError.User = error.User;
				dbElmahError.StatusCode = error.StatusCode;
				dbElmahError.TimeUtc = error.Time;
				dbElmahError.AllXml = errorXml;

				scope.Complete();

				return dbElmahError.Id.ToString();
			}
		}

 protected override void Append(log4net.Core.LoggingEvent loggingEvent)
 {
     if (this._ErrorLog != null)
     {
         Error error;
         if (loggingEvent.ExceptionObject != null)
         {
             error = new Error(loggingEvent.ExceptionObject);
         }
         else
         {
             error = new Error();
         }
         error.Time = DateTime.Now;
         if (loggingEvent.MessageObject != null)
         {
             error.Message = loggingEvent.MessageObject.ToString();
         }
         error.Detail = base.RenderLoggingEvent(loggingEvent);
         error.HostName = this._HostName;
         error.User = loggingEvent.Identity;
         error.Type = "log4net - " + loggingEvent.Level; // maybe allow the type to be customized?
         this._ErrorLog.Log(error);
     }
 }

        public ErrorLoggingEventArgs(Error error)
        {
            if (error == null)
                throw new ArgumentNullException("error");

            _error = error;
        }

        /// <summary>
        /// Logs an error in log for the application.
        /// </summary>
        public override string Log(Error error)
        {
            if (error == null)
                throw new ArgumentNullException("error");

            string errorXml = ErrorXml.EncodeString(error);
            Guid id = Guid.NewGuid();

            using (MySqlConnection cn = new MySqlConnection(ConnectionString))
            {
                using (MySqlCommand cmd = new MySqlCommand("Elmah_LogError", cn))
                {
                    cmd.CommandType = CommandType.StoredProcedure;
                    cmd.Parameters.AddWithValue("@pErrorId", id.ToString());
                    cmd.Parameters.AddWithValue("@pApplication", ApplicationName);
                    cmd.Parameters.AddWithValue("@pHost", error.HostName);
                    cmd.Parameters.AddWithValue("@pType", error.Type);
                    cmd.Parameters.AddWithValue("@pSource", error.Source);
                    cmd.Parameters.AddWithValue("@pMessage", error.Message);
                    cmd.Parameters.AddWithValue("@pUser", error.User);
                    cmd.Parameters.AddWithValue("@pStatusCode", error.StatusCode);
                    cmd.Parameters.AddWithValue("@pTimeUtc", error.Time.ToUniversalTime());
                    cmd.Parameters.AddWithValue("@pAllXml", errorXml);

                    cn.Open();
                    cmd.ExecuteNonQuery();
                    return id.ToString();
                }
            }
        }

        /// <summary>
        /// Decodes an <see cref="Error"/> object from its XML representation.
        /// </summary>
        public static Error Decode(XmlReader reader)
        {
            if (reader == null) throw new ArgumentNullException("reader");
            if (!reader.IsStartElement()) throw new ArgumentException("Reader is not positioned at the start of an element.", "reader");

            //
            // Read out the attributes that contain the simple
            // typed state.
            //

            var error = new Error();
            ReadXmlAttributes(reader, error);

            //
            // Move past the element. If it's not empty, then
            // read also the inner XML that contains complex
            // types like collections.
            //

            var isEmpty = reader.IsEmptyElement;
            reader.Read();

            if (!isEmpty)
            {
                ReadInnerXml(reader, error);
                reader.ReadEndElement();
            }

            return error;
        }

            void ITableEntity.ReadEntity(IDictionary<string, EntityProperty> properties, Microsoft.WindowsAzure.Storage.OperationContext operationContext)
            {
                // This can occasionally fail because someone didn't finish creating the entity yet.

                EntityProperty value;
                if (properties.TryGetValue("SerializedError", out value))
                {
                    Error = ErrorXml.DecodeString(value.StringValue);
                }
                else
                {
                    Error = new Error
                    {
                        ApplicationName = "TableErrorLog",
                        StatusCode = 999,
                        HostName = Environment.MachineName,
                        Time = DateTime.UtcNow,
                        Type = typeof(Exception).FullName,
                        Detail = "Error Log Entry is Corrupted/Missing in Table Store"
                    };

                    return;
                }

                if (properties.TryGetValue("Detail", out value))
                {
                    Error.Detail = value.StringValue;
                }

                if (properties.TryGetValue("WebHostHtmlMessage", out value))
                {
                    Error.WebHostHtmlMessage = value.StringValue;
                }
            }

        /// <summary>
        /// Encodes the default JSON representation of an <see cref="Error"/> 
        /// object to a <see cref="TextWriter" />.
        /// </summary>
        /// <remarks>
        /// Only properties and collection entires with non-null
        /// and non-empty strings are emitted.
        /// </remarks>

        public static void Encode(Error error, TextWriter writer)
        {
            if (error == null) throw new ArgumentNullException("error");            
            if (writer == null) throw new ArgumentNullException("writer");

            EncodeEnclosed(error, new JsonTextWriter(writer));
        }

 protected virtual IActionResult InternalServerError(Error error)
 {
     if (error == null) throw new ArgumentNullException("error", "error is null");
     foreach (var message in error.Messages)
         Logger.LogError(message);
     return new ObjectResult(error) { StatusCode = 500 };
 }

        private static Error GenerateError(int maxErrorNestingLevel = 3, bool generateData = true, int currentNestingLevel = 0) {
            var error = new Error();
            error.Message = @"Generated exception message.";
            error.Type = TestConstants.ExceptionTypes.Random();
            if (RandomHelper.GetBool())
                error.Code = RandomHelper.GetRange(-234523453, 98690899).ToString();

            if (generateData) {
                for (int i = 0; i < RandomHelper.GetRange(1, 5); i++) {
                    string key = RandomHelper.GetPronouncableString(RandomHelper.GetRange(5, 15));
                    while (error.Data.ContainsKey(key) || key == Event.KnownDataKeys.Error)
                        key = RandomHelper.GetPronouncableString(RandomHelper.GetRange(5, 15));

                    error.Data.Add(key, RandomHelper.GetPronouncableString(RandomHelper.GetRange(5, 25)));
                }
            }

            var stack = new StackFrameCollection();
            for (int i = 0; i < RandomHelper.GetRange(1, 10); i++)
                stack.Add(GenerateStackFrame());
            error.StackTrace = stack;

            if (currentNestingLevel < maxErrorNestingLevel && RandomHelper.GetBool())
                error.Inner = GenerateError(maxErrorNestingLevel, generateData, currentNestingLevel + 1);

            return error;
        }

 /// <summary>
 /// Constructor
 /// </summary>
 /// <param name="status">The HTTP response status code</param>
 /// <param name="error">The Error object returned by the service</param>
 public KeyVaultClientException( HttpStatusCode status, Uri requestUri, Error error = null )
     : base( GetExceptionMessage( error ) )
 {
     Error      = error;
     RequestUri = requestUri;
     Status     = status;
 }

 /// <summary>
 /// Конструктор
 /// </summary>
 /// <param name="aConnectionString">строка соединения</param>
 public WorkDB(string aConnectionString)
 {
     mCn = new OleDbConnection(aConnectionString);
     mErr = new Error();
       mTxn = null;
       mIsInternalTransaction = false;
 }

        private static string GetExceptionMessage( Error error )
        {
            if ( error != null && !string.IsNullOrWhiteSpace( error.Message ) )
                return error.Message;

            return "Service Error information was not available";
        }

        /// <summary> 
        /// Constructor 
        /// </summary>
        public Error( Exception ex )
        {
            Message = ex.Message;

            if( ex.InnerException != null )
                InnerError = new Error( ex.InnerException );
        }

 public void Enqueue(Error error) {
     Manifest manifest = Manifest.FromError(error);
     manifest.LastAttempt = DateTime.MinValue;
     _data.Add(Tuple.Create(manifest, error));
     while (_data.Count > MaxItems)
         _data.RemoveAt(0);
 }

        public void RepublishError(Error error, QueueParameters parameters)
        {
            using (var connection = HosepipeConnection.FromParamters(parameters))
            using (var model = connection.CreateModel())
            {
                try
                {
                    if (error.Exchange != string.Empty)
                    {
                        model.ExchangeDeclarePassive(error.Exchange);
                    }

                    var properties = model.CreateBasicProperties();
                    error.BasicProperties.CopyTo(properties);

                    var body = Encoding.UTF8.GetBytes(error.Message);

                    model.BasicPublish(error.Exchange, error.RoutingKey, properties, body);
                }
                catch (OperationInterruptedException)
                {
                    Console.WriteLine("The exchange, '{0}', described in the error message does not exist on '{1}', '{2}'",
                        error.Exchange, parameters.HostName, parameters.VHost);
                }
            }
        }

        public void WriteException(Exception ex)
        {
            var uh = new Error(ex);
            uh.ApplicationId = this.CurrentApplication.Id;
            IUnhandledErrorRepository rep = RepositoryFactory.Instance.CreateInstance<IUnhandledErrorRepository>();
            uh = rep.Create(uh);

            var inner = ex.InnerException;

            while(inner != null)
            {
                var uhInner = new Error(inner);
                uhInner.ParentErrorId = uh.Id;
                uhInner.ApplicationId = this.CurrentApplication.Id;
                rep.Create(uhInner);
                inner = inner.InnerException;
            }

            var currentRequest = HttpContext.Current.Request;

            foreach (var cookieKey in currentRequest.Cookies.AllKeys)
            {
                Cookie sc = new Cookie(currentRequest.Cookies[cookieKey]);
                sc.ErrorId = uh.Id;
                IUnhandledCookieRepository crep = RepositoryFactory.Instance.CreateInstance<IUnhandledCookieRepository>();
                crep.Create(sc);
            }
        }

        private static Error GenerateError(int nestingLevel = 0, int minimiumNestingLevel = 0) {
            var error = new Error();
            error.Message = @"Generated exception message.";
            error.Type = TestConstants.ExceptionTypes.Random();
            if (RandomHelper.GetBool())
                error.Code = RandomHelper.GetRange(-234523453, 98690899).ToString();

            for (int i = 0; i < RandomHelper.GetRange(minimiumNestingLevel, minimiumNestingLevel + 5); i++) {
                string key = RandomHelper.GetPronouncableString(RandomHelper.GetRange(5, 15));
                while (error.Data.ContainsKey(key))
                    key = RandomHelper.GetPronouncableString(RandomHelper.GetRange(5, 15));

                error.Data.Add(key, RandomHelper.GetPronouncableString(RandomHelper.GetRange(5, 25)));
            }

            var stack = new StackFrameCollection();
            for (int i = 0; i < RandomHelper.GetRange(1, 10); i++)
                stack.Add(GenerateStackFrame());
            error.StackTrace = stack;

            if (minimiumNestingLevel > 0 || (nestingLevel < 5 && RandomHelper.GetBool()))
                error.Inner = GenerateError(nestingLevel + 1);

            return error;
        }

 public void Error(Exception exception)
 {
     var errorLog = new Error(exception);
     foreach (var logProvider in providers)
         logProvider.Log(errorLog);
     LastMessage = errorLog;
 }

 public IActionResult Clubs()
 {
     if (ModelState.IsValid)
     {
         ListModelResponse<Club> clubResponse = _context.GetUserClubs(_userManager.GetUserId(User));
         if (clubResponse.DidError == true || clubResponse == null)
         {
             if (clubResponse == null)
                 return View("Error");
             Error er = new Error(clubResponse.ErrorMessage);
             return View("Error", er);
         }
         if(clubResponse.Model!=null)
         {
             ViewBag.ClubsByTitle = clubResponse.Model.OrderBy(p => p.Name);
             ViewBag.ClubsByLocation = clubResponse.Model.OrderBy(p => p.Location);
         }
         string sourceCookie = HttpContext.Request.Cookies["SourcePageClub"];
         if (sourceCookie != null)
         {
             ViewBag.SourcePageClub = sourceCookie;
          }
         return View(clubResponse.Model);
     }
     else
     {
         return BadRequest();
     }
 }

		public static bool CheckSyntax(string expression, out Error[] errors)
		{
			var p = new CSharpParser();
			p.ParseExpression(expression);
			errors = p.Errors.ToArray();
			return !errors.Any();
		}