WebForms Core 2.3 is currently under development, introducing improvements to component-based development, resource lifecycle management, request handling, state management, and client-side execution.
Component System & Scope
The new component system is one of the major architectural additions planned for WebForms Core 2.3. It is being developed to bring the benefits of component-based development to WebForms Core's distinctive architecture, which uses server-driven commands, client-side execution, and a stateless server without server-side UI rendering.
The component system is designed to provide the following capabilities:
- Reusability — Create a component once and reuse it in multiple places across an application.
- Component Isolation — Keep each component instance's DOM operations and event handling within its own scope, preventing multiple instances of the same component from interfering with one another.
- Separation of Concerns — Organize application functionality into independent components, making code easier to maintain and extend.
- Composability — Combine individual components to build more complex user interfaces.
- Independent Component State — Allow each component instance to maintain its own state without unintentionally affecting other instances.
- Scoped Event Handling — Execute component events and their associated Action Controls within the appropriate component scope.
- Parameter-Based Communication — Support passing data and configuration between components.
- Event-Based Communication — Allow components to communicate through events and respond to interactions with other components.
- Testability — Make individual components easier to test by keeping their behavior and responsibilities organized within defined boundaries.
The goal is to make components reusable, independent, and easier to manage while preserving the existing WebForms Core execution model.
Example: A Counter Component in Blazor Server
The following example demonstrates the concept of independent component instances in Blazor Server. Keep it in mind until WebForms Core 2.3 is released to better understand the component-based approach being developed for WebForms Core.
File: Components/Counter.razor
<h3>Counter: @count</h3>
<button class="btn btn-primary" @onclick="Increment">
Increment
</button>
@code {
private int count = 0;
private void Increment()
{
count++;
}
}
This component contains markup, state, and event-handling logic.
File: Components/Pages/Home.razor
@page "/"
<h1>Home Page</h1>
<Counter />
<Counter />
<Counter />
By placing <Counter /> three times, Blazor creates three independent component instances. Each instance maintains its own count value.
This example illustrates the concept of component reuse and instance isolation. WebForms Core 2.3 is being developed to bring comparable component-oriented benefits to a different architecture, where the server sends commands and WebFormsJS executes them on the client.
EnableAutoCleanup
EnableAutoCleanup is a new method being developed to simplify resource lifecycle management.
When enabled, resources associated with the current page can be registered for cleanup and released when the page changes. These resources may include Event Listeners, Timers, Custom Events, Snapshots, Cache entries, Save data, IndexedDB data, and other resources that are no longer needed.
The purpose is to reduce manual cleanup work and help prevent obsolete resources and event handlers from remaining active after navigation.
Request & Action Control Lifecycle Management
Request handling and Action Control execution are being improved to prevent outdated operations from affecting the current page.
When users trigger multiple operations in quick succession, an earlier request may return after a newer request has already changed the page state. WebForms Core 2.3 is being developed to identify such obsolete requests and prevent their responses or associated Action Controls from executing when they no longer belong to the current page state.
This includes improved handling of request ordering, stale responses, and Action Controls associated with previous page states.
Rendered Value Mirroring
A new structure for mirroring rendered values into Cache and Save is being developed.
The mechanism is designed to compare a stored snapshot with the current outerHTML, identify relevant changes, and represent changed values in a suitable key-value structure. This can provide a consistent basis for retrieving and updating preserved data.
RunWebForms
A new RunWebForms method has been added to execute Action Controls on the client side programmatically.
This provides an additional way to run WebForms Core instructions without relying exclusively on their automatic execution through the usual processing flow.
SetResponse
A new SetResponse method has been added to programmatically add HTML, Action Controls, and other data to a response.
It also supports scenarios in which HTML comments contain WebForms Core instructions that need to be processed on the client side.
Hash URL State Management
State management for URLs containing hashes has been improved to provide more consistent behavior when navigating between hash-based locations.
Transient DOM Improvements
An issue that could cause an execution loop when Transient DOM was used on elements containing Comment Action Controls has been resolved.
Loader Improvements
Loader behavior has been improved with new configuration options for controlling Loader animations, including situations in which data arrives quickly.
The default Loader animation behavior has also been adjusted for CommentBack, with additional configuration options for WasmBack and FrontBack.
SPALink Improvements
SPALink behavior has been improved to allow its settings to be restored to their initial state when required.
Native Form Behavior
The behavior of button and input elements with type="submit" has been aligned more closely with the browser's default form behavior.
An issue that could cause an additional null value to be submitted when an element did not have a name attribute has also been resolved.
Overall Direction
WebForms Core 2.3 continues to build on the Commander-Executor architecture, in which the server provides commands and WebFormsJS executes them on the client.
The planned component system aims to combine reusable UI structures, scoped DOM operations, isolated component instances, and component communication with this architecture. Alongside EnableAutoCleanup, improved request lifecycle management, and state preservation, these developments are intended to make WebForms Core applications easier to organize and maintain without requiring server-side UI rendering.
Related Links
On Elanat:
On GitHub:
