Scott Hunter

HTML 5 Updates for .NET 4

Scott H — Thu, 11 Aug 2011 05:49:41 GMT

After we shipped .NET 4 we began working on the next version of the framework and one of the things that we have worked on for the next version of the framework is more support for HTML 5. We think that HTML 5 is so important that we have taken many of updates from the next framework and provided some of the most important ones as part of updates to .NET 4. This enables our customers to more easily develop HTML 5 applications now instead of waiting for the next framework. I’m going to highlight a couple of the updates and the major fixes they provide.

Update for the .NET Framework 4

The first update was shipped with VS 2010 SP1. You can read about the framework update here: http://support.microsoft.com/kb/2468871. One of the features of HTML 5 is there are now new input types such as date, url, email and more. While most browsers today don’t support these new input types you should still use them today because most mobile devices do support them and it changes the keyboard these devices display. For example specifying type=”email” will cause many phones to provide the “@” character on the keyboard. type=”email” or type=”url” will cause many phones to provide the “.com” button on the keyboard as a shortcut.

Before the update above it was illegal to use these input types in Web Forms. The following would generate an error:

<asp:TextBox id=”TextBoxEmail” runat=”server” type=”email” />

Because we were validating what values could be provided for the type= attribute. This validation was relaxed as part of the above update.

Reliability Update 1 for the .NET Framework 4

Earlier this week on patch Tuesday another update was released called the reliability update 1 for .NET 4: http://support.microsoft.com/kb/2533523. This update solves a variety of problems with HTML 5 input types. If you used any of the HTML 5 input types (a few mentioned above) with server controls they would not behave properly in the following cases:

UpdatePanel – The values of any HTML 5 input types would not be posted back on postback.

Validation Controls - The ASP.NET validation controls such as asp:RequiredFieldValidator would not provide client validation on HTML 5 input types.

Callbacks – ASP.NET pages that are using callbacks would not post back the values of any HTML 5 input types.

All of these items were corrected with the second update listed above. Even more support for HTML 5 will be coming in the next version of the framework and we hope to start announcing details around that soon. Note the above two updates also fix quite a few other things in .NET 4 as well so I suggest you read the details from the links.

Update on the Microsoft jQuery Plugins

Scott H — Fri, 15 Apr 2011 16:42:55 GMT

A little over a six months ago we blogged about the work that Microsoft was doing with jQuery plugins (jQuery Templates, Globalization, and Data Link). This post provides a little more information on the current status and on the plans for those plugins.

Over the past six months, as the jQuery and Microsoft teams have worked on the plugins, we've decided together that the richness and power of these plugins makes it important to develop them in the context of a strong relationship with a collaborative sub-team within jQuery.

To facilitate this, the jQuery team has announced some changes in the way plugins are managed. Each plugin will now be owned by a sub-team within the jQuery Project, such as the jQuery UI team or the jQuery Core Dev team.

When jQuery 1.5 shipped earlier this year, you might have wondered why jQuery Templates was not part of that release. The jQuery announcement clarifies this -- jQuery Templates is a key part of jQuery functionality, but it will nonetheless continue as a separate plugin in jQuery UI rather than shipping as part of jQuery Core.

This is a continuation of the investment that Microsoft is making in jQuery and jQuery UI. Our investment isn't limited to the plugins I just mentioned. For example, another important investment has been the new jQuery UI Grid project that we've provided support for at many levels. We're now shipping both jQuery and jQuery UI in our newer products, and we plan to have great support in ASP.NET for developers who want to use the jQuery UI Grid in their projects.

Moving forward, we'll continue to be involved in the design and development of jQuery Templates. This includes our contributions to the grid project, since the jQuery UI Grid is using the jQuery Templates plugin. Microsoft will also continue to work on Data Linking and its integration with jQuery Templates. We'll move that work to its own source repository, plus we'll take ownership of the documentation.

We think these changes are a valuable step towards helping the Microsoft and jQuery teams and the community to move these plugins towards RTM quality and to ship them as great V1 products!

Updates to the Microsoft CDN (Updated 12/1/2010)

Scott H — Tue, 16 Nov 2010 17:36:00 GMT

I want to announce a couple of changes we have made to the Microsoft CDN recently.

Updated jQuery

We have added both jQuery 1..4.3 and jQuery 1.4.4 to the CDN, plus there are vsdoc files for both of these releases. These new releases are available with these URLs:

jQuery version 1.4.4

jQuery version 1.4.3

New Domain Name

The Microsoft CDN is now available from a new domain name: ajax.aspnetcdn.com. We added support for this new domain name to increase the performance of the CDN. The primary benefit of the new domain is that it is not the microsoft.com domain, any requests to the microsoft.com cause the browser to send cookies for that domain across the wire. Since many people may have visited a Microsoft web property this means extra information is coming across the wire for those requests potentially slowing down the request. The new domain is a domain a user would never have visited in their browser and thus requests will have no additional payload. Testing has shown that this can increase speeds by up to 20%.

The previous domain ajax.microsoft.com is still available and will always remain available so all links to it will continue to function as usual but going forward we recommend people use the new domain.

Full details of the Microsoft CDN are available here: http://www.asp.net/ajaxlibrary/cdn.ashx

SSL Support (12/1/2010)

When we first created the new CDN ajax.aspnetcdn.com it did not support SSL (https://) style requests. As of 12/1/2010 the CDN has been updated to support SSL as well now.

Web Pages Beta 2–Request Validation

Scott H — Thu, 07 Oct 2010 05:09:02 GMT

Today we released all kinds of goodness at Microsoft for ASP.NET developers:

- Web Pages Beta 2 – An update to our new support for adding simple Razor syntax pages to to web applications.
- MVC 3 Beta – An update to our preview release from a few months ago with several enhancements around razor, helpers, unobtrusive javascript, dependency injection and more.
- NuPack – Package manager for finding, adding, upgrading libraries for your .NET projects. This makes it super easy to find libraries for writing your applications and easily installing them into your projects including their dependencies.

I want to focus on Web Pages today which I’ve not written about since we released the first release but I’ve been involved in from the beginning. If you don’t have any background on Web Pages this is a very simple way to do web development drawling parallels to programming in classic ASP or PHP. It does not require development tools like Visual Studio, or a build system to build projects. You can just take an empty folder and and drop in a .cshtml (C#)or .vbhtml (Visual Basic) file into the folder that contains a combination of markup and razor syntax and point your browser and you are off and running.

For someone like myself Web Pages reminds me of when I first started web programming years ago with classic ASP. I could take my HTML files and add a little bit of inline code to get dynamic web pages. It was a great way to learn web programming and Web Pages brings this same simplicity to ASP.NET. All of the concepts you learn while programming in Web Pages you should be able to use if you decide to move up to our more complicated frameworks like MVC.

To learn more about Web Pages check out our online manual: http://www.asp.net/webmatrix/tutorials/1-getting-started-with-webmatrix-and-asp-net-web-pages.

Today I’m going to talk about Request Validation which is a security feature that is built in ASP.NET. Request Validation is a security measure that is built into ASP.NET. The purpose of this feature is prevent script or HTML injection attack in websites. Such attacks happen when a webpage has some input fields on the page that accept input. If a person fills these input fields with script or html and the web page outputs the content back the user the web browser will run the script or html potentially causing the browser to do something bad.

To prevent this ASP.NET looks at any input that it sees and if it looks like unencoded html and error will happen and the request will not be processed. Lets take a simple application and see what this looks like:

<!DOCTYPE html>
<html lang="en">
    <head>
        <meta charset="utf-8" />
        <title></title>
    </head>
    <body>
        <form method="post" action="">
            <label for="description">Description:</label>
            <textarea name="description">
            </textarea>
            <br />
            <input type="submit" value="Submit"></input>
        </form>
        <br />
        @if (IsPost) {
            <div>
                Your description is: @Request["description"]
            </div>
        }
    </body>
</html>

If I type something in the field on the page that looks like html:

And the press the submit button I will get an error instead of having my page run properly:

This shows an example of ASP.NET working to be secure by default and making the developer make the decision if they want allow such input. You might be asking yourself why would you want to allow someone to type html into a field. The best example is when you build a web page that contains a rich html editor, today you see these in all kinds of applications on the internet such as blogs. I’ve added the TinyMCE editor to my application because I want to have a rich editor. I downloaded the scripts from the TinyMCE site and added them to the scripts folder in my project. Next I added the following markup above my form:

<script type="text/javascript" src="scripts/tiny_mce/tiny_mce.js"></script>
<script type="text/javascript">
    tinyMCE.init({
        mode : "textareas",
        theme : "simple"
    });
</script>

This enables the rich html editor on my page and running the page in the browser now looks like this:

Now any in the description field will fail with the same server error we saw above when pressing the submit button. This is because the fancy effects of being able to bold, strike through and underline you see in the example above happen because the field contains html. I need someway of turning off the validation for just this one field. Older versions of ASP.NET have had ways of turning this off:

ASP.NET 1.1 – ASP.NET 3.5 SP1:

In Web Forms you can add the following page directive: <%@ Page validateRequest="false" %>

In MVC you would place the following attribute on the action method for your controller: [ValidateInput(false)]

But these are not a good solution because they turn off Request Validation for the entire page! If I had other fields on the page for example a <input type=”text” name=”name”/> field in which I do not want to allow html or script input it is no longer protected because I’ve turned off request validation for the whole page. Now I need to manually validate the input for each field to make sure the input is safe.

ASP.NET 4:

We made Request Validation even stronger by making it happen earlier in the request pipeline. This meant that even low level ASP.NET components called Handlers and Modules could be protected. But because we are validating input so early you can no longer turn it on or off at the page level. If you had pages that needed to support html input you had to disable the .NET 4 mode and re-enable the .NET 1.1/2.0 mode using settings in the web.config file.

The Future: Web Pages, MVC 3 and in the next framework Web Forms:

Clearly we needed a much better solution. I should be able to turn off the request validation just for the fields that need to support html type input. While building Web Pages we were able to keep both the additional security we enabled in .NET 4 and support this using the new Validation.Exclude method. Here is how I add support for this by adding it to the top of my page:

@{
    Validation.Exclude("description");
}

You can pass multiple fields or if you want to disable Request Validation for the entire page you can call Validation.ExcludeAll. Now if I run the page in the browser you will see this:

You might be asking yourself why does the text in the rich html editor look one way and when I display in the page does it look different? We have just run into another security feature that ASP.NET razor syntax has, whenever we output values we automatically encode them:

Your description is: @Request["description"]

The value of @Request[“description”] is automatically html encoded. This again is an example of security being on by default so if values containing html or script are output the browser will not execute the html/script. If the developer knows that the data they are outputing is valid they can create a special type called an HtmlString and return the value of that which will not be automatically encoded. Here is the changed code in my sample:

@if (IsPost) {
    var desc = new HtmlString(Request["description"]);
    <div>
        Your description is: @desc
    </div>
}

Now I’m grabbing the value of the Request and creating a new HtmlString with that value. HtmlString is a special type that ASP.NET does not encode when it is output. Now running my page I will get the output I expect:

In this blog post I’ve covered a lot of topics but to recap:

- Web Pages validates input by default for security
- Web pages allows this validation to be disabled on a field by field basis
- Web pages encodes output by default for security
- Web pages allows output to be put into an HtmlString which allows it to be output with encoding

I hope to post about more Web Pages features soon…

GridView with Sort Arrows and Showing Header When Empty

Scott H — Sun, 29 Aug 2010 02:02:04 GMT

One of the common things people want to do when displaying data with grid controls is to have the little up and down arrows next to the header columns to indicated what direction the data is being sorted in. You see this in Windows Explorer and many other programs. This has been traditionally something that is difficult to do with the GridView control in ASP.NET. If you search the internet you will find a variety of hacks to do this:

Matt Berseth: Building a VS2008 Styled Grid with the GridView Control

4 Guys From From Rolla.com: Improving the Sort Arrows GridView Control

Some of these implementations have various limitations such as they don’t work if you use AutoGenerateColumns = true. In .NET 4 we addressed these problems by adding a couple of new properties to the GridView:

These allow you to easily set specific styles on both the header cells and the item cells of the GridView. Here is an example of this put to use in a GridView:

        1: <asp:GridView ID="GridView1" runat="server" AllowSorting="True" DataSourceID="EntityDataSource1" PageSize="5">

       2:     <SortedAscendingHeaderStyle CssClass="sortasc" />

       3:     <SortedDescendingHeaderStyle CssClass="sortdesc" />

       4: </asp:GridView>

What this does in when the grid is being sorted the header of the grid the sortasc or sortdesc class will be applies to the header cell like this depending on the direction it is being sorted on:

<th style=”sortasc”>Column Header</th>

<th style=”sortdesc”>Column Header</th>

And I’ve got some simple CSS defined that will apply a sort arrow:

       1: th.sortasc a  

       2: {

       3:     display:block; padding:0 4px 0 15px; 

       4:     background:url(img/asc.gif) no-repeat;  

       5: }

       6:  

       7: th.sortdesc a 

       8: {

       9:     display:block; padding:0 4px 0 15px; 

      10:     background:url(img/desc.gif) no-repeat;

      11: }

The end result will look like this showing the grid sorting each direction on the LastName column with nice arrows showing the direction.

I’ve created a sample of this you can download and try out: http://www.cshonline.com/aspnet/gridsortarrows.zip.

Another common request for the GridView deals with how it displays when there is no data. It basically does not display at all. You will basically see a set of empty <div></div> tags in the page. There is a template inside the Grid that you can use to display some text:

       1: <EmptyDataTemplate>

       2:     Empty GridView

       3: </EmptyDataTemplate>

But a lot of the time what you really want is to display the header row of the Grid showing what COULD be displayed. Once again if you search around the Internet you might find hacks to show the header. Once again because this was a common ask we added support for this in .NET 4. You can now use the ShowHeaderWhenEmpty property to show the header. Here is what the markup would look like:

       1: <asp:GridView ID="GridView1" runat="server" DataSourceID="EntityDataSource1" ShowHeaderWhenEmpty="true">

       2: </asp:GridView>

And here is what a GridView would display with no data with this property enabled:

Hopefully all of these new options will make using the GridView easier. Enjoy!

PersistedSelection in Data Controls in .NET 4

Scott H — Fri, 27 Aug 2010 04:55:01 GMT

We did a variety of small feature items across the data controls when we were working on .NET 4 and I’m going to do a couple of blog posts on some of this new functionality. When we were building Dynamic Data we made small enhancements to the data controls but they only worked when you were using Dynamic Data. In .NET 4 we took this functionality and made it work across all of our core data controls.

Persisted Selection

When using our data controls that support paging like GridView and ListView there is some funky behavior today. If the user selects the first row of data and then moves to the next page the first row of the data is selected. This behavior seems weird, especially when you are in a master detail scenario where you show the details of the selected row on the same page. As you page through your data the detail view would keep changing as you move from page to page. Here is what the old behavior looks like:

You can see in the first image that the second row is selected.

As I move to the second page the second row which is a different user is selected. This is probably not what a user would expect when using the controls. Now I’m going to enable a new property on the control called EnablePersistedSelelection and set it to true.

        1: EnablePersistedSelection="true"

And now we can look and see what the behavior looks like:

You can now see that I select Scott Hunter in the first page.

And move to the second page and no row is selected.

but moving back to the first page Scott Hunter is still selected. This should make master / detail view work better we think this is the behavior that someone would expect when using the control anyways.

Automatically prepopulate fields for Insert in .NET 4

Scott H — Thu, 26 Aug 2010 07:35:00 GMT

We introduced a lot of little data enhancements in .NET 4 that you may not have heard about. One of these is a mechanism for setting the default value of fields in a data control when you want to do an Insert. In our controls today you would probably do something painful:

- Handle the ItemCreated event and inside the event you can call FindControl and find the control for each column manually and set the value on the control using whatever property it supports to set its control.

- Handle the Inserting event on the data source control (if you are using one) and check to see if fields have values and if not set the default. This is problematic because this happens after the user has pressed Insert so they do not see the default value until AFTER the insert operation.

One of the features we enabled in .NET 4 was the ability to enable Dynamic Data functionality with a single line of code in an existing web page. By enabling Dynamic Data you can easily use some of its features to make this super simple.

In my example I’ve got a table called Contact which has an Id, FirstName, LastName and Age fields. I’ve created an Entity Framework model around my database giving me rich classes for the tables in my database. Here is what my page markup looks like:

<asp:DetailsView ID="DetailsView1" runat="server" Height="50px" Width="125px" 

    AutoGenerateRows="True" DataKeyNames="Id" DataSourceID="EntityDataSource1" 

    DefaultMode="Insert">

    <Fields>

        <asp:CommandField ShowInsertButton="True" />

    </Fields>

</asp:DetailsView>

<asp:EntityDataSource ID="EntityDataSource1" runat="server" ConnectionString="name=DatabaseEntities" DefaultContainerName="DatabaseEntities" EnableFlattening="False" EnableInsert="True" EntitySetName="Contacts">

</asp:EntityDataSource>

And here is what my code behind markup looks like:

DetailsView1.EnableDynamicData(typeof(DatabaseModel.Contact));

var contact = new DatabaseModel.Contact();

contact.FirstName = "Scott";

contact.LastName = "Guthrie";

DetailsView1.SetMetaTable(DetailsView1.GetMetaTable(), contact);

My code is doing a couple of items here:

1: Enabling Dynamic Data functionality for the data control passing it the type of data the control is hosting. This is the object from my Entity Framework model.

2 – 4: Creating a dummy record of Contact and filling in the fields with whatever data I want to use for my defaults.

5: Calling the SetMetaTable method on the data control passing the MetaTable which I get from the GetMetaTable method on the control and then passing my object that contains the default values.

Now if I run my page I will get the DetailsView to show up with my defaults automatically set. Note in my example I’m using auto generated columns. If you choose to manually specify your columns you will need to specify them using either DynamicField (DetailsView/GridView) or DynamicControl (FormView/ListView) for this functionality to work because these types inject Dynamic Data fields templates which allow this insert functionality to work.

Also you can also specify the defaults using a dictionary if you don’t want to create a full object. Here is an example of what that would look like:

DetailsView1.EnableDynamicData(typeof(DatabaseModel.Contact));

var contact = new Dictionary<string, object>() {

    {"FirstName", "Scott"},

    {"LastName", "Guthrie"}

};

DetailsView1.SetMetaTable(DetailsView1.GetMetaTable(), contact);

I’ve created a fully running sample of this you can download as well. The sample requires .NET 4, VS 2010 and SQL Express 2008 to be installed to run. Here is the link the sample: http://www.cshonline.com/aspnet/insertdefaults.zip

Program Manager Position on the ASP.NET PM team

Scott H — Mon, 23 Nov 2009 22:14:00 GMT

Are you interested in making a change? Do you want to join a fast moving team inside of Microsoft and help drive the future features in ASP.NET?We have a program manager position on the ASP.NET team which is currently available. You can access the listing here: ASP.NET PM Position. We are looking for someone that is interested in driving the data strategy on our team which includes partnering with LINQ and SQL teams, is into web standards around HTML, CSS and JavaScript and making ASP.NET work better with these standards and much much more. Please check out the listing if you are interested.

Data Enhancements in .NET 4 / Visual Studio 2010 Beta 2

Scott H — Wed, 21 Oct 2009 06:40:14 GMT

On Wednesday we are releasing .NET 4 / Visual Studio 2010 Beta 2 to the public and it brings many cool enhancements to the ASP.NET data controls and Entity Framework. I’m going to drill into a few features of these data related features and you can read more about all the changes to ASP.NET 4 at: http://www.asp.net/learn/whitepapers/aspnet40/. This contains a very detailed list of all the changes we have made in ASP.NET.

Here are a couple of my favorite “data” related features:

1) The Entity Framework now supports the ability to the ability to pluralize entity sets and singularize entities. This means when I refer the table the table will be called “Products” but the actual class that I work on in my application is a “Product”. This feels much more natural then Entity Framework 1 where I would write:

Products product = new Products();

while in 4.0 this becomes:

Product product = new Product();

which feels more natural and looks better in my code.

Here is the UI in the Entity Model Wizard for enabling this (note it turned on by default)

2) The Entity Framework now supports the ability to include “foreign keys” in the data model. In version 1 of the Entity Framework if I had a Product table that contained a CategoryID which referenced a record in the Category table the generated Entity Framework model would convert the CategoryID into a navigation property which would drill directly in the category table. While this simplified some scenario’s it made web scenarios more difficult. Normally I would represent the this in using a DropDownList control which would contain the primary key and the name of the records from the category table. When saving saving the record I would just want to assign the selected CategoryID from the DropDownList to the Product class. But with navigation properties I would have to revert to some very ugly and non-discoverable code for setting the CategoryID since it not exist. Entity Framework 4 now includes the ability to have foreign key columns added directly to the entity allowing me to either set the foreign key or the navigation property making web scenarios easier to program:

EF 1.0 EF 4.0

3) QueryExtender support is now available for EntityDataSource. In .NET 4 Beta 1 and in the Dynamic Data Preview releases on CodePlex we introduced a very exciting extender control for the LinqDataSource called the QueryExtender. We created this control in response to feedback we received after releasing Dynamic Data 1.0 that our customers wanted an easy way of filtering or searching the data that their data source controls returned aka “How do I implement a search”. This pattern with data source controls can get fairly complicated and we wanted to provide something simple. The QueryExtender allows the following types of searches:

Search: Searched for a string across any number of columns

Range: Filters data based on if the value of a column is between a given range

Property: Filters based on a column matching a value

Custom: Event is fired in which the developer can customize the LINQ expression.

Here is an example of using the QueryExtender with the EntityDataSource. It takes the value from TextBox1 and uses compares it to the ProductName field and only returns rows which have the text from TextBox1 in the ProductName field:

<asp:EntityDataSource ID="EntityDataSource1" runat="server"
        ConnectionString="name=NORTHWNDEntities"
        DefaultContainerName="NORTHWNDEntities" EnableDelete="True"
        EnableFlattening="False" EnableInsert="True" EnableUpdate="True"
        EntitySetName="Products">
</asp:EntityDataSource>
<asp:QueryExtender ID="QueryExtender1" runat="server" TargetControlID="EntityDataSource1">
    <asp:SearchExpression SearchType="Contains" DataFields="ProductName">
        <asp:ControlParameter ControlID="TextBox1" />
    </asp:SearchExpression>
