While at PDC this year I had an opportunity to interview a number of smart and engaging people. One of my guests was Scott Hunter (@coolcsh) who these days is responsible for WebForms, ASP.NET Data and seemingly much more. To my surprise Scott wanted to talk about what is coming after ASP.NET 4!
Taking a step back and looking at ASP.NET, tooling, data and the entire experience of working with the .NET stack Scott’s team and other groups in Microsoft are turning their attention to a single concept…
1: Overload the DataBind Method
How often have you worked with data bound control and wrote code like this:
protected void Page_Load(object sender, EventArgs e)
this.grid.DataSource = foo;
Wouldn’t it be simpler if you could just call the DataBind method and pass in the data source?
You can do this easily today by implementing an extension method as I did here, but it would be nice to have this as a first-class feature of the BaseDataBoundControl class.
2: Implement IsFirstRequest Property
The whole notion of the IsPostBack property always seemed a bit awkward to me. More often than not you are using this property to evaluate it’s negative state – in other words trying to figure out if the page is running under the context of the first request. I suggest the addition of a property that is no more than the reverse of IsPostBack:
It’s a small thing, but I think it makes code a little cleaner to read.
3: Implement Application Name
Often developers need a way to display the application name to users. While setting up a globally-scoped class to handle this task is trivial, but it would be nice if there was a “Name” property off the page’s locally scoped Application property:
The value for this property would likely be saved in the web.config or Global.asax. Adding this feature may also help sort out a common problem that arises in using the membership provider when developers forget to define an application name. Visual Studio could auto fill this value with the “application name” from the create project wizard and then allow an override at any time.
4: Option to Categorize IntelliSense Members
Ever wanted to tap into an event of an object, but weren’t sure what the event name was? Ever wanted to know just what an object methods were while trying to learn a new API? What about trying to find out if there is a property for X? IntelliSense is an invaluable tool in it’s current form and Visual Studio 2010 adds some needed filtering behaviors for C#, but we can do even better.
It would be nice if IntelliSense had a way to display members in a categorical format:
Obviously this isn’t a feature you would want enabled at all times, but it would make working with new APIs much easier.
5: Bring XAML Data Binding Syntax to ASP.NET
David Fowler (@davidfowl) has been churning out some amazing blog posts all around the topic of data binding in ASP.NET. One of his recent posts included an exposition of DataBinding 3.0. Basically the latest iteration of data binding brings the XAML syntax to ASP.NET data binding.
This addition makes life easier because then you don’t have to worry about when you use the Bind or Eval syntax. Plus making a homogenous binding syntax among WPF, Silverlight, ASP.NET AJAX and ASP.NET WebForms makes working with the controls a natural task regardless of the platform you are working.
6: Parameter Attributes
When working with QueryString parameters requires some repetitious boilerplate code. Consider the following listing, which you have probably written thousands of times:
private string UserName
if(Request.QueryString["userName"] != null)
How much simpler would it be if you could just decorate the property with an attribute and the retrieval code is implemented automatically?
This approach doesn’t have to stop with the query string either. The same types of attributes may be available for :
- Form Elements
- Context Items
7: WebForms Model Binders
One of the features that I immediately fell in love with from the ASP.NET MVC framework was model binders. With the updates to ASP.NET 4 granting total control over the client IDs of server controls, now WebForms needs model binders!
The pages could be strongly typed like MVC strongly typed views, or the designer could interrogate the control hierarchy and build the view model on the fly. Obviously we’d also need some hooks to tap into the flow to implement custom bindings too.
Just as the server can benefit from automatic mapping of input controls to a model object, Ajax scenarios could be greatly simplified if there was a function to run on the client that automatically created a JSON object with all input values.
Consider a form like this:
With markup like this:
A model, or DTO if you like, could easily be constructed by querying the form and building the object from input elements.
There could even be special rules for certain controls like a select list. Sending the selected index, text and value as a group for the single control should provide all the information necessary to consuming resource.
9: Select the Location of ViewState
While ASP.NET 4 makes great strides to trim down a page’s ViewState it would still be nice to have explicit control over where the ViewState is rendered on the page. I’d love to see a server control that allows you to place the ViewState containers at a location of your choosing:
Now more times than not the best approach is to simply move ViewState to the bottom of the page, but having explicit control of the placement seems like the best scenario.
10: Disabling the Post Back Button
The ASP.NET runtime will not recognize a post back initiated by a disabled button so developers have had to concoct some clever ways to protect users from themselves. It would be nice if ASP.NET had a way to reliably disable post back buttons out-of-the-box.
11: Implement ASP.NET Configuration Console as Portable Area
Eric Hexter (@ehexter) recently blogged about the concept of a “portable area” where you can compile single controls controls or even up to entire workflows into an assembly to later include in an ASP.NET MVC or WinForms application. This approach is perfect for implementing the ASP.NET configuration UI generated by Visual Studio.
The portable area approach would decouple the screens from the layout seen in this screenshot and allow the pages to reflect the layout of your website. This feature would be perfect for exposing the membership functionality to admins, power users or even just the development team.
12: Script-Based Post Backs
It would make life much simpler for the times when this functionality is required to have a method off the Sys namespace (or wherever appropriate) that posts back a WebForm. This is how it could look:
Passing a string into the function would tell the page which handler to map to in the page event lifecycle.
So there you have it. These are some of my ideas about how to make ASP.NET and Visual Studio simpler to use. Now tell me, what are yours?