Жизненный цикл HTTP-запросов в ASP.NET Core MVC

// Пример внедрения зависимостей в контроллер
public class OrderController : Controller
{
    private readonly IOrderService _orderService;
    
    public OrderController(IOrderService orderService)
    {
        _orderService = orderService;
    }
    
    public ActionResult Index()
    {
        var orders = _orderService.GetAllOrders();
        return View(orders);
    }
}

protected void Application_BeginRequest(object sender, EventArgs e)
{
    // Код обработки запроса на ранней стадии
}

protected void Application_BeginRequest(object sender, EventArgs e)
{
    var culture = new CultureInfo("en-US");
    Thread.CurrentThread.CurrentCulture = culture;
    Thread.CurrentThread.CurrentUICulture = culture;
}

protected void Application_BeginRequest(object sender, EventArgs e)
{
    HttpContext.Current.Response.AddHeader("Access-Control-Allow-Origin", "*");
    if (HttpContext.Current.Request.HttpMethod == "OPTIONS")
    {
        HttpContext.Current.Response.AddHeader("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE");
        HttpContext.Current.Response.AddHeader("Access-Control-Allow-Headers", "Content-Type, Accept");
        HttpContext.Current.Response.End();
    }
}

protected void Application_BeginRequest(object sender, EventArgs e)
{
    if (!Request.IsSecureConnection && !Request.Url.Host.Contains("localhost"))
    {
        string redirectUrl = Request.Url.ToString().Replace("http:", "https:");
        Response.Redirect(redirectUrl);
    }
}

public static void RegisterRoutes(RouteCollection routes)
{
    routes.IgnoreRoute("{resource}.axd/{*pathInfo}");
    
    routes.MapRoute(
        name: "Default",
        url: "{controller}/{action}/{id}",
        defaults: new { controller = "Home", action = "Index", id = UrlParameter.Optional }
    );
}

public class ProductController : Controller
{
    private readonly IProductRepository _repository;
    
    public ProductController(IProductRepository repository)
    {
        _repository = repository;
    }
    
    public ActionResult Details(int id)
    {
        var product = _repository.GetById(id);
        return View(product);
    }
}

// Привязка модели автоматически заполнит параметры из запроса
public ActionResult Edit(int id, ProductViewModel model)
{
    if (ModelState.IsValid)
    {
        // Обработка валидной модели
    }
    return View(model);
}

public class CustomHttpModule : IHttpModule
{
    public void Init(HttpApplication application)
    {
        application.BeginRequest += new EventHandler(OnBeginRequest);
        application.EndRequest += new EventHandler(OnEndRequest);
        // Другие обработчики событий
    }
 
    public void Dispose()
    {
        // Освобождение ресурсов
    }
 
    private void OnBeginRequest(object sender, EventArgs e)
    {
        HttpApplication app = (HttpApplication)sender;
        HttpContext context = app.Context;
        // Логика обработки
    }
 
    private void OnEndRequest(object sender, EventArgs e)
    {
        // Логика завершения
    }
}

[assembly: PreApplicationStartMethod(typeof(ModuleRegistration), "Register")]
 
public static class ModuleRegistration
{
    public static void Register()
    {
        DynamicModuleUtility.RegisterModule(typeof(CustomHttpModule));
    }
}

// Потенциально опасный код при параллельном выполнении
public static class CounterService
{
    private static int _requestCount = 0;
    
    public static int IncrementAndGetCount()
    {
        // Здесь возможно состояние гонки при параллельном доступе
        return ++_requestCount;
    }
}

public static class CounterService
{
    private static int _requestCount = 0;
    private static object _lockObject = new object();
    
    public static int IncrementAndGetCount()
    {
        lock(_lockObject)
        {
            return ++_requestCount;
        }
    }
}

protected void Application_BeginRequest(object sender, EventArgs e)
{
    if (Request.HttpMethod == "POST" && !Request.IsAjaxRequest())
    {
        string cookieToken = Request.Cookies["__RequestVerificationToken"]?.Value;
        string formToken = Request.Form["__RequestVerificationToken"];
        
        if (cookieToken == null || formToken == null || cookieToken != formToken)
        {
            Response.StatusCode = 400;
            Response.End();
        }
    }
}

[Authorize(Roles = "Admin")]
public class AdminController : Controller
{
    [AllowAnonymous]
    public ActionResult Login()
    {
        return View();
    }
    
