ASP.NET Web Forms

Introducing ASP.NET Web Forms Pageless Architecture (WPA)

Updated:

What Does “Pageless” Refers?

It means no *.aspx pages, except one blank Default.aspx, for the entry point.

Overview

ASP.NET Web Forms Pageless Architecture (WPA) is a design pattern that strips away traditional Web Forms conventions while preserving its powerful request-handling infrastructure. The result is a clean, modern architecture that delivers exceptional performance and maintainability.

The Core Philosophy:

  • Zero Server Controls
  • Zero PostBack
  • Zero ViewState
  • Full Route Control
  • Two-Level Caching (in-process memory + static file)
  • JSON Communication (C# API + Fetch API)

This architecture treats ASP.NET Web Forms as what it fundamentally is: a robust HTTP request processing engine. By removing the abstraction layers that were designed for RAD (Rapid Application Development), we expose a clean, intuitive foundation for building modern web applications.

Architecture Principles

Single Entry Point

The entire application flows through one file: Default.aspx. This single entry point receives all requests and dispatches them to appropriate handlers based on route resolution.

Caching Strategy

WPA implements a comprehensive caching system with multiple tiers:

Cache TypeStorageUse Case
In-ProcessConcurrentDictionaryHot data, fastest access
Static FilePre-rendered HTML filesCDN-ready, persistent
DatabasePre-computed contentPersistent, survives app restart

Cached Content Types:

  • Pre-rendered HTML (complete pages)
  • Pre-computed JSON (API responses)
  • Template fragments (reusable components)

Content Serving Patterns

Type 1: Full Rendered HTML

For content that changes infrequently, serve pre-rendered HTML directly from cache.

1.1 Full Static Page

Complete HTML pages pre-rendered and cached at multiple levels.

1.2 Semi-Dynamic Content

Static layout with dynamic content sections. Layout is cached; content fetched per request or from fast cache.

Type 2: Dynamic Content with Fetch API

For interactive pages requiring real-time data, serve a cached HTML shell and fetch content via API.

This pattern is ideal for:

  • CRUD operations
  • Admin interfaces
  • Real-time dashboards
  • Interactive forms

Implementation

Global Routing Configuration

First, configure Global.asax.cs to route all requests to the single entry point:

using System;
using System.Web.Routing;

namespace MyWebApp
{
    public class Global : System.Web.HttpApplication
    {
        protected void Application_Start(object sender, EventArgs e)
        {
            // Route everything to Default.aspx
            RouteTable.Routes.MapPageRoute("Root", "", "~/Default.aspx");
            RouteTable.Routes.MapPageRoute("CatchAll", "{*slug}", "~/Default.aspx");
        }
    }
}

The Entry Point: Default.aspx

The ASPX file is minimal—just a page directive:

<%@ Page Language="C#" AutoEventWireup="true" CodeBehind="Default.aspx.cs" Inherits="MyWebApp.Default" %>

The code-behind handles all routing logic:

using System;
using System.Web;

namespace MyWebApp
{
    public partial class Default : System.Web.UI.Page
    {
        protected void Page_Load(object sender, EventArgs e)
        {
            // Get the requested path
            string path = Request.RawUrl;

            // Remove query string for route matching
            int queryIndex = path.IndexOf('?');
            if (queryIndex >= 0)
                path = path.Substring(0, queryIndex);

            // Resolve route and dispatch
            var route = RouteResolver.Resolve(path, Request);

            switch (route.Type)
            {
                case RouteType.Public:
                    HandlePublic(route);
                    break;

                case RouteType.Admin:
                    HandleAdmin(route);
                    break;

                case RouteType.Api:
                    HandleApi(route);
                    break;

                case RouteType.Redirect:
                    Response.RedirectPermanent(route.RedirectTo);
                    break;

                case RouteType.NotFound:
                    Handle404();
                    break;
            }
        }

        private void HandlePublic(RouteResult route)
        {
            // Try cache first
            if (CacheStore.Pages.TryGetValue(route.CacheKey, out string html))
            {
                Response.ContentType = "text/html";
                Response.Write(html);
                return;
            }

            // Cache miss - use handler to build
            var handler = HandlerFactory.GetPublicHandler(route.Handler);
            handler?.ProcessRequest(Context, route);
        }

        private void HandleAdmin(RouteResult route)
        {
            // Admin authentication check
            if (Session["IsAdmin"] == null && route.Handler != "login")
            {
                Response.Redirect("/admin/login");
                return;
            }

            var handler = HandlerFactory.GetAdminHandler(route.Handler);
            handler?.ProcessRequest(Context, route);
        }

        private void HandleApi(RouteResult route)
        {
            var handler = HandlerFactory.GetApiHandler(route.Handler);
            handler?.ProcessRequest(Context, route);
        }

        private void Handle404()
        {
            Response.StatusCode = 404;
            Response.ContentType = "text/html";

            string html = PageBuilder.Build404Page();
            Response.Write(html);
        }
    }
}

Route Resolver

The route resolver supports multiple URL patterns:

using System;
using System.Collections.Generic;
using System.Text.RegularExpressions;
using System.Web;

namespace MyWebApp
{
    public enum RouteType
    {
        Public,
        Admin,
        Api,
        Redirect,
        NotFound
    }

    public class RouteResult
    {
        public RouteType Type { get; set; }
        public string Handler { get; set; }
        public string Action { get; set; }
        public Dictionary<string, string> Params { get; set; } = new Dictionary<string, string>();
        public string CacheKey { get; set; }
        public string RedirectTo { get; set; }
        public int ContentId { get; set; }
    }

    public static class RouteResolver
    {
        // Pre-defined admin routes
        private static readonly HashSet<string> AdminRoutes = new HashSet<string>(StringComparer.OrdinalIgnoreCase)
        {
            "dashboard", "articles", "articleedit", "gallery", "galleryedit",
            "media", "settings", "users", "login", "logout"
        };

        // Pre-defined API routes
        private static readonly HashSet<string> ApiRoutes = new HashSet<string>(StringComparer.OrdinalIgnoreCase)
        {
            "articles", "gallery", "media", "auth", "settings"
        };

        // Pre-defined special public routes
        private static readonly HashSet<string> SpecialRoutes = new HashSet<string>(StringComparer.OrdinalIgnoreCase)
        {
            "", "news", "events", "gallery", "contact"
        };

        public static RouteResult Resolve(string path, HttpRequest request)
        {
            // Normalize path
            path = (path ?? "").Trim('/').ToLower();

            // Remove default.aspx if present
            if (path == "default.aspx")
                path = "";

            // ═══════════════════════════════════════════════════════════
            // PHASE 1: URL Pattern Detection
            // ═══════════════════════════════════════════════════════════

            // Parse URL segments and parameters
            var urlInfo = ParseUrl(path, request);

            // ═══════════════════════════════════════════════════════════
            // PHASE 2: Route Type Identification
            // ═══════════════════════════════════════════════════════════

            // 2.1 Check API routes: /api/{handler}/{action}
            if (urlInfo.Segments.Length > 0 && urlInfo.Segments[0] == "api")
            {
                return ResolveApiRoute(urlInfo);
            }

            // 2.2 Check Admin routes: /admin/{handler}/{action}/{id}
            if (urlInfo.Segments.Length > 0 && urlInfo.Segments[0] == "admin")
            {
                return ResolveAdminRoute(urlInfo);
            }

            // 2.3 Check special public routes
            if (SpecialRoutes.Contains(urlInfo.PrimarySegment))
            {
                return new RouteResult
                {
                    Type = RouteType.Public,
                    Handler = string.IsNullOrEmpty(urlInfo.PrimarySegment) ? "homepage" : urlInfo.PrimarySegment,
                    CacheKey = $"page:{urlInfo.PrimarySegment ?? "home"}"
                };
            }

            // 2.4 Check user-defined content slugs (articles, pages)
            var slugResult = ResolveSlug(urlInfo.PrimarySegment);
            if (slugResult != null)
                return slugResult;

            // 2.5 Not found
            return new RouteResult { Type = RouteType.NotFound };
        }

        private static UrlInfo ParseUrl(string path, HttpRequest request)
        {
            var info = new UrlInfo
            {
                FullPath = path,
                Segments = path.Split(new[] { '/' }, StringSplitOptions.RemoveEmptyEntries),
                Params = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase)
            };

            info.PrimarySegment = info.Segments.Length > 0 ? info.Segments[0] : "";

            // ═══════════════════════════════════════════════════════════
            // Support Multiple Parameter Formats
            // ═══════════════════════════════════════════════════════════

            // Format 1: Query string - /ArticleEdit?id=5&action=save
            foreach (string key in request.QueryString.AllKeys)
            {
                if (!string.IsNullOrEmpty(key))
                    info.Params[key] = request.QueryString[key];
            }

            // Format 2: Form POST data
            if (request.HttpMethod == "POST")
            {
                foreach (string key in request.Form.AllKeys)
                {
                    if (!string.IsNullOrEmpty(key))
                        info.Params[key] = request.Form[key];
                }

                // Format 3: JSON body (check content type)
                if (request.ContentType?.Contains("application/json") == true)
                {
                    try
                    {
                        using (var reader = new System.IO.StreamReader(request.InputStream))
                        {
                            request.InputStream.Position = 0;
                            string json = reader.ReadToEnd();
                            var jsonParams = Newtonsoft.Json.JsonConvert.DeserializeObject<Dictionary<string, object>>(json);
                            if (jsonParams != null)
                            {
                                foreach (var kvp in jsonParams)
                                    info.Params[kvp.Key] = kvp.Value?.ToString() ?? "";
                            }
                        }
                    }
                    catch { }
                }
            }

            // Format 4: MVC-style URL segments - /ArticleEdit/Save/5
            // Extract action and id from URL if present
            if (info.Segments.Length >= 2)
                info.Params["_urlAction"] = info.Segments[1];
            if (info.Segments.Length >= 3)
                info.Params["_urlId"] = info.Segments[2];

            return info;
        }

        private static RouteResult ResolveApiRoute(UrlInfo info)
        {
            // /api/{handler}/{action}
            string handler = info.Segments.Length > 1 ? info.Segments[1] : "";
            string action = info.Params.ContainsKey("action") 
                ? info.Params["action"] 
                : (info.Segments.Length > 2 ? info.Segments[2] : "");

            if (!ApiRoutes.Contains(handler))
                return new RouteResult { Type = RouteType.NotFound };

            return new RouteResult
            {
                Type = RouteType.Api,
                Handler = handler,
                Action = action,
                Params = info.Params
            };
        }

        private static RouteResult ResolveAdminRoute(UrlInfo info)
        {
            // /admin/{handler}/{action}/{id}
            string handler = info.Segments.Length > 1 ? info.Segments[1] : "dashboard";
            string action = info.Params.ContainsKey("action")
                ? info.Params["action"]
                : (info.Segments.Length > 2 ? info.Segments[2] : "");

            if (!AdminRoutes.Contains(handler))
                return new RouteResult { Type = RouteType.NotFound };

            // Extract ID from URL or params
            string id = info.Params.ContainsKey("id")
                ? info.Params["id"]
                : (info.Segments.Length > 3 ? info.Segments[3] : "");

            var result = new RouteResult
            {
                Type = RouteType.Admin,
                Handler = handler,
                Action = action,
                Params = info.Params
            };

            if (int.TryParse(id, out int contentId))
                result.ContentId = contentId;

            return result;
        }

        private static RouteResult ResolveSlug(string slug)
        {
            if (string.IsNullOrEmpty(slug))
                return null;

            // Check slug cache/database
            var slugInfo = SlugStore.GetSlug(slug);
            if (slugInfo == null)
                return null;

            // Handle old slugs with redirect
            if (!slugInfo.IsActive)
            {
                return new RouteResult
                {
                    Type = RouteType.Redirect,
                    RedirectTo = "/" + slugInfo.CurrentSlug
                };
            }

            return new RouteResult
            {
                Type = RouteType.Public,
                Handler = slugInfo.ContentType,  // "article", "page", etc.
                ContentId = slugInfo.ContentId,
                CacheKey = $"{slugInfo.ContentType}:{slugInfo.ContentId}"
            };
        }
    }

    public class UrlInfo
    {
        public string FullPath { get; set; }
        public string[] Segments { get; set; }
        public string PrimarySegment { get; set; }
        public Dictionary<string, string> Params { get; set; }
    }
}

