在Asp.Net MVC 5中处理会话和多个工作进程

Question

我有一个Asp.Net MVC 5 Web应用程序，该应用程序具有用于处理DB中的日志错误的错误处理机制，并以另一种形式（称为ErrorPage）向显示该错误的用户显示errorId。 当Web应用程序中发生错误时，我将该errorId存储在会话中，并从ErrorPage中的会话中读取该错误ID，以向遇到此错误的用户显示该errorId以便进行备份操作。 该Web应用程序的Web服务器当前仅通过一个工作进程处理请求，因此所有生成的会话在整个Web应用程序中都是有效且可访问的。

我打算将此Web应用程序的工作进程数从1增加到4，但是我的Web应用程序存在一些问题。 同样在IIS中，我将会话状态模式设置为“ 处理中”模式，因为在许多情况下，我在Web应用程序中使用会话，因此无法将其设置为SQL Server模式，因为这会增加性能开销。

问题是（例如）请求进入工作进程A，并且在工作进程A中将为此请求生成会话，并假定此请求在Web应用程序中遇到错误，我将用户重定向到ErrorPage，它是这个新请求（将用户重定向到ErrorController中的ErrorPage的操作）可能在另一个工作进程B中进行（例如）。 但是在工作进程B中，我无法访问为第一个请求生成的会话，因为该会话是在工作进程级别定义的，并且它们仅在该工作进程中有效。

因此，经过大量搜索之后，我决定将会话信息保存在DB中而不是Ram中，并在需要该信息时从DB中加载它。 但是我不知道要使用哪个密钥ID在数据库中保存此信息？

想象一下这种情况，可以更轻松地发现我的实际问题：

让我们：

WorkerProcessId1 = W1;
WorkerProcessId2 = W2;
SessionId1 = S1;
SessionId2 = S2;
RequestId1 = R1;
RequestId2 = R2;

和方案：