    public ActionResult Dashboard()
    {
        return View();
    }
}

public ActionResult Edit([Bind(Include = "Name,Description,Price")] Product product)
{
    // Только указанные свойства могут быть изменены
}

protected void Application_EndRequest(object sender, EventArgs e)
{
    var response = HttpContext.Current.Response;
    response.Headers.Add("X-Content-Type-Options", "nosniff");
    response.Headers.Add("X-Frame-Options", "DENY");
    response.Headers.Add("Content-Security-Policy", "default-src 'self'");
}

public ActionResult Index()
{
    return View(); // Автоматически ищет представление "Index"
}

return View("Custom"); // Ищет Custom.cshtml
return View("~/CustomViews/Special.cshtml"); // Абсолютный путь

public ActionResult Details(int id)
{
    var product = repository.GetProduct(id);
    return View(product); // Передаем модель в представление
}

public ActionResult ProcessOrder(OrderViewModel model)
{
    // model автоматически заполняется данными из запроса
    if (ModelState.IsValid)
    {
        // Обработка заказа
    }
    return View(model);
}

public class ProductViewModel
{
    [Required]
    [StringLength(50)]
    public string Name { get; set; }
    
    [Range(0.01, 10000)]
    [DisplayFormat(DataFormatString = "{0:C}")]
    public decimal Price { get; set; }
    
    [DataType(DataType.MultilineText)]
    public string Description { get; set; }
}

public class OrderViewModel : IValidatableObject
{
    public DateTime DeliveryDate { get; set; }
    public bool ExpressDelivery { get; set; }
    
    public IEnumerable<ValidationResult> Validate(ValidationContext validationContext)
    {
        if (ExpressDelivery && DeliveryDate > DateTime.Now.AddDays(3))
        {
            yield return new ValidationResult(
                "Экспресс-доставка должна быть назначена в течение 3 дней", 
                new[] { nameof(DeliveryDate) }
            );
        }
    }
}

public class CustomDateModelBinder : IModelBinder
{
    public object BindModel(ControllerContext controllerContext, 
                           ModelBindingContext bindingContext)
    {
        var valueResult = bindingContext.ValueProvider
            .GetValue(bindingContext.ModelName);
        
        // Собственная логика преобразования
        return DateTime.Parse(valueResult.AttemptedValue);
    }
}

[OutputCache(Duration = 3600, VaryByParam = "id")]
public ActionResult Details(int id)
{
    // Этот результат будет кэшироваться на час
    return View(repository.GetProduct(id));
}

protected void Application_Start()
{
    ViewEngines.Engines.Clear();
    ViewEngines.Engines.Add(new RazorViewEngine());
}

public class CustomRazorViewEngine : RazorViewEngine
{
    public CustomRazorViewEngine()
    {
        ViewLocationFormats = new[] {
            "~/Features/{1}/{0}.cshtml",
            "~/Features/Shared/{0}.cshtml"
        };
        
        PartialViewLocationFormats = new[] {
            "~/Features/{1}/Partials/{0}.cshtml",
            "~/Features/Shared/Partials/{0}.cshtml"
        };
    }
}

public class DatabaseViewEngine : IViewEngine
{
    public ViewEngineResult FindView(ControllerContext controllerContext, string viewName, string masterName, bool useCache)
    {
        // Логика поиска представления в базе данных
    }
    
    public ViewEngineResult FindPartialView(ControllerContext controllerContext, string partialViewName, bool useCache)
    {
        // Логика поиска частичного представления
    }
    
    public void ReleaseView(ControllerContext controllerContext, IView view)
    {
        // Освобождение ресурсов
    }
}

public abstract class CustomViewPage<TModel> : WebViewPage<TModel>
{
    public override void InitHelpers()
    {
        base.InitHelpers();
        // Дополнительная инициализация
    }
    
    public override void Execute()
    {
        // Кастомная логика выполнения
        base.Execute();
    }
}

public class MvcApplication : System.Web.HttpApplication
{
    protected void Application_Start()
    {
        // Предварительная компиляция всех представлений при старте приложения
        var engine = ViewEngines.Engines.OfType<RazorViewEngine>().First();
        var viewLocationCache = new DefaultViewLocationCache();
        
        foreach (var virtualPath in GetAllViewPaths())
        {
            // Принудительная компиляция
            BuildManager.GetCompiledType(virtualPath);
        }
    }
}