Cache Store

Thread-safe in-memory cache using ConcurrentDictionary:

using System;
using System.Collections.Concurrent;
using System.IO;

namespace MyWebApp
{
    public static class CacheStore
    {
        // In-process memory cache
        public static ConcurrentDictionary<string, string> Pages = new ConcurrentDictionary<string, string>();
        public static ConcurrentDictionary<string, SlugInfo> Slugs = new ConcurrentDictionary<string, SlugInfo>();

        private static string _cacheFolder;

        public static void Initialize(string cacheFolder)
        {
            _cacheFolder = cacheFolder;

            if (!Directory.Exists(_cacheFolder))
                Directory.CreateDirectory(_cacheFolder);
        }

        /// <summary>
        /// Get page from cache (memory first, then file)
        /// </summary>
        public static bool TryGetPage(string cacheKey, out string html)
        {
            // Level 1: In-process memory
            if (Pages.TryGetValue(cacheKey, out html))
                return true;

            // Level 2: Static file cache
            string filePath = GetCacheFilePath(cacheKey);
            if (File.Exists(filePath))
            {
                html = File.ReadAllText(filePath);
                // Promote to memory cache
                Pages.TryAdd(cacheKey, html);
                return true;
            }

            html = null;
            return false;
        }

        /// <summary>
        /// Store page in both cache levels
        /// </summary>
        public static void SetPage(string cacheKey, string html)
        {
            // Level 1: In-process memory
            Pages[cacheKey] = html;

            // Level 2: Static file cache
            string filePath = GetCacheFilePath(cacheKey);
            File.WriteAllText(filePath, html);
        }