</asp:QueryExtender>

4) EnableDynamicData extension method. We introduced Dynamic Data in .NET 3.5 SP1 but it put some serious demands on the developer: Required the developer to be using Linq to SQL or Entity Framework, Required the developer to start a new project to get the Dynamic Data support files, Provided a different programming model. With Beta 2 we have added this new feature which can be enabled on our data controls like this:

ListView1.EnableDynamicData(typeofProduct))

This one line of code will automatically bring many of the features that Dynamic Data provides:

- Automatic validation

- Support for Data Annotations on objects to control validation and display properties

- Support for field templates for customizing UI behavior based on data type

This should allow any developer to utilize the power of Dynamic Data without radically changing their application or requiring Linq to SQL or Entity Framework.

There are many other changes and updates to our data support and I will try and blog about it over the next few weeks.

Dynamic Data Preview 4 Released

Scott H — Thu, 07 May 2009 11:29:39 GMT

Today we released the newest preview release of Dynamic Data. You can view the details and download this release from here: http://aspnet.codeplex.com/Release/ProjectReleases.aspx?ReleaseId=27026.

The preview releases of Dynamic Data contain much of the new feature sets that will be available when we release .NET 4. The cool thing is you can start using a lot of the new features against .NET 3.5 SP1 now using these releases.

When we look back and see how people view Dynamic Data we regret that people immediately think of it as scaffolding of data. This is something that it does do, and I think it does a pretty good job at it. But Dynamic Data is a lot more then that, providing a new templating mechanism called Field Templates which allow the default markup for many of our built in data controls to be more easily customized. These field templates also support validation by default (something our rich data controls did not) which can be customized by adding metadata to data objects.

In the past to enable Dynamic Data functionality in a web application the application needed to follow a couple of rules:

- It had to have a data model such as Entity Framework or Linq to SQL

- The data model had to be registered at startup in Global.asax

- The DynamicData directory had to exist in the web application

One of the new features this new preview release supports is adding field templates and validation to any ASP.NET web page without having to meet these requirements. It is as simple as:

GridView1.EnableDynamicData(typeof(Product));

What does this do for you? Today a control like GridView supports all kinds of high level features such as paging, sorting, viewing, editing but it provides no validation of data at all. So if your database has an integer field the end user would be able to type any data they wanted and when saving the record an ASP.NET yellow screen of death screen would appear (on the development box) saying that the data could not be converted to an integer. By enabling Dynamic Data automatic validation will occur because validation is built into the field templates that would render the column and a nice error message will appear in the page saying “Field XYZ must be an integer”.

To see this in action download the preview release and try out the SimpleDynamicDataSample.

ASP.NET 4.0 and Visual Studio 2010 Development Overview & Dynamic Data

Scott H — Mon, 23 Mar 2009 18:47:10 GMT

Last week at the Mix conference in Las Vegas we released a whitepaper that contain a list of many of the items that we are adding to ASP.NET 4.0 and Visual Studio 2010. The paper provides an overview of what we expect to be in the first beta release (do not ask for timeframes as we do not have a published date yet). You can view the whitepaper here in both HTML and download form: http://www.asp.net/learn/whitepapers/aspnet40/

Lasr week we also released a new preview of Dynamic Data. You can download the preview 3 of Dynamic Data from this link: http://aspnet.codeplex.com/Release/ProjectReleases.aspx?ReleaseId=24887. This preview really rocks and contains the QueryBlockExtender mentioned in the whitepaper above it also includes a new DomainDataSouce for accessing business layers that are created from the new .NET RIA Services CTP that was also released at Mix. Check it out and I hope to blog on it soon.

Today I will be speaking at DevConnection in Orlando, FL on Data Access and WebForm improvements in 4.0. If you are at the show the two talks are:

2pm: AMS06: ASP.NET 4.0 Data Access Patterns for Success with Web Forms

3:45: AMS08: ASP.NET Web Forms 4.0

Hope to see you there!

Better support for 3rd party controls and Dynamic Data in ASP.NET 4.0 and DevExpress Grid and Dynamic Data

Scott H — Tue, 10 Mar 2009 11:50:20 GMT

One of the things that we worked on supporting in Dynamic Data is the ability for third party controls like Grids to be able to host DynamicControls. Basically allowing the developer to use controls that are fancier or have more features then the stock controls in ASP.NET with Dynamic Data.

For the first version of Dynamic Data we tried we ran into various limitations because it was delivered in a service pack which limited what type of changes we could make in the framework. Basically we were able to add new API’s but had little ability to change existing API’s.

One of the limitations this placed on controls was that to support Dynamic Data they would need to derive from DataBoundControl because there were no interfaces that controls could implement to indicate that supported basic data binding operations. Some control vendors want to be able to derive their controls from Control to make them as lightweight as possible and to have the best performance.

To solve this in .NET 4.0 we are adding new interfaces that controls can implement that indicate that they do databinding and also indicate whether the control displays a single item or a list of items. Here is a breakdown of the new interfaces:

public interface IDataBoundControl	Interface for accessing the common properties for data bound controls.
string DataSourceID { get; set; }	Gets or sets the ID of the control from which the data-bound control retrieves its list of data items.
IDataSource DataSourceObject { get; }	Gets the actual data source control when DataSourceId is set.
object DataSource { get; set; }	Gets or sets the object from which the data-bound control retrieves its list of data items.
string[] DataKeyNames {get; set; }	Gets or sets an array that contains the names of the primary key fields for the items displayed in a control.
DataBoundControlMode Mode { get; }	Gets whether the control is in ReadOnly, Edit or Insert mode.
string DataMember { get; set; }	Gets or sets the name of the list of data that the data-bound control binds to, in cases where the data source contains more than one distinct list of data items.

