Hubbry Logo
ASP.NETASP.NETMain
Open search
ASP.NET
Community hub
ASP.NET
logo
7 pages, 0 posts
0 subscribers
Be the first to start a discussion here.
Be the first to start a discussion here.
ASP.NET
ASP.NET
ASP.NET
View on Wikipedia
from Wikipedia
ASP.NET (software)
DevelopersMicrosoft, Scott Guthrie
Initial releaseJanuary 5, 2002; 23 years ago (2002-01-05)
Stable release
4.8.1 / August 9, 2022; 3 years ago (2022-08-09)[1]
Repository
Written in.NET languages
Operating systemMicrosoft Windows, Linux, macOS
Platform.NET Framework
TypeWeb framework
LicenseProprietary software[2]
Websitedotnet.microsoft.com/en-us/apps/aspnet Edit this on Wikidata
ASP.NET (file format)
Filename extension.aspx, .asmx, .aspc,[3] .cshtml, .vbhtml
Internet media type
text/html
Developed byMicrosoft

ASP.NET is a server-side web-application framework designed for web development to produce dynamic web pages. It was developed by Microsoft to allow programmers to build dynamic web sites, applications and services. The name stands for Active Server Pages Network Enabled Technologies.[citation needed]

ASP.NET was first announced to the public under the codename ASP+, and is a re-implementation of Microsoft's Active Server Pages (ASP) technology.[3] ASP.NET is built on the Common Language Runtime (CLR), allowing programmers to write ASP.NET code using any supported .NET language.[4] The ASP.NET SOAP extension framework allows ASP.NET components to process SOAP messages.

In 2016, Microsoft released ASP.NET Core as ASP.NET's successor. This new version is a re-implementation of ASP.NET as a modular web framework, together with other frameworks like Entity Framework. The new framework uses the new open-source .NET Compiler Platform (codename "Roslyn") and is cross platform. ASP.NET MVC, ASP.NET Web API, and ASP.NET Web Pages (a platform using only Razor pages) have merged into a unified MVC (model–view–controller) 6.[5]

Programming models

[edit]
See also: ASP.NET Web Forms

ASP.NET supports a number of programming models for building web applications:[6]

  • ASP.NET Web Forms – A framework for building modular pages out of components, with UI events being processed server-side. This framework is not included in the ASP.NET Core versions; it only works in the "classic" ASP.NET, on Windows.
  • ASP.NET MVC – allows building web pages using the model–view–controller design pattern.
  • ASP.NET Web Pages – A lightweight syntax for adding dynamic code and data access directly inside HTML markup.[7]
  • ASP.NET Web API – A framework for building Web APIs on top of the .NET Framework.[8]
  • ASP.NET WebHooks – Implements the Webhook pattern for subscribing to and publishing events via HTTP.
  • SignalR – A real-time communications framework for bi-directional communication between client and server.

Other ASP.NET extensions include:

  • ASP.NET Handler – Components that implement the System.Web.IHttpHandler interface. Unlike ASP.NET Pages, they have no HTML-markup file, no events and other supporting. All they have is a code-file (written in any .NET-compatible language) that writes some data to the server HTTP response. HTTP handlers are similar to ISAPI extensions.
  • ASP.NET AJAX – An extension with both client-side as well as server-side components for writing ASP.NET pages that incorporate Ajax functionality.
  • ASP.NET Dynamic Data – A scaffolding extension to build data driven web applications.

IIS integrated pipeline

[edit]

On IIS 6.0 and lower, pages written using different versions of the ASP framework cannot share session state without the use of third-party libraries. This does not apply to ASP.NET and ASP applications running side by side on IIS 7. With IIS 7.0, modules may be run in an integrated pipeline that allows modules written in any language to be executed for any request.[9]

Third-party frameworks

[edit]

It is not essential to use the standard Web forms development model when developing with ASP.NET. Noteworthy frameworks designed for the platform include:

Versions

[edit]

ASP.NET's release history tightly correlates with the .NET Framework releases:

Date Version Remarks New ASP.NET related features
January 16, 2002 Unsupported: 1.0 First version

released together with Visual Studio .NET

  • Object-oriented Web application development supporting inheritance, polymorphism and other standard OOP features
    • Developers are no longer forced to use Server.CreateObject(...), so early-binding and type safety are possible.
  • Based on Windows programming; the developer can make use of DLL class libraries and other features of the Web server to build more robust applications that do more than simply rendering HTML (e.g., exception handling)
April 24, 2003 Unsupported: 1.1 released together with Windows Server 2003

released together with Visual Studio .NET 2003

  • Mobile controls
  • Automatic input validation
November 7, 2005 Unsupported: 2.0

codename Whidbey
released together with Visual Studio 2005 and Visual Web Developer Express
and SQL Server 2005

  • New data controls (GridView, FormView, DetailsView)
  • New technique for declarative data access (SqlDataSource, ObjectDataSource, XmlDataSource controls)
  • Navigation controls
  • Master pages
  • Login controls
  • Themes
  • Skins
  • Web parts
  • Personalization services
  • Full pre-compilation
  • New localization technique
  • Support for 64-bit processors
  • Provider class model
November 21, 2006 Unsupported: 3.0 Released with Windows Vista
November 19, 2007 Unsupported: 3.5 Released with Visual Studio 2008 and Windows Server 2008
  • New data controls (ListView, DataPager)
  • ASP.NET AJAX included as part of the framework
  • Support for HTTP pipelining and syndication feeds.
  • WCF support for RSS, JSON, POX and Partial Trust
  • All the .NET Framework 3.5 changes, like LINQ etc.
August 11, 2008 Unsupported: 3.5 Service Pack 1 Released with Visual Studio 2008 Service Pack 1
  • Incorporation of ASP.NET Dynamic Data
  • Support for controlling browser history in an ASP.NET AJAX application
  • Ability to combine multiple JavaScript files into one file for more efficient downloading
  • New namespaces System.Web.Abstractions and System.Web.Routing
April 12, 2010 Unsupported: 4.0 Released with Visual Studio 2010

Parallel extensions and other .NET Framework 4 features

The two new properties added in the Page class are MetaKeyword and MetaDescription.

August 15, 2012 Unsupported: 4.5 Released with Visual Studio 2012 and Windows Server 2012 for Windows 8

Parallel extensions and other .NET Framework 4.5 features

October 17, 2013 Unsupported: 4.5.1 Released with Visual Studio 2013[10] for Windows Server 2012 R2 and Windows 8.1
May 5, 2014[11] Supported: 4.5.2
  • Higher reliability HTTP header inspection and modification methods
  • New way to schedule background asynchronous worker tasks
July 20, 2015[11] Supported: 4.6 Released[12] with Visual Studio 2015[13] and EF 7 Previews for Windows Server 2016 and Windows 10
  • HTTP/2 support when running on Windows 10
  • More async task-returning APIs
November 30, 2015[11] Supported: 4.6.1
August 2, 2016[11] Supported: 4.6.2
  • Improved async support (output-cache and session providers)
April 11, 2017[11] Supported: 4.7 Included in the Windows 10 Creators Update[14]
  • operating system support for TLS protocols
October 17, 2017[11] Supported: 4.7.1 Included in the Windows 10 Fall Creators Update.[15]
  • Improved accessibility
  • Value tuple types serialization
  • SHA-2 support
April 30, 2018[11] Supported: 4.7.2
August 09, 2022[11] Latest version: 4.8.1 Released[16]
  • JIT and NGEN Improvements
  • Updated ZLib
  • Reducing FIPS Impact on Cryptography
  • Accessibility Enhancements for WinForms
  • Service Behavior Enhancements for WCF
  • High DPI Enhancements, UIAutomation Improvements for WPF
November 18, 2015 Unsupported: 5 RC1 This version was later separated from ASP.NET and brought into a new project called ASP.NET Core, whose versioning started at 1.0.[17] An entirely new project with different development tenets and goals
Legend:
Unsupported
Supported
Latest version
Preview version
Future version

Other implementations

[edit]

The Mono Project supports "everything in .NET 4.7 except WPF, WWF, and with limited WCF and limited ASP.NET async stack."[18] ASP.NET can be run with Mono using one of three options: Apache hosting using the mod_mono module, FastCGI hosting, and XSP.

References

[edit]
[edit]
Revisions and contributorsEdit on WikipediaRead on Wikipedia

ASP.NET

View on Grokipedia
from Grokipedia
ASP.NET is a developed by for building web applications and services. Its modern iteration, , is open-source and cross-platform, running on Windows, , macOS, and in Docker containers. It enables developers to create dynamic websites, web APIs, and cloud-based services using languages like C# and technologies such as , CSS, , and syntax. Originally introduced as part of the .NET Framework in 2002, ASP.NET provided a server-side model for developing dynamic web pages, succeeding Active Server Pages (ASP). The legacy ASP.NET is Windows-only and proprietary, and has been in maintenance mode since 2022, receiving only security updates. Over time, it evolved to include multiple programming models, such as Web Forms for rapid development with drag-and-drop controls, MVC (Model-View-Controller) for structured separation of concerns, and Web API for building RESTful services. In 2016, Microsoft released ASP.NET Core, a redesigned, modular, and high-performance version that is cross-platform and open-source under the . ASP.NET Core runs on the .NET runtime (formerly .NET Core), supporting features like , middleware pipelines, and integration with for data access. It powers interactive applications with for client-side web UI using C#, real-time functionality via , and scalable APIs with built-in support for OpenAPI (Swagger). Key advantages of ASP.NET include its performance, as demonstrated in TechEmpower benchmarks where it outperforms many popular frameworks, and its seamless integration with Azure for cloud deployment. As of November 2025, is the recommended framework for new development, with the recent release of .NET 10 / 10.0 focusing on enhanced security, minimal APIs, and improved developer productivity. The framework's ecosystem supports , single-page applications (SPAs), and progressive web apps (PWAs), making it a cornerstone of enterprise .

History and Development

Origins in .NET Framework

ASP.NET originated as a core component of Microsoft's , announced in July 2000 at the Professional Developers Conference (PDC) as part of the broader .NET Platform initiative aimed at advancing web services and application development. Development began in the late 1990s under the codename Next Generation Windows Services (NGWS), evolving into a unified framework for building scalable web applications. Following the announcement, released initial beta versions of ASP.NET in 2000, with additional betas in 2001 to refine features and gather developer feedback before stabilization. The first stable release, ASP.NET 1.0, launched on February 13, 2002, integrated with 1.0 to provide a robust server-side platform. Designed as the successor to classic (ASP), ASP.NET shifted from interpreted scripting to compiled code execution, enabling models and seamless integration with .NET languages such as C# and VB.NET for enhanced performance and productivity. This evolution addressed limitations in classic ASP, such as runtime parsing and COM interop inefficiencies, by leveraging the (CLR) for managed code execution. At launch, ASP.NET introduced key innovations including server controls—reusable components that abstract HTML rendering and handle user interactions declaratively—and view state, a mechanism for persisting page and control data across HTTP requests without server-side session storage. Additionally, provided a disconnected data access architecture with datasets and data adapters, facilitating efficient integration of database operations into web applications. Early adoption faced challenges due to its exclusive dependency on and (IIS) for hosting, limiting deployment options compared to platform-agnostic alternatives. Developers transitioning from classic ASP's procedural scripting encountered a steeper , requiring to object-oriented paradigms, state management concepts like view state, and the post-back model. Despite these hurdles, ASP.NET quickly gained traction among enterprise developers for its structured approach to .

Evolution and Key Milestones

ASP.NET evolved through iterative enhancements to the .NET Framework, introducing features that improved developer productivity and capabilities. The release of .NET Framework 2.0 in November 2005 marked a significant milestone, bringing master pages for consistent layout management across pages and initial support for AJAX through extensions that enabled partial page updates without full postbacks. In 2007, .NET Framework 3.5 extended these capabilities with the introduction of (LINQ), allowing developers to query data sources using a unified syntax integrated into C# and , which simplified data access in ASP.NET applications. By 2010, .NET Framework 4.0 further refined the framework with a streamlined Web.config file to reduce configuration complexity and built-in URL routing for Web Forms, enabling cleaner, SEO-friendly URLs without mapping directly to physical files. A pivotal shift occurred in 2009 with the release of , which provided an alternative to the traditional Web Forms model by emphasizing the Model-View-Controller pattern for better , testability, and maintainability in . This parallel programming model addressed growing demands for more structured architectures in complex applications. The most transformative milestone came in 2016 with the release of , a complete rewrite as an open-source, cross-platform framework under .NET Core, unifying , , and into a single, modular runtime. This evolution was driven by needs for higher performance in resource-constrained environments, seamless integration with cloud platforms like Azure, and incorporation of open-source community feedback to enhance modularity and extensibility. Subsequent developments included the unification of .NET Framework and .NET Core into a single .NET platform starting with .NET 5 in November 2020, which streamlined development by making the recommended path for new web applications and emphasizing cross-platform capabilities. Key (LTS) releases, such as .NET 6 in 2021 and .NET 8 in 2023, further advanced performance, security, and features like minimal APIs and enhanced support, with .NET 9 released in November 2024 continuing this trajectory as of November 2025.

Core Architecture

ASP.NET Framework Components

The ASP.NET Framework relies on the (CLR) as its core runtime environment, enabling the execution of managed code written in languages like C# and VB.NET. The CLR provides essential services such as just-in-time () compilation, automatic through garbage collection, and to prevent runtime errors like invalid casts or null reference exceptions. This integration ensures that ASP.NET applications run in a secure, verifiable environment where code is executed within application domains for isolation and resource management. Key subsystems in the ASP.NET Framework include the HTTP runtime, which processes incoming HTTP requests by parsing them, routing to appropriate handlers, and managing the overall . Configuration is handled primarily through the Web.config file, an XML-based structure that defines settings for the application, such as connection strings, custom errors, and HTTP module registrations, allowing hierarchical inheritance from machine-wide to application-specific levels. The compilation model supports dynamic compilation, where pages and code are compiled on the first request for rapid development, or pre-compilation, which builds assemblies in advance for deployment to improve and enable error detection before runtime. The page framework forms a central component, implementing an event-driven lifecycle that begins with request acquisition by the HTTP runtime, proceeds through initialization, loading of view state, event handling, and data binding, and concludes with rendering the response to the client. This lifecycle supports server controls, such as the GridView for displaying tabular data with built-in sorting and paging, and validation controls like RequiredFieldValidator for ensuring input integrity without custom code. These controls are instantiated and managed during specific lifecycle phases to maintain state across postbacks. Integration with Windows services is foundational, particularly with (IIS) for hosting, where ASP.NET extends IIS through ISAPI filters and extensions in classic mode or integrated pipeline mode for seamless request processing. Authentication providers, configurable via Web.config, include Windows authentication leveraging IIS's Negotiate//Kerberos mechanisms and forms authentication for custom credential storage, ensuring secure user sessions within the IIS environment. Unlike ASP.NET Core's lightweight server, the Framework's components are tightly coupled to IIS for Windows-specific hosting.

ASP.NET Core Modular Design

ASP.NET Core introduces a modular foundation built on the .NET runtime, where core functionality is delivered through lightweight packages rather than a monolithic installation. This design enables developers to include only the necessary components, such as MVC or Pages, via methods like AddControllersWithViews() or AddRazorPages(), resulting in smaller application footprints and improved performance. By decoupling features into packages, ASP.NET Core supports cross-platform development and facilitates easier updates without requiring a full framework reinstall. Central to this modularity is the , a customizable chain of components that processes incoming HTTP requests and outgoing responses in a sequential manner. Each middleware handles specific tasks, such as via UseLogging(), with UseAuthentication(), or through UseRouting(), allowing developers to compose the pipeline in the Program.cs file using extension methods like app.Use(). This pipeline operates on the HttpContext object, enabling flexible, ordered execution that can be tailored to application needs without tight to the underlying runtime. The modular nature of middleware promotes reusability and , contrasting with the more rigid processing in earlier frameworks. ASP.NET Core includes a built-in dependency injection (DI) container that manages object creation and lifetimes, integrated directly into the framework via the IServiceCollection interface. Services are registered during application startup using methods like services.AddSingleton(), services.AddScoped(), or services.AddTransient(), which define how instances are shared—singleton for application-wide single instances, scoped for per-request lifecycles, and transient for new instances per resolution. This DI system supports , allowing components to request dependencies through constructors, enhancing testability and modularity by avoiding hardcoded dependencies. For example, database contexts can be registered with services.AddDbContext<MyContext>() to inject configuration-aware services automatically. Configuration in ASP.NET Core is handled through a provider-based system that prioritizes JSON files like appsettings.json, with support for environment-specific overrides such as appsettings.Development.json. The IConfiguration interface aggregates sources including environment variables and command-line arguments, enabling seamless adaptation across deployment scenarios without recompilation. This approach separates configuration from code, reinforcing the modular design by allowing runtime adjustments that align with the framework's independence from operating system specifics. Hosting is abstracted via the IHost or WebApplication models, which decouple the application from platform dependencies, supporting diverse environments through configurable builders.

Programming Models

Web Forms and Post-Back Model

ASP.NET Web Forms provides an event-driven, stateful programming model within the ASP.NET Framework, enabling developers to create dynamic web pages using a rich set of server controls and a post-back mechanism for handling user interactions. This model abstracts much of the underlying HTTP protocol, allowing for rapid application development similar to desktop programming paradigms. Developers can utilize drag-and-drop functionality in Visual Studio to place server controls on pages, which are then processed on the server to generate HTML output sent to the client. Central to this model are server controls, such as the and TextBox, which encapsulate both markup and behavior. These controls render as standard elements in the browser but maintain server-side logic for events and state. For instance, a control generates an <input type="submit"> element that, when clicked, initiates a post-back to the server, while a TextBox renders as an <input type="text"> for user input. The framework automatically handles the conversion between these controls and their HTML representations, simplifying the creation of interactive user interfaces.) To maintain state across the inherently stateless HTTP requests, Web Forms employs View State, a mechanism that serializes the properties of pages and controls into a base64-encoded string stored in a hidden form field named __VIEWSTATE. This data is automatically restored on subsequent post-backs, preserving values like user-entered text in a TextBox or the selected index in a without requiring manual intervention. View State is enabled by default for all server controls but can be disabled selectively to optimize , though doing so requires alternative for affected elements. The post-back mechanism forms the core of user interaction in Web Forms, where client-side actions like button clicks or form submissions send the entire page (or portions thereof) back to the server for processing. Synchronous post-backs refresh the full page, triggering server-side events such as Button.Click or page-level Load. For asynchronous post-backs, the UpdatePanel control enables partial page updates by wrapping sections of the page, reducing the data transferred and avoiding full reloads while still invoking the server event model. This approach supports scenarios like updating a grid without disrupting the entire layout. Page processing in Web Forms follows a well-defined lifecycle of events, ensuring consistent handling of initialization, state restoration, event execution, and rendering, particularly during post-backs. The sequence begins with the Init event, where controls are initialized and any master pages or themes are applied, but View State properties are not yet loaded. Next, the Load event restores control properties from View State and control state, allowing access to persisted values. If the request is a post-back, control-specific event handlers (e.g., Button.Click) are then invoked, followed by validation if applicable. The PreRender event provides the final opportunity for modifications before View State is serialized and saved. Finally, the Unload event handles cleanup tasks, such as closing database connections, after the response has been generated but before the page is discarded. This structured lifecycle facilitates predictable behavior and debugging in stateful applications. Web Forms excels in use cases requiring rapid development of data-driven user interfaces, such as enterprise applications with forms, grids, and validation logic, where the control library and event model accelerate prototyping and maintenance. However, the heavy reliance on View State and full or partial post-backs can lead to larger page payloads, potentially impacting load times and complicating SEO optimization due to dynamic content generation. Additionally, the server-centric approach may hinder native mobile responsiveness, as post-backs do not align seamlessly with touch-based interactions or varying screen sizes without additional CSS and adaptations.