        /// <summary>
        /// Invalidate cache entry from all levels
        /// </summary>
        public static void Invalidate(string cacheKey)
        {
            // Remove from memory
            Pages.TryRemove(cacheKey, out _);

            // Remove file
            string filePath = GetCacheFilePath(cacheKey);
            if (File.Exists(filePath))
                File.Delete(filePath);
        }

        private static string GetCacheFilePath(string cacheKey)
        {
            // Sanitize cache key for filename
            string filename = cacheKey.Replace(":", "_").Replace("/", "_") + ".html";
            return Path.Combine(_cacheFolder, filename);
        }
    }

    public class SlugInfo
    {
        public int ContentId { get; set; }
        public string ContentType { get; set; }
        public string Slug { get; set; }
        public string CurrentSlug { get; set; }
        public bool IsActive { get; set; }
    }
}

Handler Interface and Base Classes

using System.Web;

namespace MyWebApp
{
    public interface IHandler
    {
        void ProcessRequest(HttpContext context, RouteResult route);
    }

    public abstract class PublicHandlerBase : IHandler
    {
        protected HttpContext Context { get; private set; }
        protected HttpRequest Request => Context.Request;
        protected HttpResponse Response => Context.Response;
        protected RouteResult Route { get; private set; }

        public void ProcessRequest(HttpContext context, RouteResult route)
        {
            Context = context;
            Route = route;

            // Build and serve page
            string html = BuildPage();

            // Cache the result
            if (!string.IsNullOrEmpty(route.CacheKey))
                CacheStore.SetPage(route.CacheKey, html);

            // Output
            Response.ContentType = "text/html";
            Response.Write(html);
        }