R1 comes to web server
==> web server passes R1 to W1
==> W1 generates S1 for R1
==> R1 faces an error
==> for the user who sends R1 (it is possible the user has not logged in yet so I don't know the userId), I will save the error in DB using the combination of S1 and userId in a specific pattern as a unique identifier in Error table in DB
==> the user will redirect to ErrorPage with another request R2
==> web server passes R2 to W2
==> W2 generates S2 for R2
==> after the redirect is done, in the ErrorPage I need the errorId of that error which I save it to DB, for showing it to the user for backup operations
==> I don't know which error belongs to this user and which error should be load from DB????

如果无法做到这一点，是否有任何方法可以在Web服务器的所有工作进程之间使用共享标识符？

编辑：

在此编辑中，我将说明我在ErrorHandling机制中的会话中使用的位置和方式。 在目标行的末尾有一个注释的短语，上面写着“这里我正在使用会话”：

namespace MyDomain.UI.Infrastructure.Attributes
{
    public class CustomHandleErrorAttribute : HandleErrorAttribute
    {
        public CustomHandleErrorAttribute()
        {

        }

        public override void OnException(ExceptionContext filterContext)
        {
            if (filterContext.ExceptionHandled || !filterContext.HttpContext.IsCustomErrorEnabled)
            {
                return;
            }

            if (!ExceptionType.IsInstanceOfType(filterContext.Exception))
            {
                return;
            }

            var errorid = 0;
            try
            {
                errorid = SaveErrorToDatabase(filterContext);
            }
            catch (Exception e)
            {
                //Console.WriteLine(e);
                //throw;
            }

            // if the request is AJAX return JSON else view.
            if (filterContext.HttpContext.Request.Headers["X-Requested-With"] == "XMLHttpRequest")
            {
                filterContext.Result = new JsonResult
                {
                    JsonRequestBehavior = JsonRequestBehavior.AllowGet,
                    Data = new
                    {
                        error = true,
                        message = "Error Message....",
                        errorid,
                    }
                };
            }
            else
            {
                var controllerName = (string)filterContext.RouteData.Values["controller"];
                var actionName = (string)filterContext.RouteData.Values["action"];
                var model = new HandleErrorInfo(filterContext.Exception, controllerName, actionName);

                filterContext.Controller.TempData.Clear();
                filterContext.Controller.TempData.Add("ErrorCode", errorid);//Here I am using session

                filterContext.Result = new ViewResult
                {
                    ViewName = View,
                    MasterName = Master,
                    ViewData = new ViewDataDictionary<HandleErrorInfo>(model),
                    TempData = filterContext.Controller.TempData
                };
            }

            filterContext.ExceptionHandled = true;
            filterContext.HttpContext.Response.Clear();
            filterContext.HttpContext.Response.StatusCode = 500;

            filterContext.HttpContext.Response.TrySkipIisCustomErrors = true;
        }

        private int SaveErrorToDatabase(ExceptionContext exception)
        {
            MyDomainDBContext dbContext = new MyDomainDBContext();

            var browserType = exception.HttpContext.Request.Browser.Capabilities["type"];

            var error = new Error
            {
                ErrorURL = exception.HttpContext.Request.Url.ToString(),
                ExceptionType = exception.Exception.GetType().Name,
                IsGlobalError = false,
                Message = exception.Exception.Message,
                StackTrace = exception.Exception.StackTrace,
                ThrownTime = DateTime.Now,
                UserIP = IPAddress.Parse(exception.HttpContext.Request.UserHostAddress).ToString(),
                BrowserName = browserType.ToString() + "," +
                GetUserPlatform(exception.HttpContext.Request)
            };

            AddRequestDetails(exception.Exception, exception.HttpContext.Request, error);

            if (exception.Exception.InnerException != null)
            {
                error.Message += "\n Inner Excpetion : \n " + exception.Exception.InnerException.Message;

                if (exception.Exception.InnerException.InnerException != null)
                {
                    error.Message += "\n \t Inner Excpetion : \n " + exception.Exception.InnerException.InnerException.Message;
                }
            }

            if (exception.HttpContext.User.Identity.IsAuthenticated)
            {
                error.UserID = exception.HttpContext.User.Identity.GetUserId<int>();
            }

            dbContext.Errors.Add(error);
            dbContext.SaveChanges();

            return error.ErrorID;
        }

        private void AddRequestDetails(Exception exception, HttpRequestBase request, Error err)
        {
            if (exception.GetType().Name == "HttpAntiForgeryException" && exception.Message == "The anti-forgery cookie token and form field token do not match.")
            {
                if (request.Form != null)
                {
                    if (request.Cookies["__RequestVerificationToken"] != null)
                    {

                        err.RequestDetails = "Form : " + request.Form["__RequestVerificationToken"] +
                                             " \n Cookie : " + request.Cookies["__RequestVerificationToken"].Value;

                    }
                    else
                    {
                        err.RequestDetails = "Does not have cookie for forgery";
                    }
                }
            }
        }

        private String GetUserPlatform(HttpRequestBase request)
        {
            var ua = request.UserAgent;

            if (ua.Contains("Android"))
                return $"Android";

            if (ua.Contains("iPad"))
                return $"iPad OS";

            if (ua.Contains("iPhone"))
                return $"iPhone OS";

            if (ua.Contains("Linux") && ua.Contains("KFAPWI"))
                return "Kindle Fire";

            if (ua.Contains("RIM Tablet") || (ua.Contains("BB") && ua.Contains("Mobile")))
                return "Black Berry";

            if (ua.Contains("Windows Phone"))
                return $"Windows Phone";

            if (ua.Contains("Mac OS"))
                return "Mac OS";

            if (ua.Contains("Windows NT 5.1") || ua.Contains("Windows NT 5.2"))
                return "Windows XP";

            if (ua.Contains("Windows NT 6.0"))
                return "Windows Vista";

            if (ua.Contains("Windows NT 6.1"))
                return "Windows 7";

            if (ua.Contains("Windows NT 6.2"))
                return "Windows 8";

            if (ua.Contains("Windows NT 6.3"))
                return "Windows 8.1";

            if (ua.Contains("Windows NT 10"))
                return "Windows 10";

            //fallback to basic platform:
            return request.Browser.Platform + (ua.Contains("Mobile") ? " Mobile " : "");
        }
    }

    public class IgnoreErrorPropertiesResolver : DefaultContractResolver
    {
        protected override JsonProperty CreateProperty(MemberInfo member, MemberSerialization memberSerialization)
        {
            JsonProperty property = base.CreateProperty(member, memberSerialization);

            if (new[]{
                "InputStream",
            "Filter",
            "Length",
            "Position",
            "ReadTimeout",
            "WriteTimeout",
            "LastActivityDate",
            "LastUpdatedDate",
            "Session"
            }.Contains(property.PropertyName))
            {
                property.Ignored = true;
            }
            return property;
        }
    }
}

如您所见，我填充了TempData ，它将存储在会话中，以便通过ErrorCode键将errorId传递给ErrorPage以便显示给用户。

Answer 1

我找到了一个临时解决方案，可通过创建一个新类（将其从HandleErrorInfo继承并具有以下结构）并在ErrorPage中使用此errorId来将errorId传递给ErrorPage：

public class HandleErrorInfoExtension : HandleErrorInfo
{
    public HandleErrorInfoExtension(Exception exception, string controllerName, string actionName, int errorId) : base(exception, controllerName, actionName)
    {
        ErrorId = errorId;
    }

    public int ErrorId { get; set; }
}

但是我不接受自己的回答，因为我仍然在寻找一种真正的解决方案来解决这个问题的主要问题，该问题是能够在应用程序的所有工作进程之间共享数据（或数据结构）。 您应该知道我在应用程序的其他地方使用了会话，这些地方中的一些至关重要（例如付款模块），因此我找不到删除会话使用的主要解决方案（除非使用DB数据存储，因为性能开销）。 因此，我请StackOverflow.com的开发人员社区帮助我解决此问题。

感谢所有亲爱的同事。