public void ConfigureViewCaching(ViewDataDictionary viewData)
{
    var cacheSetting = new HttpCachePolicySettings
    {
        Duration = TimeSpan.FromMinutes(10),
        VaryByParams = new string[] { "id" },
        Location = HttpCacheabilityWhere.Client
    };
    
    ViewContext.HttpContext.Response.ApplyCachePolicy(cacheSetting);
}

/Views/Home/Index.cshtml
/Views/Home/Index.ru-RU.cshtml
/Views/Home/Index.de-DE.cshtml

public class LocalizedRazorViewEngine : RazorViewEngine
{
    public override ViewEngineResult FindView(ControllerContext controllerContext, string viewName, string masterName, bool useCache)
    {
        var culture = Thread.CurrentThread.CurrentUICulture.Name;
        
        // Сначала ищем локализованную версию
        var localizedViewName = string.Format("{0}.{1}", viewName, culture);
        var result = base.FindView(controllerContext, localizedViewName, masterName, useCache);
        
        // Если не найдено, используем версию по умолчанию
        if (result.View == null)
        {
            result = base.FindView(controllerContext, viewName, masterName, useCache);
        }
        
        return result;
    }
}

public static class CustomHtmlHelpers
{
  public static MvcHtmlString PriorityLabel(this HtmlHelper helper, int priority)
  {
      string cssClass = priority > 7 ? "high-priority" : 
                        priority > 3 ? "medium-priority" : "low-priority";
      
      TagBuilder tag = new TagBuilder("span");
      tag.AddCssClass(cssClass);
      tag.SetInnerText($"Приоритет: {priority}");
      
      return MvcHtmlString.Create(tag.ToString());
  }
}

public static MvcHtmlString UserStatusLabel<TModel>(
  this HtmlHelper<TModel> helper, 
  Expression<Func<TModel, UserStatus>> expression)
{
  var status = ExpressionHelper.GetPropertyValue(expression, helper.ViewData.Model);
  string cssClass = status == UserStatus.Active ? "status-active" : "status-inactive";
  
  TagBuilder tag = new TagBuilder("span");
  tag.AddCssClass(cssClass);
  tag.SetInnerText(status.ToString());
  
  return MvcHtmlString.Create(tag.ToString());
}

public static MvcHtmlString CategoryTree(this HtmlHelper helper, IEnumerable<Category> categories)
{
  var sb = new StringBuilder();
  sb.Append("<ul class='category-tree'>");
  
  foreach (var category in categories.Where(c => c.ParentId == null))
  {
      RenderCategoryNode(sb, category, categories, 0);
  }
  
  sb.Append("</ul>");
  return MvcHtmlString.Create(sb.ToString());
}
 
private static void RenderCategoryNode(StringBuilder sb, Category category, 
                                    IEnumerable<Category> allCategories, int level)
{
  sb.AppendFormat("<li class='level-{0}'>{1}", level, category.Name);
  
  var children = allCategories.Where(c => c.ParentId == category.Id).ToList();
  if (children.Any())
  {
      sb.Append("<ul>");
      foreach (var child in children)
      {
          RenderCategoryNode(sb, child, allCategories, level + 1);
      }
      sb.Append("</ul>");
  }
  
  sb.Append("</li>");
}

public class CustomHelperFactory
{
  private readonly IPermissionService _permissionService;
  
  public CustomHelperFactory(IPermissionService permissionService)
  {
      _permissionService = permissionService;
  }
  
  public SecurityHelper CreateSecurityHelper(HtmlHelper htmlHelper)
  {
      return new SecurityHelper(htmlHelper, _permissionService);
  }
}

[OutputCache(Duration = 60, VaryByParam = "id")]
public ActionResult ProductDetails(int id)
{
    var product = _repository.GetProduct(id);
    return View(product);
}

public ActionResult Index()
{
    Response.Cache.SetExpires(DateTime.Now.AddMinutes(10));
    Response.Cache.SetCacheability(HttpCacheability.Public);
    Response.Cache.SetValidUntilExpires(true);
    
    return View();
}

@Html.Action("TopProducts", "Product", new { count = 5 })
 