        protected abstract string BuildPage();

        protected string LoadTemplate(string name)
        {
            string path = Context.Server.MapPath($"~/App_Data/templates/{name}.html");
            return System.IO.File.ReadAllText(path);
        }
    }

    public abstract class AdminHandlerBase : IHandler
    {
        protected HttpContext Context { get; private set; }
        protected HttpRequest Request => Context.Request;
        protected HttpResponse Response => Context.Response;
        protected RouteResult Route { get; private set; }

        public void ProcessRequest(HttpContext context, RouteResult route)
        {
            Context = context;
            Route = route;

            // Build admin page (typically not cached, or short-lived cache)
            string html = BuildPage();

            Response.ContentType = "text/html";
            Response.Write(html);
        }

        protected abstract string BuildPage();

        protected string LoadTemplate(string name)
        {
            string path = Context.Server.MapPath($"~/App_Data/admin/{name}.html");
            return System.IO.File.ReadAllText(path);
        }

        protected string WrapInLayout(string content, string pageTitle)
        {
            string layout = LoadTemplate("_layout");
            layout = layout.Replace("{{page_title}}", HttpUtility.HtmlEncode(pageTitle));
            layout = layout.Replace("{{content}}", content);
            return layout;
        }
    }

    public abstract class ApiHandlerBase : IHandler
    {
        protected HttpContext Context { get; private set; }
        protected HttpRequest Request => Context.Request;
        protected HttpResponse Response => Context.Response;
        protected RouteResult Route { get; private set; }