MVC, Razor Pages, and API Development

ASP.NET Core MVC implements the Model-View-Controller (MVC) design pattern, which promotes by dividing application logic into three interconnected components: the model for and business rules, the view for rendering the , and the controller for handling user input and coordinating responses. This separation facilitates testable code, as controllers can be unit tested independently without relying on views or full HTTP contexts, enabling developers to mock dependencies and verify behavior in isolation. Controllers are classes that inherit from Controller or ControllerBase, processing incoming HTTP requests, interacting with models, and selecting appropriate views or returning directly. Views in MVC utilize templating, a syntax that embeds C# code within markup to generate dynamic content, such as declaring a model with @model IEnumerable<Product> or iterating over data with @foreach (var item in Model) { <p>@item.Name</p> }. syntax supports conditional rendering, partial views for reusable UI components, and Tag Helpers for server-side attributes that produce cleaner , like <input asp-for="Email" /> for model-bound form inputs. This approach ensures views remain focused on presentation while leveraging strongly typed models for and IntelliSense support in development tools. Razor Pages, introduced in ASP.NET Core 2.0, offer a page-focused that simplifies development for page-centric applications, particularly those involving basic CRUD operations, by combining the handler logic and markup within a single .cshtml file or its associated code-behind. Each Page consists of a .cshtml file containing with embedded syntax and a corresponding PageModel class (in .cshtml.cs) that defines properties for data binding and handler methods like OnGetAsync() for retrieving data on page load or OnPostAsync() for form submissions. The @page directive at the top of the .cshtml file registers the page as an endpoint, enabling convention-based routing where the file name determines the , such as Pages/Index.cshtml mapping to "/". This model reduces boilerplate compared to traditional MVC by colocating related code, making it easier to maintain small-scale web apps without separate controllers for each page; for instance, a handler might bind form data automatically and redirect after processing, as in public async Task<IActionResult> OnPostAsync(Product product) { if (ModelState.IsValid) { await _context.SaveChangesAsync(); return RedirectToPage("./Index"); } return Page(); }. Razor Pages support model binding, validation with attributes like [Required], and for services, aligning with ASP.NET Core's modular design while maintaining stateless, HTTP-compliant behavior. Web API development in ASP.NET Core centers on building RESTful services that expose endpoints for data operations, typically using controllers derived from ControllerBase to handle HTTP methods without view rendering. Attribute routing simplifies mapping with attributes like [Route("api/[controller]")] on the controller class and [HttpGet], [HttpPost] on actions, allowing patterns such as GET /api/products for listing items or POST /api/products for creation, where the controller name (e.g., ProductsController) fills the placeholder. The [ApiController] attribute enables API-specific conventions, including automatic model validation that returns 400 Bad Request for invalid inputs and inference of response types. JSON serialization and deserialization are handled by System.Text.Json, the default formatter in , which converts objects to and from streams efficiently, supporting features like case-insensitive property matching and polymorphic via options configuration. For example, an action might return return Ok(new { Id = 1, Name = "Product" }); to produce output, or use CreatedAtAction(nameof(GetProduct), new { id = product.Id }, product); for 201 Created responses with location headers, ensuring adherence to principles for scalable, stateless APIs. Blazor integrates with ASP.NET Core to enable interactive web UIs using C# and .NET components instead of JavaScript. As of .NET 8 and continuing in .NET 9, Blazor primarily uses a unified model in Blazor Web Apps with render modes that determine interactivity and hosting: static server-side rendering for non-interactive content, Interactive Server for server-side rendering with real-time updates via (similar to legacy Blazor Server), Interactive WebAssembly for client-side execution in the browser through , and Interactive Auto which starts with server rendering and switches to WebAssembly. Legacy Blazor Server and standalone Blazor WebAssembly apps remain supported for existing projects. In Interactive Server mode, Razor components (.razor files) render on the server, with UI events triggering diffs sent over for efficient updates, suitable for low-latency intranet apps. Blazor WebAssembly downloads the .NET runtime to the client, allowing full offline capability and direct API calls, while sharing Razor syntax for component markup like @page "/counter" <h1>Counter</h1> <p>Current count: @currentCount</p> <button @onclick="IncrementCount">Click me</button> @code { private int currentCount = 0; private void IncrementCount() { currentCount++; } }. This integration leverages ASP.NET Core's routing and middleware pipeline for hosting Blazor apps alongside MVC or Razor Pages endpoints.

Hosting and Deployment

IIS Integration and Pipeline

ASP.NET Framework applications are hosted on Internet Information Services (IIS) in Windows environments through the use of Internet Server Application Programming Interface (ISAPI) extensions and filters, which enable the server to route requests to the appropriate ASP.NET handler based on file extensions. For instance, requests for .aspx files are mapped to aspnet_isapi.dll, the core ISAPI extension that bridges IIS and the ASP.NET runtime, allowing the framework to process dynamic content.) This model, prominent in IIS 6.0 and earlier, operates in classic mode, where ASP.NET maintains a separate request pipeline from IIS's native pipeline, limiting interoperability between native ISAPI components and managed ASP.NET modules.) The introduction of integrated pipeline mode in IIS 7.0, released in 2008, marked a significant evolution by unifying the IIS native with the ASP.NET managed into a single, cohesive request-processing architecture. In this mode, ASP.NET modules can execute at any stage of the request lifecycle alongside native IIS modules, enabling uniform processing of all requests—regardless of handler—for shared features such as , , and caching. This integration allows pre-conditioned handler mappings to automatically select the appropriate ASP.NET version and runtime, directing requests to managed handlers instead of relying solely on ISAPI in classic mode. The ASP.NET request pipeline in integrated mode progresses through a series of well-defined events, starting with BeginRequest and concluding with EndRequest, during which modules and handlers perform specific tasks. Modules, such as the UrlRoutingModule, intervene at stages like PostResolveRequestCache to handle URL routing, while handlers like PageHandlerFactory are invoked after the PostMapRequestHandler stage to process specific content types, such as rendering ASPX pages.) Key intermediate events include AuthenticateRequest for user identity verification and AuthorizeRequest for access checks, ensuring comprehensive request handling across the pipeline. This staged approach provides extensibility, as developers can register custom modules and handlers to hook into these events for tailored processing.) Configuration of the IIS integration occurs primarily through the Web.config file, where the <system.webServer> section defines IIS-specific elements like handler mappings and module registrations. For example, handlers are added via the element to map verb-path combinations to managed assemblies, overriding or supplementing ISAPI mappings in integrated mode. Modules are similarly registered in the section to participate in events, allowing fine-grained control over request flow without altering global IIS settings.) This configuration model ensures that ASP.NET applications can leverage IIS's robustness while maintaining framework-specific customizations.

Cross-Platform Hosting in ASP.NET Core

ASP.NET Core introduces cross-platform hosting capabilities, allowing applications to run on Windows, , and macOS without dependency on (IIS). This flexibility is achieved through the web server, which serves as the default HTTP server and supports self-hosting scenarios. Unlike the original ASP.NET Framework, which was tightly coupled to Windows and IIS, ASP.NET Core's enables deployment in diverse environments, including platforms and containers. Kestrel is a , high-performance, cross-platform implemented in managed code, capable of handling HTTP/1.1, , and protocols. It is included by default in projects and can be configured programmatically to bind to specific ports, enable , and set limits such as maximum request body size or concurrent connections. For instance, developers can customize Kestrel options in the Program.cs file using the UseKestrel method on the host builder, allowing fine-tuned control over listening endpoints and security settings. This configuration ensures compatibility across operating systems, with Kestrel leveraging platform-specific networking APIs for optimal performance on and macOS. The hosting environment in ASP.NET Core is typically initialized in Program.cs using the modern minimal hosting model with WebApplication.CreateBuilder (recommended since .NET 6 in 2021), which sets up a cross-platform web host with built-in support for , configuration providers, logging, and . This approach automatically detects the runtime environment and configures the application to run seamlessly on Windows, , or macOS, including content root and web root paths adjusted for the host OS, while reducing by integrating service registration and configuration directly in Program.cs. The older WebHost.CreateDefaultBuilder method remains available for but is legacy. An example setup might look like this:

csharp

var builder = WebApplication.CreateBuilder(args); // Add services to the container. builder.Services.AddControllersWithViews(); var app = builder.Build(); // Configure the HTTP request pipeline. if (!app.Environment.IsDevelopment()) { app.UseExceptionHandler("/Error"); app.UseHsts(); } app.UseHttpsRedirection(); app.UseStaticFiles(); app.UseRouting(); app.UseAuthorization(); app.MapControllerRoute( name: "default", pattern: "{controller=Home}/{action=Index}/{id?}"); app.Run();

var builder = WebApplication.CreateBuilder(args); // Add services to the container. builder.Services.AddControllersWithViews(); var app = builder.Build(); // Configure the HTTP request pipeline. if (!app.Environment.IsDevelopment()) { app.UseExceptionHandler("/Error"); app.UseHsts(); } app.UseHttpsRedirection(); app.UseStaticFiles(); app.UseRouting(); app.UseAuthorization(); app.MapControllerRoute( name: "default", pattern: "{controller=Home}/{action=Index}/{id?}"); app.Run();

This approach abstracts away OS-specific details, enabling developers to build once and deploy across platforms without code changes. In production environments, is rarely exposed directly to the due to its focus on core request ; instead, it integrates with reverse proxy servers like or for enhanced security, load balancing, and static file serving. These proxies forward requests to Kestrel while preserving client information, such as the real , through the ForwardedHeaders in the application's . Configuration involves enabling the middleware early in the request pipeline and setting trusted proxy networks to prevent spoofing. For example, Nginx can be set up to proxy requests to Kestrel on a local port, ensuring robust handling of termination and traffic routing on Linux-based servers. Deployment options for cross-platform hosting emphasize containerization and cloud services. Docker containers package applications with their dependencies, allowing consistent execution on any Docker-supported host, including servers or clusters; official .NET Docker images facilitate multi-stage builds for efficient runtime images. Azure App Service provides managed hosting for apps on both Windows and plans, supporting automatic scaling and integration with via built-in reverse proxy capabilities. In hybrid scenarios, IIS can act as a on Windows, forwarding requests to a self-hosted instance while leveraging IIS for URL rewriting and authentication. These options enable scalable, platform-agnostic deployments without altering the core application logic.

Versions and Lifecycle

ASP.NET Framework Releases

