WebForms Core is a true competitor to front-end frameworks – and in many cases, a superior competitor. Looking at its comprehensive feature set and JavaScript integration capabilities, it’s clear that WebForms Core is not just a front-end replacement, but it approaches front-end problems from a fundamentally better perspective. WebForms Core can call JavaScript methods directly through directives while maintaining a server-side architecture. WebForms Core is not a “cool replacement” – it’s a fundamental approach to building most web applications. The combination of server-side simplicity with client-side power through JavaScript integration creates a development experience that front-end frameworks can’t match.
WebForms Core v2.0 is not just an update, it’s an explosion of innovation. But it’s not an update; it’s a manifesto for the future of the web. An update like this has never been seen in the history of software development. And it probably won’t be seen again for decades.
Why was WebForms Core born?
Due to the many challenges of front-end frameworks, Elanat created WebForms Core technology to address these challenges.
Why were front-end frameworks challenging?
- We realized that users care more about "speed" than "visual effects".
- SEO and performance became business priorities.
- JavaScript bundles grew to hundreds of megabytes.
- SPA initial load times were unacceptable.
- Complexity reached the point of explosion and developers complained of "framework fatigue".
What Front-End Frameworks Promise and WebForms Core Delivers:
- Component Reusability ✅ (WebForms Core has extensibility with extension methods in the server-side programming language)
- State Management ✅ (WebForms Core does this automatically and also has caching/session)
- Rich Interactions ✅ (WebForms Core has a comprehensive event system)
- Performance ✅ (WebForms Core has an efficient command protocol)
- Ecosystem Access ✅ (WebForms Core can call any JS library)
- Scalability ✅ (The server in WebForms Core is completely stateless and scalable.)
This means:
- You are not limited to built-in commands
- You can use any JavaScript library (charts, maps, animations).
- You get the simplicity of server-side development with the power of client-side libraries
- Works offline via cache system
- The competitive landscape has changed
What WebForms Core offers that front-end frameworks don't:
- Single mental model (no context switching between front/back)
- Much easier debugging (everything goes back to the server code)
- Native real-time features (no need for additional libraries)
- Improved functionality by default (works without JS, improves with it)
- No build complexity (no interference from Webpack, Babel, npm)
- Simpler development experience (one language, one mindset) with performance equivalent to or better than front-ends
- Intelligent performance (server can make optimal decisions based on user conditions) Weak users: simpler pages, strong users: more advanced pages
Evolution in Access to Tag Data
In version 2, accessing input data has been greatly simplified. Powerful methods have been added to the server-side WebForms class and the WebFormsJS library to allow you to access this data directly.
To access the data, previously we had to first cache the data of each tag (including text, attributes, styles, etc.) and then use it. In version 2, we can directly access the data using the Fetch helper class.
From Caching to Direct Access: A Paradigm Shift
Example
Previous versions
form.SaveClass("<div>3");
form.SetClass("<div>4", Fetch.Saved());
In previous versions, you had to first save the tag data and then use that data.
Version 2
form.SetClass("<div>4", Fetch.GetClass("<div>3"));
In version 2 and later, you can directly get the tag data without saving it.
Comprehensive Tag Data Access Methods
WebForms Core 2 provides a rich set of methods to retrieve tag properties directly:
| Property | Method | Description |
|---|---|---|
| ID | GetId |
Retrieves the element's ID |
| Name | GetName |
Gets the name attribute |
| Value | GetValue |
Gets the input value |
| Value Length | GetValueLength |
Returns the length of the value |
| Class | GetClass |
Retrieves the CSS class |
| Style | GetStyle |
Gets inline styles |
| Title | GetTitle |
Gets the title attribute |
| Text | GetText |
Gets inner text |
| Outer Text | GetOuterText |
Gets full outer HTML |
| Text Length | GetTextLength |
Returns length of inner text |
| Attribute | GetAttribute |
Retrieves any attribute by name |
| Width | GetWidth |
Gets element width |
| Height | GetHeight |
Gets element height |
| Is Read Only | GetIsReadOnly |
Returns "0" or "1"
|
| Selected Index | GetSelectedIndex |
Gets selected index in dropdowns |
| Index | GetIndex |
Gets element index |
| Text Align | GetTextAlign |
Retrieves text alignment |
| Node Length | GetNodeLength |
Gets number of child nodes |
| Is Visible | GetIsVisible |
Returns "0" or "1"
|
Why This Matters
- Faster Development: No need to manage intermediate state or caching.
- Cleaner Code: Direct method calls reduce boilerplate and improve readability.
- Real-Time Interaction: Enables dynamic UI updates with minimal effort.
- Server-Side Power: All logic remains centralized, simplifying debugging and scaling.
WebForms Core 2’s tag data access overhaul is a perfect example of how it reimagines web development — not just simplifying it, but making it smarter and more intuitive.
Top comments (0)