// В контроллере:
[ChildActionOnly]
[OutputCache(Duration = 300)]
public ActionResult TopProducts(int count)
{
    var products = _repository.GetTopSellingProducts(count);
    return PartialView(products);
}

[OutputCache(Duration = 3600, VaryByParam = "none")]
public ActionResult Dashboard()
{
    return View();
}
 
// В представлении:
@{Html.RenderAction("UserWelcome", "Account");}
 
// В контроллере:
[ChildActionOnly]
[OutputCache(Duration = 0)]  // Не кэшировать
public ActionResult UserWelcome()
{
    return PartialView(User.Identity.Name);
}

[OutputCache(CacheProfile = "StandardProfile")]
public ActionResult News()
{
    return View(_newsService.GetLatest());
}

public ActionResult UpdateProduct(ProductViewModel model)
{
    if (ModelState.IsValid)
    {
        _repository.UpdateProduct(model);
        // Инвалидация кэша
        Response.RemoveOutputCacheItem(Url.Action("Details", new { id = model.Id }));
        return RedirectToAction("Index");
    }
    return View(model);
}

@Html.Partial("_ProductSummary", Model.Product)

@Html.Action("RecentPosts", "Blog", new { count = 5 })

// В основном представлении:
@Html.Action("Comments", "Blog", new { postId = Model.Id })
 
// В контроллере:
[ChildActionOnly]
public ActionResult Comments(int postId)
{
    var comments = _commentService.GetForPost(postId);
    return PartialView(comments);
}

[ChildActionOnly]
[OutputCache(Duration = 60, VaryByParam = "none")]
public ActionResult SiteStatistics()
{
    // Тяжелые вычисления
    return PartialView(_statsService.GetStatistics());
}

public static void RegisterGlobalFilters(GlobalFilterCollection filters)
{
    filters.Add(new HandleErrorAttribute());
    filters.Add(new RequireHttpsAttribute());
    filters.Add(new AuthorizeAttribute());
}

public class LoggingFilterAttribute : ActionFilterAttribute
{
    public override void OnActionExecuting(ActionExecutingContext filterContext)
    {
        // Логирование перед выполнением действия
        Log($"Выполняется {filterContext.ActionDescriptor.ActionName}");
    }
 
    public override void OnActionExecuted(ActionExecutedContext filterContext)
    {
        // Логирование после выполнения действия
        Log($"Завершено {filterContext.ActionDescriptor.ActionName}");
    }
}

public class RequestTransformModule : IHttpModule
{
  public void Init(HttpApplication application)
  {
      application.BeginRequest += (sender, e) =>
      {
          var app = (HttpApplication)sender;
          var context = app.Context;
          
          // Модификация заголовков запроса
          if (context.Request.UserAgent.Contains("OldBrowser"))
          {
              context.Request.Browser = new HttpBrowserCapabilities();
              context.Request.Browser.Capabilities["browser"] = "Modern";
          }
      };
  }
  
  public void Dispose() { }
}

application.BeginRequest += (sender, e) =>
{
  var app = (HttpApplication)sender;
  var request = app.Request;
  
  // Определение культуры из URL, например /ru/controller/action
  var urlSegments = request.Path.Split('/');
  if (urlSegments.Length > 1 && urlSegments[1].Length == 2)
  {
      var culture = urlSegments[1];
      // Проверка валидности культуры и установка
      Thread.CurrentThread.CurrentCulture = new CultureInfo(culture);
      Thread.CurrentThread.CurrentUICulture = new CultureInfo(culture);
      
      // Модификация URL для дальнейшей обработки
      app.Context.RewritePath(request.Path.Substring(3));
  }
};

if (context.Request.Browser.IsMobileDevice)
{
  string originalUrl = context.Request.Url.ToString();
  string mobileUrl = originalUrl.Replace("www.", "m.");
  context.Response.Redirect(mobileUrl, true);
}

public class DynamicRoute : RouteBase
{
  public override RouteData GetRouteData(HttpContextBase httpContext)
  {
      // Базовая проверка применимости маршрута
      if (!httpContext.Request.Path.StartsWith("/api/dynamic"))
          return null;
      
      var routeData = new RouteData(this, new MvcRouteHandler());
      
      // Динамическое определение контроллера на основе заголовков или параметров
      string apiVersion = httpContext.Request.Headers["Api-Version"];
      routeData.Values["controller"] = apiVersion == "2.0" ? "ApiV2" : "ApiV1";
      routeData.Values["action"] = "ProcessRequest";
      
      return routeData;
  }
  
  public override VirtualPathData GetVirtualPath(RequestContext requestContext, RouteValueDictionary values)
  {
      return null; // Только входящая маршрутизация
  }
}

public class CustomRequestHandler : IHttpHandler
{
  public bool IsReusable => true;
  
  public void ProcessRequest(HttpContext context)
  {
      // Полная обработка запроса с нуля
      context.Response.ContentType = "application/json";
      context.Response.Write("{\"status\":\"processed\",\"custom\":true}");
  }
}

routes.MapRoute(
    name: "Product",
    url: "Products/{productId}/{action}",
    defaults: new { controller = "Products", action = "Details" }
);
 
// Более общий маршрут размещается ПОСЛЕ специфичного
routes.MapRoute(
    name: "Default",
    url: "{controller}/{action}/{id}",
    defaults: new { controller = "Home", action = "Index", id = UrlParameter.Optional }
);

public ActionResult Create(ProductViewModel model)
{
    if (!ModelState.IsValid)
    {
        // Для отладки можно просмотреть, какие поля вызвали проблемы
        foreach (var state in ModelState)
        {
            if (state.Value.Errors.Count > 0)
            {
                // Логирование проблемных полей
                Debug.WriteLine($"Ошибка в поле {state.Key}: {state.Value.Errors[0].ErrorMessage}");
            }
        }
        return View(model);
    }
    // ... продолжение обработки
}

public class CustomTimingFilterAttribute : ActionFilterAttribute
{
  private Stopwatch _stopwatch;
 
  public override void OnActionExecuting(ActionExecutingContext filterContext)
  {
      _stopwatch = Stopwatch.StartNew();
      
      // Можно изменить параметры, передаваемые в действие
      if (filterContext.ActionParameters.ContainsKey("id"))
      {
          var id = (int)filterContext.ActionParameters["id"];
          if (id <= 0)
          {
              filterContext.ActionParameters["id"] = 1;
          }
      }
  }
 
  public override void OnActionExecuted(ActionExecutedContext filterContext)
  {
      _stopwatch.Stop();
      
      // Добавим информацию о времени выполнения в ViewBag
      filterContext.Controller.ViewBag.ExecutionTime = _stopwatch.ElapsedMilliseconds;
      
      // Логирование в целях диагностики
      Debug.WriteLine($"Действие {filterContext.ActionDescriptor.ActionName} " +
                      $"выполнено за {_stopwatch.ElapsedMilliseconds} мс");
  }
}

public class AddHeaderFilterAttribute : ActionFilterAttribute
{
  public string HeaderName { get; set; }
  public string HeaderValue { get; set; }
 
  public override void OnResultExecuting(ResultExecutingContext filterContext)
  {
      // Добавляем заголовок в ответ
      filterContext.HttpContext.Response.Headers.Add(HeaderName, HeaderValue);
  }
}

[CustomTimingFilter]
[AddHeaderFilter(HeaderName = "X-Custom-Header", HeaderValue = "Custom Value")]
public ActionResult Details(int id)
{
  var product = _repository.GetProduct(id);
  return View(product);
}

public class CacheResourceAttribute : ActionFilterAttribute
{
  public int Duration { get; set; }
  private static readonly Dictionary<string, Tuple<DateTime, object>> _cache = 
      new Dictionary<string, Tuple<DateTime, object>>();
 
  public override void OnActionExecuting(ActionExecutingContext filterContext)
  {
      string key = GenerateCacheKey(filterContext);
      
      if (_cache.TryGetValue(key, out var cachedItem))
      {
          if (DateTime.UtcNow < cachedItem.Item1)
          {
              // Возвращаем кэшированный результат и прерываем конвейер
              filterContext.Result = cachedItem.Item2 as ActionResult;
          }
      }
  }
 
  public override void OnActionExecuted(ActionExecutedContext filterContext)
  {
      // Сохраняем результат в кэше
      if (filterContext.Result != null && Duration > 0)
      {
          string key = GenerateCacheKey(filterContext);
          var expiry = DateTime.UtcNow.AddSeconds(Duration);
          _cache[key] = new Tuple<DateTime, object>(expiry, filterContext.Result);
      }
  }
 
  private string GenerateCacheKey(ControllerContext context)
  {
      var descriptor = context.ActionDescriptor;
      return $"{descriptor.ControllerDescriptor.ControllerName}_{descriptor.ActionName}_{context.HttpContext.Request.QueryString}";
  }
}

public class RequestLoggerModule : IHttpModule
{
    private static readonly ILog _log = LogManager.GetLogger(typeof(RequestLoggerModule));
    
    public void Init(HttpApplication application)
    {
        application.BeginRequest += (sender, e) => {
            var app = (HttpApplication)sender;
            var context = app.Context;
            _log.InfoFormat("Запрос начат: {0} {1} от {2}",
                context.Request.HttpMethod,
                context.Request.RawUrl,
                context.Request.UserHostAddress);
            
            // Сохраняем метку времени для расчета длительности обработки
            context.Items["RequestStartTime"] = Stopwatch.StartNew();
        };
        
        application.EndRequest += (sender, e) => {
            var app = (HttpApplication)sender;
            var context = app.Context;
            var stopwatch = (Stopwatch)context.Items["RequestStartTime"];
            
            _log.InfoFormat("Запрос завершен: {0} {1}, статус {2}, длительность {3}ms",
                context.Request.HttpMethod,
                context.Request.RawUrl,
                context.Response.StatusCode,
                stopwatch.ElapsedMilliseconds);
        };
    }
    
    public void Dispose() { }
}

public class PerformanceMonitorAttribute : ActionFilterAttribute
{
    private Stopwatch _timer;
    private static readonly ILog _log = LogManager.GetLogger(typeof(PerformanceMonitorAttribute));
    
    public override void OnActionExecuting(ActionExecutingContext filterContext)
    {
        _timer = Stopwatch.StartNew();
        
        // Логируем параметры действия для диагностики
        var parameters = filterContext.ActionParameters
            .Select(p => $"{p.Key}={p.Value}")
            .Aggregate((current, next) => $"{current}, {next}");
        
        _log.DebugFormat("Выполняется {0}.{1}({2})",
            filterContext.ActionDescriptor.ControllerDescriptor.ControllerName,
            filterContext.ActionDescriptor.ActionName,
            parameters);
    }
    
    public override void OnActionExecuted(ActionExecutedContext filterContext)
    {
        _timer.Stop();
        
        if (filterContext.Exception != null)
        {
            _log.Error($"Исключение в {filterContext.ActionDescriptor.ControllerDescriptor.ControllerName}" +
                       $".{filterContext.ActionDescriptor.ActionName}: {filterContext.Exception.Message}",
                       filterContext.Exception);
        }
        
        if (_timer.ElapsedMilliseconds > 500) // Порог предупреждения
        {
            _log.WarnFormat("Медленное выполнение {0}.{1}: {2}ms",
                filterContext.ActionDescriptor.ControllerDescriptor.ControllerName,
                filterContext.ActionDescriptor.ActionName,
                _timer.ElapsedMilliseconds);
        }
    }
}

protected void Application_Error(object sender, EventArgs e)
{
    Exception exception = Server.GetLastError();
    
    if (exception is HttpException httpException && httpException.GetHttpCode() == 404)
    {
        Server.ClearError();
        Response.Redirect("~/Error/NotFound");
    }
    else
    {
        // Логирование критической ошибки
        Logger.Fatal("Необработанное исключение", exception);
        
        Server.ClearError();
        Response.Redirect("~/Error/ServerError");
    }
}

[HandleError(ExceptionType = typeof(DbException), View = "DatabaseError")]
public ActionResult Details(int id)
{
    var product = _repository.GetProduct(id);
    return View(product);
}

public class CustomExceptionFilterAttribute : HandleErrorAttribute
{
    public override void OnException(ExceptionContext filterContext)
    {
        if (filterContext.ExceptionHandled)
            return;
            
        // Обработка AJAX-запросов отдельно
        if (filterContext.HttpContext.Request.IsAjaxRequest())
        {
            filterContext.Result = new JsonResult
            {
                Data = new { success = false, message = filterContext.Exception.Message },
                JsonRequestBehavior = JsonRequestBehavior.AllowGet
            };
            filterContext.ExceptionHandled = true;
            return;
        }
        
        base.OnException(filterContext);
    }
}