The ASP.NET Framework, part of the .NET Framework, has evolved through several versions since its initial release, each introducing enhancements to capabilities, performance, and integration with emerging technologies. The original ASP.NET was tightly coupled with the Windows ecosystem and (IIS), focusing on server-side rendering and for dynamic web applications. Releases were tied to .NET Framework versions, with key innovations in controls, , and asynchronous processing to support enterprise-scale web apps. The version history spans from 1.0 in 2002 to 4.8 in 2019, with a minor update in 4.8.1 in 2022. Early versions emphasized foundational web forms and postback models, while later ones added AJAX support, improved rendering, and async patterns. Mainstream support for most versions ended between 2009 and 2022, but extended security updates continue for select versions like 3.5 and 4.8, reflecting its ongoing use in legacy systems. Microsoft provides paths for migration to for modern applications, though the Framework persists in many enterprise environments to its stability and backward compatibility.
VersionRelease DateKey ASP.NET FeaturesEnd of Support
1.0February 13, 2002Introduced Web Forms for event-driven programming, server controls, data binding, and mobile controls; built on CLR 1.0 for basic web application development.Ended January 13, 2009 (extended).
1.1April 30, 2003Enhanced performance with better mobile support, themes for consistent styling, precompilation for faster deployment, and improved security via built-in cryptography; supported side-by-side execution with 1.0.Ended July 14, 2009 (extended).
2.0November 7, 2005Added master pages for layout consistency, membership and role providers for authentication, personalization services, new controls like GridView and DetailsView, and client callbacks for partial updates; integrated with CLR 2.0 for generics and improved scalability.Ended April 12, 2011 (mainstream); extended support ended April 10, 2013.
3.0November 6, 2006Introduced Windows Communication Foundation (WCF) and Windows Workflow Foundation (WF) integration for service-oriented apps, with ASP.NET hosting support; no major ASP.NET-specific changes but enhanced overall framework for web services.Ended July 12, 2011 (mainstream); extended support ended April 10, 2013.
3.5November 19, 2007Built-in AJAX controls and extensions for asynchronous updates without full postbacks, LINQ integration for data querying, and RESTful services via WCF; included AJAX Control Toolkit for richer client interactions.Mainstream ended January 13, 2015; extended support ends January 9, 2029 (for 3.5 SP1).
4.0April 12, 2010Improved HTML rendering for cleaner markup, URL routing for SEO-friendly paths, permanent redirects, client ID mode control to avoid naming conflicts, and enhanced ViewState management; supported MVC 3 with Razor syntax.Ended January 12, 2016 (all support).
4.5August 15, 2012Async support using Task-based patterns for better scalability in I/O-bound operations, bundling and minification for optimized resource delivery, model binding enhancements, and lazy request validation to handle unvalidated input selectively.Ended January 12, 2016 (all support).
4.5.1October 17, 2013Added One ASP.NET for unified configuration across Web Forms, MVC, and Web API; improved Bootstrap integration, new membership system with OWIN support, and better mobile responsiveness.Ended January 12, 2016 (all support).
4.5.2May 5, 2014Enhanced async logging and tracing, per-core locking for better multi-threading, and improved support for cloud environments; minor ASP.NET updates focused on performance tuning.Ended April 26, 2022 (all support).
4.6July 15, 2015HTTP/2 protocol support for faster web performance, improved cryptography with TLS 1.1/1.2 defaults, and Roslyn compiler integration for better editing; ASP.NET benefited from enhanced JIT compilation.Ended April 26, 2022 (all support).
4.6.1November 18, 2015Added support for new TLS versions, improved debugging, and algebraic data types in some libraries; ASP.NET updates included better JSON handling and authentication middleware.Ended April 26, 2022 (all support).
4.6.2August 2, 2016Introduced child process debugging, better high-DPI support, and SQL Server 2016 compatibility; ASP.NET saw enhancements in cross-device rendering.Active until January 12, 2027 (extended).
4.7April 5, 2017Improved TLS 1.3 support, better WPF accessibility, and .NET Standard 2.0 compatibility; ASP.NET features focused on security hardening and performance.Active (support aligned with Windows OS lifecycle; no announced end date as of November 2025).
4.7.1October 17, 2017Enhanced support for OpenSSH, better ARM64 compatibility, and improved serialization; minor ASP.NET updates for authentication flows.Active (support aligned with Windows OS lifecycle; no announced end date as of November 2025).
4.7.2April 30, 2018Added support for new cryptographic algorithms, better Windows 10 integration, and accessibility improvements; ASP.NET benefited from updated hosting models.Active (support aligned with Windows OS lifecycle; no announced end date as of November 2025).
4.8April 18, 2019Focused on reliability with fixes for WPF and Windows Forms interop, improved High-DPI support, and accessibility enhancements; ASP.NET updates included better compatibility for legacy web apps without major new features.Active (support aligned with Windows OS lifecycle; no announced end date as of November 2025).
4.8.1August 9, 2022Minor update with security fixes, support for newer TLS protocols, and ARM64 enhancements; no significant new ASP.NET features, emphasizing maintenance for existing apps.Active (support aligned with Windows OS lifecycle; no announced end date as of November 2025).
As of November 2025, .NET Framework 4.8/4.8.1 and earlier supported versions remain recommended for ongoing ASP.NET development in Windows environments where cross-platform is not required, with security updates delivered via and support tied to the Windows OS lifecycle. For legacy apps on unsupported versions, Microsoft advises upgrading in-place to 4.8/4.8.1 or migrating to to access cross-platform capabilities and .

ASP.NET Core Releases and Support

ASP.NET Core, as an integral part of the .NET platform, follows the annual release cadence established for .NET starting from version , with earlier .NET Core versions released on a similar schedule. The initial release, 1.0, arrived in June 2016 alongside .NET Core 1.0, introducing a modular, cross-platform framework for . Subsequent versions built incrementally: 2.0 in August 2017, 2.1 (LTS) in May 2018, and 2.2 in December 2018; then 3.0 in September 2019 and 3.1 (LTS) in December 2019. This progression continued with 5.0 in November 2020, 6.0 (LTS) in November 2021, 7.0 in November 2022, 8.0 (LTS) in November 2023, and 9.0 in November 2024. Microsoft provides two support tiers for .NET releases, including ASP.NET Core: Long Term Support (LTS) versions receive three years of support, while Standard Term Support (STS) versions receive 18 months (or extended for alignment in some cases), with security updates and bug fixes during that period. For instance, .NET 8 LTS, which includes 8.0, is supported until November 10, 2026. .NET 9, an STS release incorporating 9.0, has support until November 10, 2026, aligning with the end of .NET 8 support to facilitate smoother transitions for developers. As of 2025, ASP.NET Core 9.0 introduces enhancements focused on performance, security, and developer productivity, including expanded Native AOT (Ahead-of-Time) compilation support for minimal APIs and Razor Pages, which reduces startup times and memory usage in cloud-native scenarios. Improved monitoring tools, such as opt-out HTTP metrics for specific endpoints, enable better memory analysis and tracing without overhead in high-traffic applications. Additionally, new AI integration primitives, like extensions to TensorPrimitives for efficient math operations and interop with libraries such as ML.NET and ONNX Runtime, simplify embedding AI capabilities into web applications. Upgrading between versions often involves addressing breaking changes to ensure compatibility, with providing detailed migration guides. A notable example is the shift to endpoint in 3.0, which replaced the previous middleware and required updates to route configuration and link in MVC applications for better and extensibility. Subsequent upgrades, such as from 7.0 to 8.0, emphasize minimal disruptions through backward compatibility but may require adjustments for new defaults like enhanced .
VersionRelease DateSupport TypeEnd of Support
1.0June 2016STSJune 2019
2.0August 2017STSOctober 2018
2.1May 2018LTSAugust 2021
2.2December 2018STSDecember 2019
3.0September 2019STSMarch 2020
3.1December 2019LTSDecember 2022
5.0November 2020STSMay 2022
6.0November 2021LTSNovember 2024
7.0November 2022STSMay 2024
8.0November 2023LTSNovember 2026
9.0November 2024STSNovember 2026

Ecosystem and Extensions

Third-Party Frameworks and Tools

The ASP.NET ecosystem is enriched by a variety of third-party frameworks and tools developed by the community and commercial entities, which extend core functionalities such as , development, , data mapping, job processing, logging, and . These extensions leverage for seamless integration, allowing developers to build scalable applications without reinventing common patterns. By building atop ASP.NET's modular architecture, these tools enhance productivity and performance in diverse scenarios, from lightweight services to enterprise-grade systems. Among popular frameworks, ServiceStack offers high-performance API development with end-to-end typed integrations, supporting RESTful services and message-based APIs while optimizing for speed in web, mobile, and desktop applications. Orchard Core serves as a modular, multi-tenant (CMS) built specifically for , enabling the creation of extensible, content-driven web applications with features like theming and localization. Key tools include AutoMapper, a convention-based for object-to-object mapping that automates the transformation of domain entities to data transfer objects (DTOs), reducing in ASP.NET applications (commercial since April 2025; free alternatives include Mapster and Mapperly). Hangfire facilitates background job processing without requiring Windows Services or separate processes, using persistent storage to manage recurring, delayed, or queued tasks in .NET and .NET Core setups. Serilog delivers structured logging with fully-formed events, integrating easily into ASP.NET pipelines to output diagnostics to files, consoles, or other sinks for better . Integration examples highlight how these tools complement ASP.NET's built-in capabilities; for instance, Core acts as the primary object-relational mapper (ORM), utilizing DbContext for entity tracking and migrations to evolve database schemas declaratively within projects. Authentication is commonly handled via IdentityServer, an Connect and 2.0 framework that secures applications by managing user sessions, tokens, and identity providers. The growth of this ecosystem is propelled by , Microsoft's , which hosts over millions of packages and enables extensions like Swashbuckle for generating interactive OpenAPI (Swagger) documentation directly from API controllers, streamlining API exploration and testing.