        public void ProcessRequest(HttpContext context, RouteResult route)
        {
            Context = context;
            Route = route;

            Response.ContentType = "application/json";

            try
            {
                // Dispatch to action method
                string action = GetAction();
                HandleAction(action);
            }
            catch (Exception ex)
            {
                WriteError(ex.Message, 500);
            }

            EndResponse();
        }

        protected abstract void HandleAction(string action);

        protected string GetAction()
        {
            // Priority: query string > form > URL segment
            return Request["action"] 
                ?? Route.Params.GetValueOrDefault("_urlAction", "")
                ?? Route.Action 
                ?? "";
        }

        protected int GetId()
        {
            string idStr = Request["id"] 
                ?? Route.Params.GetValueOrDefault("_urlId", "")
                ?? Route.ContentId.ToString();

            int.TryParse(idStr, out int id);
            return id;
        }

        protected string GetParam(string key)
        {
            return Request[key] ?? Route.Params.GetValueOrDefault(key, "");
        }

        protected void WriteJson(object obj)
        {
            string json = Newtonsoft.Json.JsonConvert.SerializeObject(obj);
            Response.Write(json);
        }

        protected void WriteSuccess(string message = "Success")
        {
            WriteJson(new { success = true, message });
        }

        protected void WriteSuccess(object data, string message = "Success")
        {
            WriteJson(new { success = true, message, data });
        }

        protected void WriteError(string message, int statusCode = 400)
        {
            Response.StatusCode = statusCode;
            WriteJson(new { success = false, message });
        }

        protected void EndResponse()
        {
            Response.Flush();
            Response.SuppressContent = true;
            HttpContext.Current.ApplicationInstance.CompleteRequest();
        }
    }
}

Example: API Handler Implementation

A complete example of an Articles API handler:

using System;
using System.Collections.Generic;
using System.Web;

namespace MyWebApp.Handlers.Api
{
    public class ArticlesApiHandler : ApiHandlerBase
    {
        protected override void HandleAction(string action)
        {
            switch (action.ToLower())
            {
                case "list":
                case "get_list":
                    GetList();
                    break;

                case "get":
                case "get_item":
                    GetItem();
                    break;

                case "save":
                    Save();
                    break;

                case "delete":
                    Delete();
                    break;

                default:
                    WriteError($"Unknown action: {action}", 400);
                    break;
            }
        }

        private void GetList()
        {
            int page = int.TryParse(GetParam("page"), out int p) ? p : 1;
            int pageSize = 20;

            var articles = Database.QueryList<Article>(
                @"SELECT id, title, slug, status, created_at, updated_at 
                  FROM articles 
                  ORDER BY updated_at DESC 
                  LIMIT @offset, @limit",
                new { offset = (page - 1) * pageSize, limit = pageSize }
            );

            int total = Database.ExecuteScalar<int>("SELECT COUNT(*) FROM articles");

            WriteJson(new { 
                success = true, 
                items = articles,
                total,
                page,
                pageSize
            });
        }

        private void GetItem()
        {
            int id = GetId();
            if (id <= 0)
            {
                WriteError("Invalid ID", 400);
                return;
            }

            var article = Database.QuerySingle<Article>(
                "SELECT * FROM articles WHERE id = @id",
                new { id }
            );

            if (article == null)
            {
                WriteError("Article not found", 404);
                return;
            }

            WriteSuccess(article);
        }

        private void Save()
        {
            int id = GetId();
            string title = GetParam("title");
            string slug = GetParam("slug");
            string content = GetParam("content");
            string status = GetParam("status");

            // Validation
            if (string.IsNullOrWhiteSpace(title))
            {
                WriteError("Title is required");
                return;
            }

            // Generate slug if empty
            if (string.IsNullOrWhiteSpace(slug))
                slug = SlugHelper.Generate(title);

            DateTime now = DateTime.Now;

            if (id > 0)
            {
                // Update existing
                Database.Execute(
                    @"UPDATE articles 
                      SET title = @title, slug = @slug, content = @content, 
                          status = @status, updated_at = @now 
                      WHERE id = @id",
                    new { id, title, slug, content, status, now }
                );
            }
            else
            {
                // Insert new
                id = Database.InsertAndGetId(
                    @"INSERT INTO articles (title, slug, content, status, created_at, updated_at)
                      VALUES (@title, @slug, @content, @status, @now, @now)",
                    new { title, slug, content, status, now }
                );
            }

            // Invalidate cache
            CacheStore.Invalidate($"article:{id}");
            CacheStore.Invalidate($"page:news");  // Invalidate listing page too

            WriteJson(new { success = true, id, message = "Saved successfully" });
        }