public ActionResult ProcessPayment(OrderViewModel model)
{
    try
    {
        _paymentService.ProcessPayment(model.PaymentInfo);
        return RedirectToAction("Confirmation");
    }
    catch (PaymentDeclinedException ex)
    {
        ModelState.AddModelError("", ex.Message);
        return View(model);
    }
    catch (PaymentGatewayException)
    {
        // Произошла техническая ошибка, перенаправим на страницу с временными проблемами
        return RedirectToAction("TemporaryUnavailable", "Payment");
    }
}

public class ViewRenderExceptionFilterAttribute : FilterAttribute, IResultFilter
{
    public void OnResultExecuting(ResultExecutingContext filterContext) { }
    
    public void OnResultExecuted(ResultExecutedContext filterContext)
    {
        if (filterContext.Exception != null)
        {
            // Ошибка при рендеринге представления
            filterContext.ExceptionHandled = true;
            filterContext.HttpContext.Response.Clear();
            filterContext.HttpContext.Response.StatusCode = 500;
            filterContext.HttpContext.Response.Write("Произошла ошибка при отображении страницы");
        }
    }
}

public async Task<ActionResult> GetData()
{
    // Поток возвращается в пул на время выполнения запроса
    var data = await _repository.GetDataAsync();
    // После завершения запроса выполнение продолжается
    return View(data);
}

public async Task<ActionResult> Index()
{
    var products = await _dbContext.Products
        .Where(p => p.IsActive)
        .ToListAsync();
    return View(products);
}

// Оптимизация поиска маршрутов с помощью вспомогательного атрибута
[RoutePrefix("api/products")]
public class ProductApiController : ApiController
{
  [Route("{id:int}")]
  public Product GetProduct(int id) { ... }
}

private static readonly ObjectPool<StringBuilder> _builderPool = 
  new DefaultObjectPool<StringBuilder>(new StringBuilderPooledObjectPolicy());
 
public ActionResult GenerateReport()
{
  StringBuilder builder = _builderPool.Get();
  try
  {
      // Использование StringBuilder
      return Content(builder.ToString());
  }
  finally
  {
      // Возврат в пул
      _builderPool.Return(builder);
  }
}

// Указание конкретных полей снижает время привязки модели
[HttpPost]
public ActionResult Update([Bind(Include = "Id,Name,Price")] Product product)
{
  // ...
}

private static readonly ConcurrentDictionary<string, object> _computeCache = 
  new ConcurrentDictionary<string, object>();
 
public JsonResult GetStatistics(string region)
{
  var cacheKey = $"stats_{region}";
  var result = _computeCache.GetOrAdd(cacheKey, _ => 
  {
      // Сложные вычисления
      return calculatedValue;
  });
  
  return Json(result);
}

protected void Application_BeginRequest(object sender, EventArgs e)
{
    HttpContext.Current.Response.Headers.Add("Link", 
        "<~/scripts/main.js>; rel=preload; as=script, " +
        "<~/styles/main.css>; rel=preload; as=style");
}

protected void Application_Start()
{
    // Предварительная загрузка и кэширование справочных данных
    var cacheManager = DependencyResolver.Current.GetService<ICacheManager>();
    cacheManager.PreloadReferenceData();
    
    // Прогрев пула соединений к базе данных
    using (var db = new ApplicationDbContext())
    {
        db.Database.Initialize(force: false);
    }
}

private void PrecompileViews()
{
    var viewEngines = ViewEngines.Engines.OfType<RazorViewEngine>().FirstOrDefault();
    if (viewEngines != null)
    {
        foreach (var virtualPath in GetAllViewPaths())
        {
            // Принудительная компиляция представления
            BuildManager.GetCompiledType(virtualPath);
        }
    }
}

public ActionResult ProductDetails(int id)
{
    var product = _repository.GetProduct(id);
    
    // Предзагрузка связанных данных, которые могут понадобиться
    Task.Run(() => _cacheService.PreloadRelatedProducts(id));
    
    return View(product);
}

<sessionState mode="StateServer" 
              stateConnectionString="tcpip=sessionserver:42424" 
              cookieless="false" 
              timeout="20" />

<sessionState mode="SQLServer"
              sqlConnectionString="Data Source=dbserver;Initial Catalog=ASPState;..." 
              timeout="20" />