Alternative Implementations

The Mono project, an open-source implementation of the .NET Framework initiated by in 2004 and later backed by , provided cross-platform support for subsets of ASP.NET technologies, enabling deployment of ASP.NET Web Forms and MVC applications on and macOS environments. This implementation allowed developers to run ASP.NET code outside of Windows without relying on Microsoft's proprietary runtime, leveraging the XSP and Mod Mono for integration. Following Microsoft's acquisition of in 2016, stewardship of Mono shifted toward integration with emerging .NET technologies, though active development of ASP.NET-specific features waned as focus moved to .NET Core; the project's last major release occurred in 2019, with subsequent patches emphasizing maintenance rather than expansion of web framework support. In the evolution from .NET Core to modern unified .NET, community-driven ports like the extend hybrid applications to additional platforms beyond official offerings. , an open-source framework, enables components—typically rendered via or server-side—to integrate with native UI renderers, supporting hybrid apps that combine web-like development with native performance on , Android, desktop, and embedded systems. For instance, Uno's renderer allows apps to run in browsers while its Skia-based engine ports them to non-web targets, facilitating single-codebase deployment for cross-platform scenarios without full reliance on .NET MAUI. This community effort addresses gaps in official hybrid tooling, particularly for and embedded devices, by providing pixel-perfect rendering and API compatibility layers. Cloud-specific implementations offer serverless alternatives for , decoupling runtime execution from traditional hosting models. Azure Functions, Microsoft's serverless compute service, natively supports applications through HTTP triggers and durable functions, allowing developers to build event-driven APIs and microservices that scale automatically without managing infrastructure. Similarly, integrates with via the Amazon.Lambda.AspNetCoreServer hosting package, enabling existing web APIs to run as serverless functions triggered by API Gateway or other AWS events, with support for .NET 8 and container images for custom deployments. These integrations preserve 's middleware pipeline and while abstracting server provisioning, making them suitable for high-throughput, cost-optimized workloads. Compatibility layers like .NET Standard facilitate shared codebases across diverse ASP.NET implementations, bridging the gap between the legacy .NET Framework and modular .NET Core runtimes. Defined as a set of standardized APIs common to multiple .NET platforms, .NET Standard 2.0 ensures that libraries targeting it—such as those for controllers or —can be consumed by both Framework-based and Core-based applications without recompilation. This specification, supported by .NET Framework 4.6.1 and all versions of .NET Core/.NET 5+, promotes interoperability in mixed environments, allowing alternative runtimes to leverage unified packages via while avoiding platform-specific divergences.

References

  1. https://dotnet.microsoft.com/en-us/learn/aspnet/what-is-aspnet
  2. https://learn.microsoft.com/en-us/aspnet/core/?view=aspnetcore-10.0
  3. https://learn.microsoft.com/en-us/aspnet/overview
  4. https://learn.microsoft.com/en-us/aspnet/core/overview?view=aspnetcore-10.0
  5. https://learn.microsoft.com/en-us/aspnet/core/fundamentals/?view=aspnetcore-10.0
  6. https://dotnet.microsoft.com/en-us/apps/aspnet
  7. https://learn.microsoft.com/en-us/aspnet/core/release-notes/aspnetcore-10.0?view=aspnetcore-10.0
  8. https://learn.microsoft.com/en-us/aspnet/core/mvc/overview?view=aspnetcore-10.0
  9. https://learn.microsoft.com/en-us/shows/pdc-2000/
  10. https://news.microsoft.com/source/2000/07/11/microsoft-announces-groundswell-of-support-for-net-platform/
  11. https://stackoverflow.com/questions/1083368/whats-the-early-history-of-the-net-framework
  12. https://learn.microsoft.com/en-us/lifecycle/products/microsoft-net-framework
  13. https://learn.microsoft.com/en-us/answers/questions/5591348/asp-net-what-is-this
  14. https://learn.microsoft.com/en-us/troubleshoot/developer/webapps/aspnet/development/server-controls
  15. https://learn.microsoft.com/en-us/dotnet/framework/whats-new/
  16. https://learn.microsoft.com/en-us/aspnet/web-forms/overview/older-versions-getting-started/master-pages/master-pages-and-asp-net-ajax-cs
  17. https://learn.microsoft.com/en-us/dotnet/csharp/whats-new/csharp-version-history
  18. https://learn.microsoft.com/en-us/dotnet/visual-basic/programming-guide/concepts/linq/introduction-to-linq
  19. https://learn.microsoft.com/en-us/aspnet/whitepapers/aspnet4/overview
  20. https://www.microsoft.com/en-us/download/details.aspx?id=5388
  21. https://learn.microsoft.com/en-us/lifecycle/products/microsoft-net-and-net-core
  22. https://learn.microsoft.com/en-us/aspnet/core/overview?view=aspnetcore-9.0
  23. https://devblogs.microsoft.com/dotnet/announcing-net-5/
  24. https://learn.microsoft.com/en-us/dotnet/core/whats-new/dotnet-9/overview
  25. https://learn.microsoft.com/en-us/dotnet/standard/clr
  26. https://learn.microsoft.com/en-us/dotnet/standard/managed-execution-process
  27. https://learn.microsoft.com/en-us/dotnet/api/system.web.httpruntime?view=netframework-4.8.1
  28. https://learn.microsoft.com/en-us/troubleshoot/developer/webapps/aspnet/performance/create-web-config
  29. https://learn.microsoft.com/en-us/previous-versions/aspnet/bb398860%28v=vs.100%29
  30. https://learn.microsoft.com/en-us/previous-versions/aspnet/ms178472%28v=vs.100%29
  31. https://learn.microsoft.com/en-us/dotnet/api/system.web.ui.webcontrols.gridview?view=netframework-4.8.1
  32. https://learn.microsoft.com/en-us/previous-versions/aspnet/7kh55542%28v=vs.100%29
  33. https://learn.microsoft.com/en-us/iis/application-frameworks/building-and-running-aspnet-applications/aspnet-integration-with-iis
  34. https://learn.microsoft.com/en-us/troubleshoot/developer/webapps/aspnet/development/security-overview
  35. https://learn.microsoft.com/en-us/aspnet/core/fundamentals/?view=aspnetcore-9.0
  36. https://learn.microsoft.com/en-us/aspnet/core/fundamentals/middleware/?view=aspnetcore-9.0
  37. https://learn.microsoft.com/en-us/aspnet/core/fundamentals/dependency-injection?view=aspnetcore-9.0
  38. https://learn.microsoft.com/en-us/dotnet/core/extensions/dependency-injection
  39. https://learn.microsoft.com/en-us/aspnet/core/fundamentals/configuration?view=aspnetcore-9.0
  40. https://learn.microsoft.com/en-us/archive/msdn-magazine/2001/may/asp-net-web-forms-let-you-drag-and-drop-your-way-to-powerful-web-apps
  41. https://learn.microsoft.com/en-us/aspnet/web-forms/what-is-web-forms
  42. https://learn.microsoft.com/en-us/previous-versions/aspnet/bb386448(v=vs.100)
  43. https://learn.microsoft.com/en-us/dotnet/api/system.web.ui.updatepanel?view=netframework-4.8.1
  44. https://learn.microsoft.com/en-us/previous-versions/aspnet/ms178472(v=vs.100)
  45. https://learn.microsoft.com/en-us/aspnet/core/mvc/overview?view=aspnetcore-9.0
  46. https://learn.microsoft.com/en-us/aspnet/core/mvc/views/overview?view=aspnetcore-9.0
  47. https://learn.microsoft.com/en-us/aspnet/core/mvc/views/razor?view=aspnetcore-9.0
  48. https://learn.microsoft.com/en-us/aspnet/core/razor-pages/?view=aspnetcore-9.0
  49. https://learn.microsoft.com/en-us/aspnet/core/tutorials/razor-pages/razor-pages-start?view=aspnetcore-9.0
  50. https://learn.microsoft.com/en-us/aspnet/core/web-api/?view=aspnetcore-9.0
  51. https://learn.microsoft.com/en-us/aspnet/core/blazor/components/render-modes?view=aspnetcore-9.0
  52. https://learn.microsoft.com/en-us/aspnet/core/blazor/hosting-models?view=aspnetcore-9.0
  53. https://learn.microsoft.com/en-us/aspnet/core/blazor/?view=aspnetcore-9.0
  54. https://learn.microsoft.com/en-us/archive/msdn-magazine/2002/august/asp-net-intercept-monitor-and-modify-web-requests-with-http-filters-in-isapi-and-asp-net
  55. https://learn.microsoft.com/en-us/iis/application-frameworks/building-and-running-aspnet-applications/how-to-take-advantage-of-the-iis-integrated-pipeline
  56. https://learn.microsoft.com/en-us/archive/msdn-magazine/2005/september/instrument-and-monitor-your-asp-net-apps-using-wmi-and-mom-2005
  57. https://learn.microsoft.com/en-us/iis/configuration/system.webserver/handlers/add
  58. https://learn.microsoft.com/en-us/aspnet/core/fundamentals/servers/kestrel?view=aspnetcore-9.0
  59. https://learn.microsoft.com/en-us/aspnet/core/fundamentals/servers/?view=aspnetcore-9.0
  60. https://learn.microsoft.com/en-us/aspnet/core/fundamentals/servers/kestrel/endpoints?view=aspnetcore-9.0
  61. https://learn.microsoft.com/en-us/aspnet/core/fundamentals/servers/kestrel/options?view=aspnetcore-9.0
  62. https://learn.microsoft.com/en-us/aspnet/core/fundamentals/servers/kestrel/when-to-use-a-reverse-proxy?view=aspnetcore-9.0
  63. https://learn.microsoft.com/en-us/aspnet/core/host-and-deploy/docker/building-net-docker-images?view=aspnetcore-9.0
  64. https://learn.microsoft.com/en-us/azure/app-service/quickstart-dotnetcore
  65. https://learn.microsoft.com/en-us/aspnet/core/host-and-deploy/iis/?view=aspnetcore-9.0
  66. https://learn.microsoft.com/en-us/dotnet/framework/install/versions-and-dependencies
  67. https://dotnet.microsoft.com/en-us/platform/support/policy/dotnet-framework
  68. https://learn.microsoft.com/en-us/aspnet/whitepapers/side-by-side-with-10
  69. https://learn.microsoft.com/en-us/archive/msdn-magazine/2006/vs-2005-guided-tour/a-look-at-the-new-services-controls-and-features-in-asp-net-2-0
  70. https://learn.microsoft.com/en-us/aspnet/web-forms/videos/aspnet-35/
  71. https://learn.microsoft.com/en-us/archive/msdn-magazine/2009/december/extreme-asp-net-looking-ahead-to-asp-net-4-0
  72. https://learn.microsoft.com/en-us/archive/msdn-magazine/2009/september/exploring-asp-net-4-0-web-forms-and-beyond
  73. https://devblogs.microsoft.com/dotnet/support-ending-for-the-net-framework-4-4-5-and-4-5-1/
  74. https://learn.microsoft.com/en-us/aspnet/whitepapers/whats-new-in-aspnet-45-and-visual-studio-2012
  75. https://learn.microsoft.com/en-us/previous-versions/aspnet/hh420390%28v=vs.120%29
  76. https://dotnet.microsoft.com/en-us/platform/support/policy
  77. https://learn.microsoft.com/en-us/aspnet/core/release-notes/aspnetcore-9.0?view=aspnetcore-9.0
  78. https://learn.microsoft.com/en-us/dotnet/ai/microsoft-extensions-ai
  79. https://learn.microsoft.com/en-us/dotnet/core/compatibility/3.0
  80. https://learn.microsoft.com/en-us/aspnet/core/migration/22-to-30?view=aspnetcore-9.0
  81. https://www.mono-project.com/docs/about-mono/compatibility/
  82. https://www.mono-project.com/
  83. https://github.com/mono/mono
  84. https://platform.uno/docs/articles/faq.html
  85. https://platform.uno/blog/blazor-webassembly-client-side-with-aot-and-skiasharp/
  86. https://github.com/unoplatform/uno.blazor.native.todoapp
  87. https://learn.microsoft.com/en-us/azure/azure-functions/functions-overview
  88. https://docs.aws.amazon.com/lambda/latest/dg/csharp-package-asp.html
  89. https://learn.microsoft.com/en-us/dotnet/standard/net-standard
Add your contribution
Related Hubs
User Avatar
No comments yet.