public interface IDataBoundListControl	Interface for data bound controls that display multiple rows and can selection.
DataKeyArray DataKeys { get; }	Gets a collection of DataKey objects that represent the data key value of each row in a GridView control.
DataKey SelectedDataKey { get; }	Gets the DataKey object that contains the data key value for the selected row in a GridView control.
int SelectedIndex { get; set; }	Gets or sets the index of the selected row in a GridView control.
string[] RowClientIDSuffix { get; set; }
bool EnablePersistedSelection { get; set; }	Gets or sets whether the selection is based on index or on data keys.

IDataBoundItemControl	Interface for data bound controls that display a single item.
DataKey DataKey { get; }	Gets a DataKey object that represent the data key value of the row in a control.

IFieldControl	Interface for data bound controls that can automatically generate their fields based on data.
IAutoFieldGenerator FieldsGenerator { get; set; }	Gets and sets the IAutoFieldGenerator which generates the fields.

IDataBoundControl is implemented by a control to indicate that it support data binding. This includes datasources, primary keys and the mode the control operates in. IDataBoundListControl indicates a control that displays data in a list and supports selection. IDataBoundItemControl indicates a control that displays a single record at a time. And IFieldControl is for controls like GridView or DetailView that have the ability to autogenerate their columns. These new interfaces are implemented across all the standard data controls in 4.0 including ListView, GridView, DetailsView and FormView. If third party controls support these interfaces they will be usable with Dynamic Data.

One of the control vendors DevExpress has recently implemented Dynamic Data support without these interfaces in their grid control. Here is a very cool screencast by Mehul Harry that demonstrates their grid and Dynamic Data in action. With these new interfaces they will be able to support their spreadsheet control as well once 4.0 ships. View the screencast here: http://community.devexpress.com/blogs/aspnet/archive/2009/02/01/asp-net-dynamic-data-and-devexpress-grid.aspx. Please check it out and let Mehul know what you think!

Update for .NET 3.5 SP1 Released

Scott H — Tue, 30 Dec 2008 22:24:08 GMT

There was an update to the .NET 3.5 SP1 release a couple of days ago and I have not seen a lot of mention to it so thought I would write a blog post and talk about how this update affects ASP.NET.

First off you can search for KB959209 in the Microsoft knowledge base for details on this update. Here is the direct URL to the article: http://support.microsoft.com/kb/959209.

This update corrects the following issues that may affect an ASP.NET developer that has .NET 3.5 SP1 installed:

- Dynamic Data used with Entity Framework generates an error when navigating one to one relationships

- BrowserCaps generates an error if Front Page Server extensions are installed.

- Using a derived UpdateProgress control may encounter an exception.

- An exception is thrown if the website is using WPF to generate images and the site is hosted under IIS.

There are other issues that are fixed in the framework and CLR that could affect applications so I suggest reading the list of changes in the knowledge base.

If you are using Dynamic Data and Entity Framework then I highly recommend this update.

Posting from Oredev in Sweden

Scott H — Fri, 21 Nov 2008 17:56:38 GMT

Eilon Lipton and I have spent the week in Malmo, Sweden at the the Oredev conference. Here is the schedule of our talks:

November 19th – Get to Know the ASP.NET MVC Framework

November 20th – ASP.NET 4.0 Roadmap

November 20th – Advanced ASP.NET MVC

November 21st – ASP.NET Dynamic Data

Jonathan Carter has posted a great series of blogs posts on Dynamic Data. Check them out here:

Dynamic Data: Come For The Scaffolding, Stay For Everything Else
Dynamic Data: Kickin’ It Old School
Dynamic Data: Models, MetaModels And Everything In Between
Dynamic Data: The Little MetaModel That Could

Securing Dynamic Data

Scott H — Thu, 06 Nov 2008 02:42:54 GMT

One of the questions we often get is how do you secure Dynamic Data websites. Michael Miele one of the technical writers that writes the documentation for ASP.NET wrote a great sample that shows how to do this using Form Authentication and Roles that are provided in ASP.NET. We uploaded his sample to the Dynamic Data Samples Site last night and I thought I would share it out. Click HERE to go to the sample page and scroll down to the section “Secure Dynamic Data”. Enjoy!

PDC ASP.NET Content Available Now

Scott H — Mon, 03 Nov 2008 21:37:02 GMT

Just got back from PDC 2008 last week, we showed all kinds of cool new stuff. Here is a list of links for the videos of all the ASP.NET sessions:

ASP.NET 4.0 Roadmap - http://channel9.msdn.com/pdc2008/PC20/

ASP.NET MVC: A New Framework for Building Web Applications - http://channel9.msdn.com/pdc2008/PC21/

Microsoft Visual Studio: Web Development Futures - http://channel9.msdn.com/pdc2008/TL48/

Web Application Packaging and Deployment - http://channel9.msdn.com/pdc2008/ES15/

ASP.NET Dynamic Data - http://channel9.msdn.com/pdc2008/PC30/

ASP.NET: Cache Extensibility - http://channel9.msdn.com/pdc2008/PC41/

We also released new preview bits of Dynamic Data for PDC. You can check out the new bits from here: Dynamic Data Preview 1.

I’m also excited that David Ebbo has blogged an early version of support for many to many relationships in Entity Framework for Dynamic Data. You can see grab the code and use it with today's Dynamic Data. You can view the post: HERE.

Image Generation is released to CodePlex

Scott H — Fri, 22 Aug 2008 00:32:55 GMT

I'm really happy to announce that earlier this week we released a new feature called Image Generation to the ASP.NET CodePlex site. You can get a link directly to the page supporting this feature by clicking on: http://www.codeplex.com/aspnet/Wiki/View.aspx?title=WebForms&referringTitle=Home.

There was a feature that was in Beta 1 for Visual Studio 2005 (Whitbey) called DynamicImage that provided a control for generating images and an image service for serving them. This feature was sadly cut because some of the other parts of the framework it depended on were cut.

Image Generation is basically work to bring this type of feature back into the framework. Here are some of the highlights of what this new feature does:

New GeneratedImage ASP.NET control. This control is a derivative of asp:Image control that supports being hooked up to an Image Handler and passing parameters to it. If you put this control on a page and go into design mode it will have chrome attached to it that when clicked will automatically generate an ImageHandler and wire the control to the URL of the ImageHandler. Parameters such as the primary id and timestamp can be databound to the control and will automatically be passed to the handler.

ImageHandler which is an implementation of IHttpHandler that provides support for many image based things:

Transforms (resizing, watermarks, user defined transforms)
Client-side caching
Server side caching
Access to parameters passed from the GeneratedImage control
Provide simple mechanics for returning images

If you click to the site there are three samples of how to use GeneratedImage:

Simple Generated Image - this shows how you would create a simple bitmap and return it
Databased Images - shows how you would use this feature to display images that are stored in a database
Custom Image Transforms - shows how to write a custom image transform that adds a ASP.NET logo to an image

We are considering adding this feature in the next version of .NET and would love feedback. Please download and try and it out and let us know what you think!

Workaround for Dynamic Data Entity Framework Posted

Scott H — Sun, 17 Aug 2008 01:49:12 GMT

Today we posted a beta update to solve a couple of problems with Dynamic Data and Entity Framework that are in the RTM version of .NET 3.5 SP1. The main issue is a slight mis-match in the names that Dynamic Data looks for in Entity Framework and the names that Entity Framework is actually exposing. When this problem occurs an error that looks like "A property with name 'XX.Id' does not exist in metadata for entity type 'XX.XX.XXXX'".

Luckily we made the data model providers which are classes that look at data model and tell Dynamic Data what the tables, columns, names, etc are a extensible system. This means we can distribute a replacement data model provider that solves the issue I mentioned above. You can download a replacement Entity Framework provider at this link: http://www.codeplex.com/aspnet/Release/ProjectReleases.aspx?ReleaseId=16367

If you are running into this issue please download the fix above and let us know if it solves your issues.

Dynamic Data RTM is Released!

Scott H — Mon, 11 Aug 2008 19:44:31 GMT

Today we shipped .NET 3.5 SP1 which includes Dynamic Data. This means that the Dynamic Data RTM release is now available. Here are the links to download the final versions:

Visual Studio 2008 SP1 (also includes .NET 3.5 SP1): http://www.microsoft.com/downloads/details.aspx?FamilyId=FBEE1648-7106-44A7-9649-6D9F6D58056E&displaylang=en

.NET 3.5 SP1 Standalone Installer: http://www.microsoft.com/downloads/details.aspx?FamilyId=AB99342F-5D1A-413D-8319-81DA479AB0D7&displaylang=en

You can also preview some of the upcoming changes and new features we are working on for Dynamic Data 2.0 and Dynamic Data MVC. You can view these on our page on the Codeplex site. You can view the ASP.NET page on Codeplex here: http://www.codeplex.com/aspnet. Click the Dynamic Data link to see all of our preview releases.

Many Updates on Dynamic Data

Scott H — Mon, 21 Jul 2008 19:26:01 GMT

This week at Redmond we have the ASP.NET Insiders up here where we show them a bunch of the new stuff we are working on. I'm happy to announce that we have many new update for Dynamic Data that are available today:

1) Dynamic Data Runtime and Dynamic Data Wizard - this has been updated with a much newer version of the Dynamic Data Wizard which have over 30 bug fixes. This is a wizard that provides many options for which tables to show, which modes to show them (read only/read write, etc) and allows multiple tables in the same page. All of the generated code uses features from the new Dynamic Data feature.

2) Dynamic Data Futures - this is a sample project that shows off many of the cool directions we are looking at for the next version of Dynamic Data. An example of some of these features are: ADO.NET Data Services (formerly known as Astoria), ObjectDataSource, binding and validation for plain old CLR objects (POCO), metadata for ordering columns, adding metadata at runtime, support for images, advanced filtering including cascading and much more.

3) Dynamic Data for MVC Preview - we are working to support Dynamic Data on the new ASP.NET MVC framework as well. This is an EARLY release of this support. Compared to the WebForm version this has the current limitations: Only supports Linq to SQL, does not have client side validation and does not have filters on the list pages. Futures releases will address each of these items plus provide much more.

Interview with Craig Shoemaker Posted

Scott H — Tue, 01 Jul 2008 20:30:11 GMT

Last week I had a great chat with Craig Shoemaker on Dynamic Data. We talked about using Dynamic Data in existing applications, some about our new Futures release and some about upcoming work on having an MVC version of Dynamic Data. You can check out the interview on Pixel8 by clicking here: Craig Shoemaker interview

How to add Dynamic Data to an Existing Web Application

Scott H — Tue, 24 Jun 2008 11:18:50 GMT

Yesterday I posted about how to add Dynamic Data to an existing website and I got some feedback about how to add Dynamic Data to an existing web application. Web application projects work a little different the website projects, you can check out the differences here: http://msdn.microsoft.com/en-us/library/aa730880(VS.80).aspx.