        private void Delete()
        {
            int id = GetId();
            if (id <= 0)
            {
                WriteError("Invalid ID", 400);
                return;
            }

            Database.Execute("DELETE FROM articles WHERE id = @id", new { id });

            // Invalidate cache
            CacheStore.Invalidate($"article:{id}");
            CacheStore.Invalidate($"page:news");

            WriteSuccess("Deleted successfully");
        }
    }
}

Example: Public Page Handler with Caching

using System.Text;

namespace MyWebApp.Handlers.Public
{
    public class ArticleHandler : PublicHandlerBase
    {
        protected override string BuildPage()
        {
            // Load article from database
            var article = Database.QuerySingle<Article>(
                "SELECT * FROM articles WHERE id = @id AND status = 'published'",
                new { id = Route.ContentId }
            );

            if (article == null)
                return Build404();

            // Load templates
            string layout = LoadTemplate("layout");
            string articleTemplate = LoadTemplate("article");

            // Build article content
            articleTemplate = articleTemplate
                .Replace("{{title}}", HttpUtility.HtmlEncode(article.Title))
                .Replace("{{content}}", article.Content)
                .Replace("{{date}}", article.CreatedAt.ToString("MMMM dd, yyyy"))
                .Replace("{{author}}", HttpUtility.HtmlEncode(article.Author));

            // Assemble into layout
            string html = layout
                .Replace("{{page_title}}", HttpUtility.HtmlEncode(article.Title))
                .Replace("{{meta_description}}", HttpUtility.HtmlEncode(article.Excerpt))
                .Replace("{{content}}", articleTemplate);

            return html;
        }

        private string Build404()
        {
            Response.StatusCode = 404;
            return LoadTemplate("404");
        }
    }
}

Frontend: Fetch API Integration

The admin interface uses JavaScript Fetch API to communicate with backend APIs:

<!-- Admin Article Editor Template -->
<!DOCTYPE html>
<html>
<head>
    <title>Edit Article</title>
</head>
<body>
    <div class="editor">
        <input type="hidden" id="articleId" value="{{id}}">

        <div class="form-group">
            <label>Title</label>
            <input type="text" id="txtTitle" value="{{title}}">
        </div>

        <div class="form-group">
            <label>Slug</label>
            <input type="text" id="txtSlug" value="{{slug}}">
        </div>

        <div class="form-group">
            <label>Content</label>
            <textarea id="txtContent">{{content}}</textarea>
        </div>

        <div class="form-group">
            <label>Status</label>
            <select id="selStatus">
                <option value="draft">Draft</option>
                <option value="published">Published</option>
            </select>
        </div>

        <div class="actions">
            <button type="button" onclick="saveArticle()">Save</button>
            <button type="button" onclick="deleteArticle()">Delete</button>
        </div>
    </div>

    <script>
        const API_URL = '/api/articles';

        async function saveArticle() {
            const id = document.getElementById('articleId').value;
            const title = document.getElementById('txtTitle').value;
            const slug = document.getElementById('txtSlug').value;
            const content = document.getElementById('txtContent').value;
            const status = document.getElementById('selStatus').value;

            // Validation
            if (!title.trim()) {
                alert('Title is required');
                return;
            }

            // Build request
            const params = new URLSearchParams();
            params.append('action', 'save');
            params.append('id', id);
            params.append('title', title);
            params.append('slug', slug);
            params.append('content', content);
            params.append('status', status);

            try {
                const response = await fetch(API_URL, {
                    method: 'POST',
                    headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
                    body: params.toString()
                });

                const data = await response.json();

                if (data.success) {
                    alert('Saved successfully!');
                    // Update ID if new article
                    if (!id && data.id) {
                        document.getElementById('articleId').value = data.id;
                    }
                } else {
                    alert('Error: ' + data.message);
                }
            } catch (err) {
                alert('Request failed: ' + err.message);
            }
        }

        async function deleteArticle() {
            const id = document.getElementById('articleId').value;

            if (!id) {
                alert('No article to delete');
                return;
            }

            if (!confirm('Are you sure you want to delete this article?')) {
                return;
            }

            try {
                const response = await fetch(`${API_URL}?action=delete&id=${id}`, {
                    method: 'POST'
                });

                const data = await response.json();

                if (data.success) {
                    alert('Deleted successfully!');
                    window.location.href = '/admin/articles';
                } else {
                    alert('Error: ' + data.message);
                }
            } catch (err) {
                alert('Request failed: ' + err.message);
            }
        }

        // Load article data on page load
        async function loadArticle() {
            const id = document.getElementById('articleId').value;
            if (!id) return;

            try {
                const response = await fetch(`${API_URL}?action=get&id=${id}`);
                const data = await response.json();

                if (data.success) {
                    document.getElementById('txtTitle').value = data.data.title;
                    document.getElementById('txtSlug').value = data.data.slug;
                    document.getElementById('txtContent').value = data.data.content;
                    document.getElementById('selStatus').value = data.data.status;
                }
            } catch (err) {
                console.error('Failed to load article:', err);
            }
        }

        // Initialize
        document.addEventListener('DOMContentLoaded', loadArticle);
    </script>
</body>
</html>

URL Pattern Support

WPA supports multiple URL patterns simultaneously:

Pattern 1: Query String

/api/articles?action=save&id=5
/admin/articleedit?id=5

Pattern 2: MVC-Style Segments

/api/articles/save/5
/admin/articleedit/edit/5

Pattern 3: Clean Slugs

/introduction-to-aspnet-webforms
/about-us
/contact

Pattern 4: JSON Body (POST)

fetch('/api/articles', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({
        action: 'save',
        id: 5,
        title: 'My Article',
        content: '...'
    })
});

All patterns are resolved by the same RouteResolver and can be used interchangeably.

Project Structure

MyWebApp/
Default.aspx ← Single entry point
Default.aspx.cs ← Route dispatcher
Global.asax
Global.asax.cs ← Route configuration
Web.config
Core/ ← Framework core
RouteResolver.cs ← URL parsing
CacheStore.cs ← Two-level cache
HandlerFactory.cs
Database.cs
SlugStore.cs
Handlers/ ← Request handlers
IHandler.cs
PublicHandlerBase.cs
AdminHandlerBase.cs
ApiHandlerBase.cs
Public/
HomepageHandler.cs
ArticleHandler.cs
GalleryHandler.cs
Admin/
DashboardHandler.cs
ArticlesHandler.cs
MediaHandler.cs
Api/
ArticlesApiHandler.cs
MediaApiHandler.cs
AuthApiHandler.cs
App_Data/
templates/ ← Public HTML
layout.html
article.html
404.html
admin/ ← Admin HTML
_layout.html
dashboard.html
articles.html
cache/ ← Static file cache
*.html
assets/ ← Static files
css/
js/

Benefits

  1. Performance: Two-level caching delivers sub-millisecond response times for cached content.
  2. Simplicity: No ViewState parsing, no control tree building, no PostBack processing. Just request in, response out.
  3. Flexibility: Support multiple URL patterns, request formats, and content types without framework constraints.
  4. Maintainability: Clear separation between routing, handling, and rendering. Each handler is self-contained.
  5. Scalability: Static file cache enables CDN distribution. In-memory cache handles high concurrency.
  6. SEO-Friendly: Server-rendered HTML, clean URLs, proper HTTP status codes.
  7. Modern Development: JSON APIs enable rich client-side interactions while maintaining server-side rendering for initial page loads.

Conclusion

ASP.NET Web Forms Pageless Architecture demonstrates that modern web development patterns can be implemented on the Web Forms platform without the overhead of server controls, ViewState, or PostBack. By treating Web Forms as a pure HTTP request processor, we gain the simplicity and performance benefits of modern frameworks while leveraging battle-tested infrastructure.

The architecture is particularly well-suited for:

  • Content-heavy websites with caching requirements
  • Applications requiring clean URL structures
  • Projects where developer control over HTML output is essential
  • Teams seeking a simpler alternative to MVC complexity

WPA proves that ASP.NET Web Forms, when stripped to its essential core, provides an elegant and powerful foundation for building modern web applications.

This article introduces the conceptual framework and proof of concept for ASP.NET Web Forms Pageless Architecture. The code examples demonstrate the core patterns and can be extended based on specific project requirements.

Feature Photo by Khara Woods on Unsplash

Github | Youtube | X.com | Facebook

© adriancs.com. All Rights Reserved.