1) Create a dummy Dynamic Data web application project. Copy the DynamicData directory from it into your existing web application. You should also copy the Site.css and Site.master files. The Default.aspx file is optional, it display a menu of tables in your data model, this file is only needed if you plan on having such a menu in your application. IMPORTANT: Web application projects have namespaces in their code behind files, you may want to change the namespaces of the copied in files to match the namespace of your existing project.

2) You can copy the Global.asax file or if you already have such a file you can just add the model registration and url routes as below to the

<%@ Import Namespace="System.Web.Routing" %>
<%@ Import Namespace="System.Web.DynamicData" %>

void Application_Start(object sender, EventArgs e) {

MetaModel model = new MetaModel();

model.RegisterContext(typeof(YourDataContextType), new ContextConfiguration() { ScaffoldAllTables = false });

routes.Add(new DynamicDataRoute("{table}/{action}.aspx") {
Constraints = new RouteValueDictionary(new { action = "List|Details|Edit|Insert" }),
Model = model
});

}

3) Right click on the References node in the solution explorer and select "Add Reference". In the dialog that opens up you need to select System.ComponentModel.DataAnnotations, System.Web.Abstractions, System.Web.DynamicData and System.Web.Routing.

4) In the <compilation> section in web.config add the following assemblies:

5) In the <pages>/<controls> section add the following new tag prefix:

6) Enable the new ASP.NET Routing feature:

IIS 5/6/Casini

In the <httpModules> section add the following new module:

IIS 7

In the <system.webServer>/<modules> section add the following:

In the <system.webServer>/<handlers> section add the following:

At this point Dynamic Data should be functional. To enable it see the steps at the bottom of yesterdays post.

How to add Dynamic Data to an Existing Web Site

Scott H — Mon, 23 Jun 2008 11:07:02 GMT

I've had various people ask me if Dynamic Data can be added to an existing website and I've compiled a list of steps to do this. We hope to add a tooling gesture to Visual Studio in the future to automatically do these steps. Once these steps are complete you can start taking advantage of Dynamic Data functionality in your existing applications.

1) Create a dummy Dynamic Data Website project. Copy the DynamicData directory from it into your existing website. You should also copy the Site.css and Site.master files. The Default.aspx file is optional, it display a menu of tables in your data model, this file is only needed if you plan on having such a menu in your application.

2) You can copy the Global.asax file or if you already have such a file you can just add the model registration and url routes as below to the

<%@ Import Namespace="System.Web.Routing" %>
<%@ Import Namespace="System.Web.DynamicData" %>

void Application_Start(object sender, EventArgs e) {

MetaModel model = new MetaModel();

model.RegisterContext(typeof(YourDataContextType), new ContextConfiguration() { ScaffoldAllTables = false });

routes.Add(new DynamicDataRoute("{table}/{action}.aspx") {
Constraints = new RouteValueDictionary(new { action = "List|Details|Edit|Insert" }),
Model = model
});

}

3) In the <compilation> section in web.config add the following assemblies:

4) In the <pages>/<controls> section add the following new tag prefix:

5) Enable the new ASP.NET Routing feature:

IIS 5/6/Casini

In the <httpModules> section add the following new module:

IIS 7

In the <system.webServer>/<modules> section add the following:

In the <system.webServer>/<handlers> section add the following:

At this point you need to register your Linq to SQL data modelin step #2 and optionally enable scaffolding by setting ScaffoldAllTables := true in the registratoin line. At this point if you copied the Default.aspx from the dummy Dynamic Data application you can execute it to view the scaffold. You can also enable Dynamic Data in existing web pages that use GridView, ListView, FormView and DetailsView by adding a DynamicDataManager to those pages and then registering the data control with the dynamic data manger:

<asp:DynamicDataManager id="DynamicDataManager1" runat="server">

<asp:GridView id="GridView1" runat="server">

...

DynamicDataManager1.Register(GridView1);

Inside of your GridView or DetailsView you can either use AutoGenerateColumns or you can use DynamicField controls in your column collections. If you are using ListView or FormView use DynamicControl to display values for each of your columns.

Dynamic Data DbImage SampleUpdated

Scott H — Tue, 17 Jun 2008 12:07:46 GMT

I posted a sample back in January on how to display images from databases or the file system using Dynamic Data. You can view that post HERE. I've just updated that sample to fix some bugs and add some new functionality. You can download the latest version of DbImage from this link: DOWNLOAD DBIMAGE.

Here is a list of the changes and updates I've made since the original post:

1) Fixed an issue that caused DbImage not to work when the primary column for the table is a GUID.

2) Added support for compound primary keys (primary key that is more then one column in the table).

3) Added support for Entity Framework (previous release would display images in Entity Framework but fail to update them).

4) The asp:FileUpload control does not work correctly inside of UpdatePanels with partial rendering turned on. By default the templates in Dynamic Data are enclosed in UpdatePanels with partial rendering turned on. This means that uploading of images will fail unless partial rendering is disabled. The new sample adds a helper method call in the Page_Init of the Insert, Edit and ListDetails page templates. This helper call looks to see if any of the displayed columns are DbImage columns and if so turns off partial rendering for the page.

DbImageAPI.ImageHelper.DisablePartialRenderingForUpload(this, DetailsDataSource.GetTable());

Dynamic Data is on .NET Rocks!

Scott H — Tue, 10 Jun 2008 23:54:27 GMT

A few weeks ago I did an interview with Carl and Richard from .NET rocks on Dynamic Data. You can listen to it here: http://www.dotnetrocks.com/default.aspx?showNum=349.