Life Before IIS Express

If you are an ASP.NET developer, you have two options for testing your sites against a web server prior to IIS Express:

• IIS Web Server — the one that comes with Windows
• Visual Studio’s built in ASP Development Web Server

There’s nothing really wrong with either one, but as a web developer your needs may actually cross the capabilities of the two put together.

As Scott Gu says on his blog introducing the new Express version of IIS, many developers have said: “I wish I could have the ease of use of the ASP.NET Development Server, but still have all the power and features of IIS.”

And this is what IIS Express does, combines the best of both web servers into one that is free and works with bothVisual Studio 2010 and Visual Web Developer Express 2010.

IIS Express

The ASP Development Server does not support the full capabilities of the IIS Web Server, but getting your IT department to let you install and run the IIS Web Server on your desktop could be an exercise in futility as it could be considered a potential security problem.

Now you can have a web server that is easy to setup and install, won’t freak out the IT department and offers a full set of IIS web server functionality.  A few other nice features:

• It doesn’t require an Admin account to run and debug applications from Visual Studio
• It can be installed side-by-side with either the IIS Web Server or the ASP Development Server
• It works with Windows XP and up

IIS Express

Gu says that IIS Express will be configured to run with Visual Studio 2010 as an alternative web server. So you won’t have to configure it to run your websites, just hit F5 and go.

A public beta is expected sometime soon and a patch for both Visual Studio 2010 and Visual Web Developer Express 2010 will come at the end of the year that support IIS Express.

My first thought when I read about this new web server, was that many IT organizations are going to be happy. They can now provide their development teams with strong Web Server capabilities without opening the door to potential security breaches.

My second thought, will it have all the nice add-on capabilities that IIS 7 offers like the SEO toolkit and the Media Services?

A Redesigned Web CMS for Everyone

Martin Kirov, executive vice president of Sitefinity at Telerik told us that for the last two years, Telerik has had the biggest team working on Telerik Sitefinity 4.0. Completely rebuilt from the ground up, the latest version of this Web CMS was designed to increase developer productivity (and in turn the ability to easily develop 3rd party components), and to provide the business user with a user experience that is focused on the essentials.

Task Oriented UX

The back-end — or administration/editorial — user experience in Sitefinity 4.0 has been streamlined, and new capabilities have been added to allow making changes without the need for a developer.

Editorial improvements are plenty in this new release, including:

• A new Forms Module which allows administrators to create forms via a drag and drop approach.
• An integrated web analyticsmodule.

Some of the administration improvements include:

• A new installation and upgrade process.
• Site configuration is now exposed via the UI and stored in XML files instead of config files.
• Store different configurations, or policies, for users, locations, roles.
• Change the language of buttons and labels.
• Admin Pages can be customized in a similar manner as front-end website pages. For example, a custom field can be added to store specific metadata information. This is done via a drag and drop experience.
• Permissions can be set on a content items or element on a page where it used to be set per page/module.
• The platform is now compliant with Section 508 and the WCAG 2.0.

Here’s an overview video of Telerik Sitefinity 4.0:

New e-Commerce Functionality

Telerik acquired their e-Commerce capabilities for 4.0 with the acquisition of Mallsoft. Mallsoft, a former Telerik partner, is a small 5-6 employee shop that built custom shopping cart technologies.

That functionality is in the process of being fully integrated with the Telerik Web CMS and all the employees are part of either the Telerik’s West Coast office in San Diego or the Development team in Bulgaria.

Extensibility a Key Element

One of the main reasons for the complete redesign of the Telerik Web CMS was, as I said earlier, to increase developer productivity, not just for Telerik developers, but for partners that create third party components for the Web CMS.

Probably one of the biggest enhancements is the ability to create custom workflows inVisual Studio (WWF integration) that support just about any defined business process. We were told that a custom workflow designer is in the works. Also, a new Widget Template editor provides improved widget controls layout and output modifications. There’s a good blog post on the Telerik website that gives you a look into the advanced workflow capability.

Technical Features

• Full support for the ASP.NET Web Parts Framework
  Web Parts Framework includes a set of controls and services that specifically target the growing demand for Web portal creation, including support for personalization, membership, communication and other infrastructural tasks. MonoX is built on top of the standard Web Part API.
• Commitment to standards
  MonoX renders XHTML compliant code and enables users to develop fully standards-compliant portals that will work reliably on different platforms.
• Unlimited design flexibility
  Developers can create user interface templates without any limitations, using their favorite approach (tables, DIVs, CSS, …). ASP.NET master pages, themes and templates are fully supported.
• Open API
  MonoX allows developers to access all of its back-end functionality through a comprehensive set of fully documented methods and events.
• Provider-based architecture
  An ASP.NET provider is a software module that provides a uniform interface between a service and a data source. Providers abstract physical storage media, in much the same way that device drivers abstract physical hardware devices. MonoX uses the provider model extensively, making it easy to add new functionality and interface with other ASP.NET applications.
• Support for localization
  All content and user interface elements can be localized at run time using only browser-based administrative tools. In addition to the standard .NET localization infrastructure, MonoX can store all localization resources in a portal database.
• Advanced module communication
  Developers can design sophisticated and elaborate Web part communication scenarios using the module communication support.
• Development flexibility
  All MonoX Web parts are in essence standard ASP.NET user controls. This allows developers to leverage their experience without the need to learn about new APIs and development environments. Controls are registered with the portal just by placing them in the module gallery folder. Additionally, there is an actual underlying file for each page, making it easy to customize the behavior of each portal page just like it is an ordinary ASPX page.
• Multi-portal environments
  Unlimited number of portals can be served from a single portal database.
• Advanced personalization infrastructure
  MonoX builds upon the personalization system that is integrated into ASP.NET 2.0, enabling users to personalize their working environment on both user and shared levels.

Content Management Features

• Browser-based administration
  All aspects of a portal can be managed through an online, browser-based interface.
• User friendly Web 2.0 interface
  MonoX provides modern and uncluttered Ajax-based user interface with intuitive look and feel. Web parts can be moved and edited using a convinient drag and drop interface.
• WYSIWYG approach
  A unique editor interface allows administrators to enter and update content “in-place” and to immediatelly see the results of their actions.
• Windows Live Writer support
  Microsoft Windows Live Writer is a free desktop application that makes it easier to compose compelling blog posts using numerous blog services. It features true offline WYSIWYG blog authoring and photo/map publishing. MonoX fully supports Windows Live Writer and other similar editing tools that recognize standard MetaWeblog API, not only for the blog publishing tasks, but also for more general portal editing and configuration actions.
• Content versioning
  All changes made on a portal page can be saved for later approval and publishing.
• RSS feed providers
  All content-based modules (HTML editor, news system) can automatically provide RSS feeds.
• Search Engine Optimization (SEO)
  MonoX includes powerful Search Engine Optimization (SEO) techniques that can help users place their portals very high on all major search engines: ViewState optimization, URL rewriting, HTTP compression, SiteMap generation, automatic META keywords generation, integration with Google Analytics, compact and standards-compliant output…
• Search infrastructure
  MonoX comes with numerous search providers that give you a total control over the portal search engine behavior and performance. Included are providers that search pages, news, blog posts, groups, user profiles and file system.
• Cloud data providers
  MonoX now includes a data provider that hooks into Amazon S3, allowing users to store their data in the cloud and not on a local database or file servers.

Social Networking Features

• User profiles
  Profiles are often used as a point of contact betwen users, and MonoX provides flexible architecture and modules to publish information about its users in a convinient way, respecting their privacy settings. You can choose between Gravatar service and local avatar repository to attach personal photos to profiles.
• Support for OpenID and RPX
  OpenID allows you to log-in to MonoX-based portals and applications without performing the time consuming registration process and remembering your credentials. RPX goes even further by integrating major online services, so you will be able to log in by using your credentials from Facebook, LinkedIn, MySpace and other major social networking systems.
• Friendship modules
  Different terms describe the “friendship” or “connection” concept for different community types, but in all cases it is the fundamental feature of all social networks. MonoX provides a flexible set of modules for displaying and managing user friend lists.
• Blog engine
  MonoX now includes a fully featured multi-user blog engine with support for comments, ratings, tagging and automatic anti-spam protection. Each user can have unlimited number of blogs, blog posts, tags and categories.
• Photo albums
  Each portal user can upload and organize photos using the album infrastructure. Thumbnails for common image file types are generated on the fly and stored on the server.
• Groups
  Groups allow users of your community to interact with each other around a common topic. Modules such as walls, forums, albums, file galleries can all be utilized in the group context.
• Discussion boards
  MonoX discussion boards allow users to easily post messages and comments to the community in a way that all the responses will be viewable no matter how much time passes between each post.
• Media galleries
  Many social networking sites are very dependant upon media galleries, as they could draw the large percentage of visitors back to the site. MonoX support a generic architecture that allows you to host videos, photos, resumes, or any other kind of physical files.
• Activity streams
  Users can track the activity of their friends and be instantly notified when somebody publishes an interesting blog post, uploads a photo, joins the community…
• Messaging
  Messaging is essential to all community sites as it allows users to communicate with each another (or a whole group) directly, resembling the look and feel of traditional mail clients.
• Video conversion and sharing
  In addition to standard media gallery functionality, MonoX supports third-party plug-ins for video conversion that allow users to upload any kind of video material and have it coverted to standard Flash formats.
• Walls
  Wall is a kind of virtual space on every user’s profile or group page that allows friends to post messages for other users to see. In essence, this is usually the central gathering point for all users of a community.
• Comments
  Comment modules allow your users to interact with the content and other members of your social network. Our flexible infrastructure enables administrators to attach comments to virtually any kind of content: wall notes, blog posts, images, etc.
• Ratings
  Ratings can be a very important part of any community-based content site. They allow the whole community to be in charge of what content takes precedence on the site.
• Tags
  Similar to comments and ratings, tags can be attached to different types of content, allowing users to build an independant form of navigation and/or categorization.

Other Built-in Web Parts

• Advertisments
  Allows users to set up and serve unlimited number of ad campaigns.
• News system
  MonoX includes several pre-built news-related Web parts. All of these modules are integrated with the news management back end section of the portal.
• File upload
  File upload Web part provides functionality for uploading unlimited number of files to the Web server. End user is available to select files to upload one by one, and than upload them all in a single step. An alternative Silverlight-based upload part provides even better user experience and interactivity.
• HTML editor
  HTML editor is one of the most-often used Web parts. It allow users to interactively edit the contents of the portal, and to immediately see the results in the WYSIWYG fashion.
• Login
  Login Web part allows administrators to quickly set up the login screen of their applications.
• Menu
  Menu Web part allows administrators to easily produce navigation menus on their portals. The navigation structure of a portal can be defined in the page management section.
• Poll
  Allows users to set up an unlimited number of polls and simple surveys.
• RSS reader
  RSS is an acronym that stands for Really Simple Syndication and it has become a popular means of distributing and reading information from around the Web. RSS reader Web part allows users to easily consume information from unlimited number of RSS sources.
• Search
  Search Web part offers a very powerful and flexible functionality for creating local search engine for the various types of content. It also supports templating techniques, allowing administrators to tightly integrate this part wherever it is needed, while achieving the desired appearance and behavior.
• List
  Allows administrators to manage all list-based information: FAQs, link lists, user testimonials, and similar.
• Newsletter
  Enables administrators to create and send newsletters to target subscriber groups.

Performance

• Advanced caching
  MonoX administrators can fine-tune the caching system on both page and Web part-level to reduce the access time and increase application responsiveness.
• Viewstate optimization
  MonoX can completely remove the contents of the ViewState hidden form field. It practically means that your page will be much “lighter” in terms of size and load times, as ViewState hidden field can hold tens of kilobytes of data even in moderately complex applications. All this is possible without loosing any of the ViewState-related functionality.
• HTTP compression
  Each portal page or related resource can be compressed on the fly, reducing the impact on the bandwidth and page load times.
• High-performance, flexible data layer
  MonoX utilizes LLBLGen, a powerful object-relational engine that generates highly optimized, robust and scalable database-related code.

Interoperability

• Integration with third-party modules and applications
  An additional benefit of the provider model used in MonoX is that all ASP.NET applications that use it can be easily integrated with MonoX. Integrating excellent third-party applications like BlogEngine.Net and YetAnotherForum.NET is only a matter of few configuration changes in the Web.config files of these applications (full examples can be downloaded from the support site).
• RSS
  Administrators without technical experience can easily set up both RSS providers and consumers in MonoX and enable it to exchange information with external applications.

Please visit Kernelemente to find out how we can create your ASP.net Content Management System.

Top features of WYSIWYG HTML Editor

What makes Cute Editor the leading online HTML Editor on the market? Aside from its powerful features and ease to use, here are some of the top reasons that make the Cute Editor your best choice for creating and publishing web content:

A cross-browser, cross-platform WYSIWYG online HTML editor.

Compatible with the most important browsers available in the market: IE 5.5+, Firefox 1.0+, Chrome, Mozilla 1.3+, Opera 9.0+, Netscape 7+ and Safari (1.3+). This includes Macintosh and Linux.

Compliant with the web standards, no deprecated tags such as <FONT> anymore

Does your online html editor still use deprecated tags such as <FONT>? Cute Editor will help you build asp.net web applications sites that adhere to the latest HTML standards, generates clean HTML/XHTML code with no deprecated tags.

Insert clean HTML from Microsoft Word.

When text is pasted from Microsoft Word a lot of unnecessary word specific markup is carried across. This can result in web pages that take an unnecessarily long time to download. The Paste from Word button solves this by removing word markup before pasting the text into your page. The ideal way for ASP.net Document Management.

Output HTML or well-formed XHTML to your choice (Demo)

Cute Editor supports output well-formed XHTML. Your choice of XHTML 1.0 or HTML 4.01 output.

Clean, lightweight and extremely fast loading

Numerous optimization methods has been applied. It’s clean, compact, extremely fast-loading, but still powerful and efficient.

Advanced file upload function

We integrate a hi-performance ASP.NET CMS upload component – Ajax uploader into Cute Editor. Ajax Uploader allows you to select and upload multiple files at once. It also supports client side validation of the file size/type before uploading.

Store images in a Database

With Cute Editor you can easily use a SQL Server database or access database as the file storage.

Image insertion and automatic upload

Built-in thumbnail generator. Thumbnail images are dynamically created; Supports upload new images. Paging – specify how many images. Support auto resize images.

Apply security to control user access to resources

Cute Editor allows developers to assign a pre-defined set of permissions by group or individual. This prevents a normal user to access the administration functionality.

RTF to HTML, HTML to RTF

With Cute Editor you can easily convert an HTML document into an RTF file and RTF file into HTML or XHTML document.

Create PDF files

Cute Editor also allows you dynamically create Adobe PDF documents from ASP.NET.

Please visit Kernelemente today and find out how we can improve your Content Management System.

• ASP.NET MVC – We’re going to use ASP.NET MVC Framework to create the web application. As the article name suggests, most of the actual program code including models and controllers will be implemented in F#.
• F# LINQ to SQL – The application uses a sample Northwind database and we’ll write queries for selecting data from the database using LINQ support that’s available in the F# PowerPack.
• F# features – The application also uses some nice F# features that are quite useful for developing web applications. We’ll use modules and records to implement the model and we’ll also use advanced meta-programming features for constructing LINQ queries.

If you want to use F# for creating an MVC application, you have a few options. It should be possible to create the web application solely as an F# project. However, we’ll use a more convenient approach. We’ll create a standard C# MVC project and move all the actual implementation to an F# library. We’ll look at the application structure shortly.

Application structure

The most convenient way to create an MVC web application, which is implemented in F# is to mix several C# and F# projects in a single solution. F# doesn’t include web project templates and doesn’t implement all Visual Studio tools that are needed for comfortable web development, so we’ll create a C# projects that allow us to use LINQ to SQL and ASP.NET designers. All important pieces of code will be written in F# though!

• WebApplication is the main MVC web application project. This is a C# project, but it doesn’t contain almost any code, because model and all controllers are implemented in a referenced F# library. This project mainly contains views (aspx files) and other resources (such as stylesheets and database).
• WebApplication.Core is an F# project that implements the core functionality of the application. In the sample application, it contains Model.fs, which implements the functionality for accessing data and two controllers (HomeController.fs for the main page and ProductsController.fs for working with products database). The Global.fs file registers routes for the URL rewriting.
• WebApplication.Data is a simple C# project that contains only generated LINQ to SQL classes for our sample database. Although it is possible to rewrite the classes to F#, it is more convenient to use the tool available for C# in Visual Studio.

When creating the projects by hand, you’ll need to translate the generated controllers from C# to F# and you’ll need to add all relevant ASP.NET references to the F# library project (there is an absurd number of them). However, you shouldn’t face any difficulties or tricky problems. In any case, it is easier to start using the Visual Studio 2010 template that you can download below.

Now that we looked at the application structure, we’ll look at a couple of interesting places in the application. This may give you an idea of some benefits that F# provides to web developers (although the sample is only very basic!)

Implementing model in F# with LINQ

As already mentioned, I decided to use the F# implementation of LINQ to SQL for data access in the application. There are only a few articles about this topic, so we’ll discuss it in some more details. As already mentioned, LINQ to SQL cannot generate the classes natively in F#, so I created a separate C# project that contains just the generated classes.

The following listing shows the content of the Model.fs (without a single function that will be discussed shortly). As you can see, I created one record type for storing information about products that will be displayed in the page (we’ll use it later). The rest of the model is implemented as an F# module, which means that it will appear as static class to .NET. Modules are quite useful for storing functionality that doesn’t need to be encapsulated in a class, so this is a perfect fit:

namespace WebApplication.Core

open Microsoft.FSharp.Quotations
open Microsoft.FSharp.Linq
open Microsoft.FSharp.Linq.Query

// Namespace with LINQ to SQL generated classes
open WebApplication.Data

// Stores information about product (will be used later)
type ProductInfo = {
  ID : int
  Name : string
  Category : string
  Price : System.Decimal }

// Implementes the model for our MVC application
module Model =
  // Returns the 'Product' entity with the given ID
  let ProductDetail (id) =
    let dx = new NorthwindDataContext()
    <@ seq { for p in dx.Products do
               if (p.ProductID = id) then yield p }
               |> Seq.head @> |> query

The ProductDetail function first creates a new instance of the generated data context and then runs the query. A query in F# is written using quotations. This means that the data-processing code is enclosed in <@ ... @>, which instructs the compiler to store the expression tree of the code (instead of compiling it). The quotation is then passed to the built-in query function that interprets it as a LINQ query.

Inside the query, you can use sequence expressions as well as some basic functions from the Seq module. In our application, we’re using sequence expression that selects all products with the specified ID and then use the Seq.head function to get only first such product.

Composing LINQ queries

The second function implemented in the model will return a list of products. I made it a bit more sophisticated to demonstrate some interesting capabilities of the F# support for LINQ. In particular, the function takes a parameter that can specify how to sort the products. The parameter is a quotation that represents the expression tree of a key selector that specifies how products should be sorted. A key selector is a function that takes a product and returns some its property (or even calculated value). For example, to sort products using the length of the product name, the key selector would be <@ fun p -> p.ProductName.Length @>. Let’s first look at the code and I’ll explain how the key selector is used after that:

let ListProducts (keySelector:Expr<Product -> 'T>) =
  let dx = new NorthwindDataContext()
  <@ seq { for p in dx.Products |> Seq.sortBy %keySelector do
              for c in dx.Categories do
                if (p.CategoryID.Value = c.CategoryID) then
                  yield { ID = p.ProductID
                          Name = p.ProductName
                          Category = c.CategoryName
                          Price = p.UnitPrice.Value } } @> |> query

The keySelector parameter has a type Expr<Product -> 'T>, which means that it is an expression tree (or a quotation, in the F# terminology) of some function that takes a Product and returns some value – the function is generic, so the value can be anything. It is used in the quoted expression as a parameter of the Seq.sortBy function. We use %keySelector, which means that the quotation of the key selector will be “spliced” into the quotation we’re writing. When we pass the quoted query to the query function later, it will see the actual expression in place of the variable spliced using the % operator. This allows us to compose queries from individual pieces, which is quite useful and cannot be directly done in C# – we can for example dynamically compose the WHERE clause using conditions specified by the user.

The sample query also uses a sequence expression with nested for loops to implement the JOIN functionality. Although this isn’t needed, because the Product entity contains a reference to the associated Category, I wrote the join explicitly to demonstrate a more complex LINQ query in F#. Finally, when returning the result using the yield keyword, we construct a value of the record defined in the previous listing (which is a bit simpler than declaring and creating a class in C#).

Implementing controllers in F#

Now that we have the module implementing the model component of our MVC application, we’ll also need to implement the controller. We’ll look at the content of the ProductsController.fs file, which is more interesting as it uses the model and also calls the ListProducts function with several different key selectors as arguments.

The class contains two members that implement two actions of the controller. The member List loads a list of products from the database. It has a parameter which may be null and specifies the ordering of products (simply as an integer). The second member returns details about the specified product and is named Detail:

let (|NonNull|_|) (a:Nullable<_>) =
  if a.HasValue then Some(a.Value) else None

type ProductsController() =
  inherit Controller()

  member x.List(id:Nullable<int>) =
    x.ViewData.Model <-
      match id with
      | NonNull(1) -> Model.ListProducts <@ fun p -> p.UnitPrice.Value @>
      | NonNull(2) -> Model.ListProducts <@ fun p -> p.CategoryID.Value @>
      | _ -> Model.ListProducts <@ fun p -> p.ProductName @>
    x.View() 

  member x.Detail(id:int) =
    x.ViewData.Model <- Model.ProductDetail id
    x.View()

The listing first defines a simple active pattern that is useful when working with Nullable<T> values. It matches when the value given as an argument contains some value and fails when the value is empty. We use it in the List member where we need to select the ordering. When the parameter contains 1, we order products by price, parameter 2 specifies ordering by category and in all other cases (including empty value) we use default ordering by the product name. As you can see we specify several different key selectors (functions taking Product enclosed in quotation using <@ ... @>) of various return types. This is possible, because the ListProducts function is generic.

In both of the actions, we assign the result to the Model property of the ViewData. This allows the view to access the model in a type-safe way. The code in the view is standard C# code, so we won’t look at it here – it is just worth mentioning that F# records appear as standard .NET classes to the C# code, so the integration is very smooth.

Summary

When developing ASP.NET MVC application in F#, the most convenient thing to do is to create a C# project and move all implementation to an F# library that is then referenced from the C# project (which contains only aspx files and other content related to the presentation layer). In F#, we can use LINQ for accessing data and the fact that quotations can be nicely composed using splicing allows us to implement some patterns that are not easy to write in C#. Moreover, F# features such as modules and records as well as pattern matching are quite useful in web development. However, this article contains only a very basic example that doesn’t really take the full advantage of F#, so can only encourage you to download the template below and try experimenting yourself!

Visual Studio 2010 template

As already mentioned, I created a simple template based on the described project that allows you to simply create MVC web applications that use F# by selecting the template in Visual Studio 2010. To increase your appetite, the screenshot on the right is taken from my “New Project” dialog after installing the template. There are two minor gotchas with projects created from the template that you need to go through:

1. You’ll need to go to the WebApplication.Data project and generate the LINQ to SQL classes from the database description manually (for some reason, this doesn’t happen automatically when you build the project). To do this, right click on Nortwind.dbml and select “Run Custom Tool” command.
2. You’ll need to fix the reference from WebApplication.Core to WebApplication.Data – simply remove the existing reference and add it again (choosing the reference to another project in the solution).

Once that’s done, you should be able to run the project (assuming that you have SQL Server Express installed – the version that comes with Visual Studio 2010 is fine).

Vertical and Scenario-Focused Tooling

I personally think having a variety of tools is good, especially if they can focus on different verticals, and are optimized for different scenarios/tasks. There is a saying – use the right tool for the job. And the reality is there is a wide spectrum of developers and correspondingly a breadth of requirements and expectations. Lots of professional/enterprise developers will find Visual Studio and its rich set of features + ecosystem a must-have for their work. At the same time, there is a huge number of ASP.net Web developers, designers and scripters that primarily use Notepad, Textmate or a simple text editor to quickly build and manage their web sites and applications. For those folks, the simplicity that comes from the minimal set of options is a feature in itself. WebMatrix caters to that huge audience. This is true today, and was true back then.

Experimentation and New Ideas

The other aspect of “WebMatrix” for ASP.net Web Development that really resonates with me is that it provides an avenue for experimentation of new ideas/approaches, and learning, as well as innovation. You need speed boats and the agility they offer to explore the new, and then figure out where you want to go. We tried a number of things in the original WebMatrix – light-weight, free and web-focused tooling (I worked on Visual InterDev and missed the concept of a Web-focused SKU when the features got merged into Visual Studio). These characteristics also resonated well with the community, and I like to think the spirit of WebMatrix lived on in the form of the Express SKUs. The current generation of WebMatrix brings together a nice combination of simplified development model along with an embedded database solution (SQLCE), and a renewed focus on addressing server-side rendering (Razor). Personally, I think even more important than these building block technologies, is the notion of starting from applications and focusing on customizing them rather than building new applications from scratch. The concept of a rich ecosystem of working applications as a starting point is critical in fueling further growth of the platform as the underlying frameworks mature, and for competing.

A Social IDE – More Ideas to Explore

There were many ideas left unfinished in the original WebMatrix. For example, the online component gallery, and messenger/chat integration. Perhaps they were a little early back then. However, in this day and age of twitter, and social development (stack overflow, github etc.), it would be interesting to further that vision, and explore what an IDE can do to incorporate identity and facilitate collaborative development.

The original WebMatrix was one of the big early fully managed ASP.net web applications, and was written using Windows Forms. It is nice to see the prettier user interface behind the simplified and streamlined development experience. Of course, this version is built on WPF.

I do wonder – what about a Silverlight-based implementation? What I’d really also like to see is a richer set of IDE building blocks that can be composed together more readily to build specific vertical tools and experiences, without starting from scratch each time. This is what I realized even back then – code editor, intellisense, project system, debugger, source control, are some of the obvious components, that would be interesting to share across the different tools, Visual Studio, Expression, WebMatrix and other future efforts.

Please visit Kernelemente to find out what we can do for you.

Why database projects?

SQL Server Database projects are good for more than one reason to write custom ASP.net Web Applications. Main reason is simple – all database objects are defined in same solution where is code that is using this database. Because database project is project like the others then it is possible to add it to code repository – you get versioning this way.

You can build and deploy database projects so you get SQL-scripts and up to date database on your database server. And… I’ve heard that database projects are also able to incremental deployments.

Structure of database projects

In my last posting about my photo gallery system, Packaging my gallery code, I wrote about how to separate files from ASP.net web projects to other projects. One of there projects was database project called MyGallery2010.Database.

You can see my database project structure on right. Currently I have definitions for tables, primary keys and foreign keys. I think it is enough for now. When project gets some more complex requirements on database then I will add new features.

One difference I noticed is that empty database project is created without deep folder structure in Visual Studio 2010. Visual Studio 2008 database projects created also folders for tables, keys and so on. Visual Studio 2010 let’s you decide how do you want to organize the definitions of your database projects.

The internal structure of database projects is very rich and allow to handle asp.net web applications in the most innovative way. Take a look at properties section – there are settings for SQL command variables, deployments, permissions and other settings. You can also add database references to Visual Studio database projects.

And one thing more – take a look at Post-Deployment and Pre-Deployment folders. You can add there special SQL-scripts that are run before and after database deployment.

Adding database objects to project

After creating new database project it is easy to start adding definitions for database objects. You can right-click on database project and select database object type from menu as show on following screenshot fragment. You can also use “Add New Item” menu selection to add new database object definition from database objects menu as shown on following screenshot.

After adding new object definition Visual Studio 2010 creates file for it and adds example definition to it. You can use it to build up your own object definition. Building your database using Visual Studio database projects guarantees pretty well that you pay attention to every object you define. I think it may decrease also bugs in database definitions.

Building and deploying database

Building and deploying database projects is not different from other projects. What is different is output. You can see that before any deployments database scripts are validated and also object dependencies are analyzed. It means that before deployment the order of changes is already clear and deployment scripts have no errors.

Please visit Kernelemente to find out what creative applications we can create for you.

While creating simple database editing user interfaces with ASP.NET Dynamic Data is a snap, creating business rules to regulate data entry is nonetheless part of almost any application. If possible, the best practice is to start this process from the database level: you should enforce required fields in SQL Server, for instance. Similarly, if you know that a field can only have values from 0 to 100, you might add a constraint directly to the field using the CHECK keyword or the Check Constraints dialog box in SQL Server Management Studio.

In ASP.NET Dynamic Data applications, certain database level constraints are automatically enforced. For example, required fields (NOT NULL) automatically generate a validation error at runtime if left blank. However, more complex constraints not reflected by the model (such as CHECK constraints) will generate a generic error saying that the update wasn’t successful. To give the user of the application a clearer indication of what’s missing, you can again use attributes.

For instance, the Range attribute (defined in the System.ComponentModel.DataAnnotations namespace) can be used to specify minimum and maximum values for either an integer or floating point field. This attribute is applied similarly to the ScaffoldColumn and UIHint attributes.

Other attributes that you can use to check values include the Required and RegularExpression attributes. It is also possible to limit string lengths using the StringLength attribute. If you instead prefer to write custom validation code yourself, then you can write a method to extend the data model you have. For instance, if you are using ADO.NET Entities, then the NorthwindModel.Designer.cs file will have partial method declarations for validating fields.

For example, if you had a business rule saying that employee hire date must be a Monday, then you could write code to implement the OnHireDateChanging method of the Employees class.

However, the problem with this approach is that the OnChanging event is executed many times: when viewing records, when editing them, and finally when saving them. This means that the actual database values must match the rules – if they don’t, then the data cannot be shown.

If you instead would like to validate values only when changes are saved back to the database, then you would need to write a bit more code. The entity data model class (NorthwindEntities in the example application) contains an event called SavingChanges which you can handle. You should write your validation rule(s) into this event handler.

Here, the code first implements the OnContextCreated partial method and then adds an event handler for the SavingChanges event. The event handler itself (in MyHandlerForSavingChanges) collects all the added or modified records from the data model, and then loops thru them to see which are related to the Employees table. Once a match is found, the value of the HireDate field is checked, and if not a Monday, an exception is raised.

Writing custom validation code is not difficult, but often you can avoid this as the attributes provided by ASP.NET Dynamic Data already are quite versatile. If they don’t meet your needs however, you can write custom rules using the two techniques shown previously.

Conclusion

In this article, you have seen how ASP.NET Dynamic Data can be used to write functional web front-ends to databases in no time. Without doing almost any customizations, ASP.NET Dynamic Data allows you to create web interfaces that are suitable at least for administrative purposes. With some additional development, you can create effective applications that appeal to a wide range of users. However, ASP.NET Dynamic Data applications might not directly suit all your needs. In these cases, it is helpful to know that you can easily integrate an ASP.NET Dynamic Data application into (an existing) regular ASP.NET WebForms application. You can even enable in-place editing of data using the grids if you comment and uncomment about ten lines of code in Global.asax.cs file. Follow the instructions inside the file itself.

Because ASP.NET Dynamic Data applications are user- interface-wise based on a master page and CSS styles, the applications you write can also be quickly modified to have the necessary look and feel. In the future, these customizations will be even easier. CodePlex already contains a public preview of a forthcoming version, and ASP.NET Dynamic Data will also be a native part of .NET Framework 4.0. Given this, ASP.NET Dynamic Data has a bright future. The technology is already useful, and especially so if you need to write quick interfaces for your databases. And many of us do.

Links

Official ASP.NET Dynamic Data page
Microsoft Visual Studio 2008 Service Pack 1 download page
Using ASP.NET Dynamic Data on MSDN
ASP.NET Dynamic Data 4.0 Preview 4

Please click here to read Part 1 of our article

Please click here to read Part 2 of our article

or visit Kernelemente to find out what we can do for you.

ASP.NET Dynamic Data is also intelligent: if the model (and thus the underlying database) has referential integrity set between tables, then your web application will have links from one table to its related tables. In the sample database, a customer can have multiple orders. Thus, the listing for the Customers table contains an automatic link to the orders by this customer. Similarly, from an order page there is an automatic link to order detail rows.

Seeing how Dynamic Data applications are built

After taking a stroll through the generated web application and its many built-in features, it is a good time to close the browser and return to Visual Studio. Next, you are going to learn how ASP.NET Dynamic Data applications are constructed.

First, you can see that your project contains a special folder called DynamicData. This is the default name for this folder, but you can also customize its name by setting the DynamicDataFolderVirtualPath property of the metamodel class in the Global.asax.cs file.

The DynamicData folder contains several subfolders, of which you need to be aware. Four important folders are Content, CustomPages, FieldTemplates and PageTemplates. By design, the Content subfolder contains common resources such as logos and other images used by the application (the actual layout is done using a master template named Site.master). CustomPages folder is initially empty, but it is designed to be a placeholder for your pages that you might want to create for individual tables. That is, by default in ASP.NET Dynamic Data applications, all tables share the same look and feel for their listing and editing pages. Now, if you wanted to have a different page for inserting, say, customer and order records, then you could store your alternative layout pages under the CustomPages folder.

The next two subfolders are key to the operation of ASP.NET Dynamic Data applications. First, there is the folder called FieldTemplates. This folder contains around a dozen user controls, each of which is used to render certain types of database fields. For instance, for Boolean fields, the Boolean.ascx control is used, and for VARCHAR fields, the Text.ascx control is used, and so on. ASP.NET Dynamic Data determines the type of each column based on the model, and then decides which control to render.

The PageTemplates folder contains a set of regular .aspx files. There are three types of files for the basic database operations: creating (Insert.aspx), reading (List.aspx) and updating (Edit.aspx). The fourth basic operation, deletion, is handled by the List.aspx page.

Armed with this knowledge, you can open any of these files and see how they are built. Recall that the same .aspx pages (and their code behind files) are used for every table available in the model. Thus, the pages are not generated statically based on the model, but instead are formed at run-time based on the model. Because of this, you can see that the code in the .aspx files refers often to an object named table, which is a variable defined in the page class.

This object, actually of type MetaTable, contains meta- information about a selected table; the object itself is initialized in the Page_Load event handler. In the .aspx file, the code then refers to members like table.DisplayName and table.GetActionPath.

Customizing using attributes

So far, you have briefly seen how ASP.NET Dynamic Data applications work. After you have seen how the different features of the application, you should next learn how you can control how data is displayed in the application.

Earlier, when looking at the Global.asax.cs file, the ScaffoldAllTables property was set to true. This property value means that every table in the model became active in the application for editing and deleting. But maybe you would like to better control which tables are active. To do this, you need to use attributes. In the data model, the classes that represent the tables are defined as partial classes. This means that you can effectively continue adding features to these classes, including specifying attributes. To write the necessary code, you need to add a new file to your project.

The easiest way to add this file is to right-click your project in Visual Studio’s Solution Explorer and then choose the Add/Class command. Visual Studio will then ask you for a class name; choose any name you want, for instance “MetadataControl”. Once the file has been created, you can start editing it.

Assuming for example, that you want to hide the employees table, you would add a partial class definition for the Employee class, originally defined in the ADO.NET entity model file NorthwindModel.Designer.cs (if you followed the naming convention suggested earlier).

With this definition, the Employees class defined in the original entity model gets extended, and the ScaffoldTable attribute is added. This attribute is one of the key ones in ASP.NET Dynamic Data. Many of the most important attributes are defined in the System.ComponentModel.DataAnnotations namespace. Other often-needed attributes include ScaffoldColumn (of which you will soon see an example), DisplayName, DisplayFormat, Range and UIHint.

With the above ScaffoldTable attribute (and the value of false) in place, you should now run the application to see how it behaves. In the initial screen showing the names of tables in the data model, you should see that the Employees table link is missing. And, if you take a look for example at the Orders table, you can see that the hyperlinks to the table are also gone.

Notice how there are two ways to show and hide tables. You can make all tables visible using the ScaffoldAllTables property in the Global.asax.cs file, and then hide them one by one using attributes. The other option is to go the other way around: leave ScaffoldAllTables to false, and then allow individual tables to become visible using the ScaffoldTable(true) attribute.

Next, let’s see how you can control individual fields using attributes. Previously, you used partial classes to help in specifying the ScaffoldTable attribute, but if you wanted to have attributes associated with individual columns, you would need another kind of solution. Since you cannot have partial property definitions, you must use an additional class to define properties that are associated with database fields.

To do this, you start with a similar partial class like with the ScaffoldTable attribute, but you use the MetadataType attribute to associate another class with the original. Then, this additional class, called the metadata class, allows you to define public properties for each field in the data model which you want to control.

Here, the partial class Employees is defined as before, but also the MetadataType attribute is applied to the class. The constructor of this attribute accepts a type as a parameter, which in turn points to the metadata class called EmployeesMetadata. This class is then free to define new properties and associated field- level attributes to them. For instance, here the DisplayName attribute (in the System.ComponentModel namespace) is associated with the column Title to specify a new, more descriptive title for the field. Of course, the property names must match those in the database for this to work.

Modifying user interfaces

While understanding how attributes are applied in ASP.NET Dynamic Data applications is key to your success, you must also understand how you can customize the web page templates that together create the user interface for your application. As briefly mentioned before, ASP.NET Dynamic Data applications by default utilize an ASP.NET template file. This file is named Site.master, and can be found from the root folder of the project.

If you wanted to change the user interface, then editing the Site.master file would be a good place to start. It utilizes XHTML code and defines a single content placeholder into which the actual pages are embedded at runtime. Furthermore, the master file uses CSS styles, which are in turn defined in the file Site.css. To do application-wide font and color changes, editing this style sheet file would give you a head start.

In addition to the template and style sheet files, you do of course have the actual .aspx pages that implement the four basic operations. This can be found inside the DynamicData\PageTemplates folder in your solution. For instance, you might wish to change how the listing pages operate. For this need, you would edit List.aspx.

Another option for customizations is the DynamicData\FieldTemplates folder. This folder contains the user controls that ASP.NET Dynamic Data uses to render different database field types. For instance, a Boolean field is shown as a checkbox to the user. If you wanted to change this, you could simply go and edit the files Boolean.ascx and Boolean_Edit.ascx. There usually are two controls defined for each data type: one for viewing and another for editing. Often, the viewer control is simply a read-only version of the edit control.

It is also possible to define your own user controls to work with your data. For instance, you might wish to change the control that is used to display dates. By default, the DateTime.ascx control uses a textbox control for this, but you could easily change this to, say, a calendar control. If you wanted to make this an application-wide change, then you could simply edit DateTime.ascx, and all date fields would change. You can also change the control on a field by field basis. This is done using attributes, just like with the previously shown ScaffoldTable and ScaffoldColumn attributes.

This declaration mirrors any other user control definition. However, for a user control to be suitable for ASP.NET Dynamic Data use, you need to tweak the code-behind file a bit. First, you need to change the inheritance chain from the regular System.Web.UI.UserControl to System.Web.DynamicData.FieldTemplateUserControl.

Of course, you are not limited to controls that are available in ASP.NET. For instance if you have purchased a nice, feature-rich third-party control or created one on your own, you are free to use them in your ASP.NET Dynamic Data applications. Specifying which user control should be used when ASP.NET Dynamic Data renders the database views can be controlled using the UIHint attribute. This attribute is applied to metadata classes just like the ScaffoldColumn attribute.

If you feel you could spend your time better, then Microsoft has a possible time-saver made just for you. Called ASP.NET Dynamic Data and part of .NET 3.5 SP1 (Service Pack 1), this new technique lets you quickly create web-based interfaces for your database editing needs. ASP.NET Dynamic Data is written so that it supports all the basic database operations: reading, creating, updating and deleting. Shortly put, the web interfaces supports the basic CRUD operations for those tables you want to enable.

This article will walk you through creating and customizing an ASP.NET Dynamic Data web application, starting from the initial steps to a complete application. Code examples are written using C#, and the familiar SQL Server sample database Northwind is used as the data source.

Getting started with Dynamic Data

Developing your first ASP.NET Dynamic Data application is simple, but still the results are effective. To get started, you first need to install both Visual Studio 2008 Service Pack 1 and .NET 3.5 Service Pack 1.

Since ASP.NET Dynamic Data is aimed at writing user interfaces for databases, it’s only natural to have different options for database access. The two available options are using LINQ to SQL to access your databases, and the other is to access them using ADO.NET Entity Framework (ADO.NET Entities for short). Although it’s technically possible to mix these two data access options in a single ASP.NET Dynamic Data project, the idea is that you select one, and then stick to that.

That said, you often have to make an early choice of your data access strategy when starting development of ASP.NET Dynamic Data applications. Given this, it is wise to give some thought as to how you would like to access your databases before starting your project.

For this article, the ADO.NET Entity Framework is chosen, as it provides an elegant solution to many database access needs. Thus, the correct template icon to select from the New Project dialog box would be named “ASP.NET Dynamic Data Entities Web Application”. Once you name your project and click OK, Visual Studio will create a new solution for you with a skeleton application in place.

Although many other application types can be run successfully after creating the project, ASP.NET Dynamic Data applications make an exception. If you try to directly run the application without changing anything, you will run into a quite disappointing error saying that “there are no accessible tables”. But be brave, this problem is easy to fix!

The fix you need to do is easy to understand, if you recall that you haven’t yet specified any database for the application. Without a database connection, the application wouldn’t be able to display any data. (Another thing is whether the application could give you a clearer error message.) To solve the problem is then, a matter of defining a database connection.

Since the project template you chose earlier was designed for ADO.NET Entities, you should next add such a connection to your project. To do so, right-click the main project node in Visual Studio’s Solution Explorer, and then choose the Add/New Item command from the popup menu. This will bring the Add New Item dialog box onto the screen. From this dialog box, select the ADO.NET Entity Data Model object (this is easiest to find from the Data section on the left), and then enter a name for the object. It’s a good idea to name the object after your database, for instance NorthwindModel for the SQL Server sample database.

Once you click OK, the Entity Data Model Wizard will open (Figure 3). You can either create a model from a database, or an empty model. Since you will need a SQL database for ASP.NET Dynamic Data applications in any case, it is usually the easiest to generate the model after an existing database. The next step in the wizard is to specify the connection string for your database. This of course depends on your database, but at minimum you will need the server’s (host) name, your database name, and finally a user id and a password.

After you have specified all the necessary details, continue to the next step in the wizard. Here, you would specify all the tables, views and stored procedures you want to include in your model. The easiest, but not always the best option, is to work directly with the underlying SQL tables. For instance, using views would let you later change table structure without affecting the application. Once you have selected your database objects (from now on, this article will refer to these collectively as tables for simplicity), you can click the Finish button in the wizard, and then let Visual Studio create the entity model for you.

Connecting to the model

With the entity data model created and added to your project, you are ready to connect the model to the rest of the application. In ASP.NET Dynamic Data applications, there is something called a metamodel, to which you can connect either a LINQ or an ADO.NET Entity Framework context.

The metamodel contains information about the database which you wish to edit using your ASP.NET Dynamic Data application. It also contains details about which tables should be visible, how columns should be formatted, and so on.

The metamodel is initialized in the Global.asax code behind file, which is a logical place to register application-wide settings. Code in the Global.asax file (and its code behind file Global.asax.cs) is executed when the ASP.NET application loads, i.e. just before the first page is served.

If you take a look at the default implementation, you will see a long comment about how the metamodel should be registered. The last line of the comment is an actual code line (around line number 29), and you should uncomment and then edit this line to connect or register your data source with the application. Assuming you have an entity model named NorthwindEntities.

Note how you don’t need to specify an instance of your data model; it is enough to specify the type of the class using the C# typeof operator. Internally, ASP.NET Dynamic Data uses reflection to gather the necessary data at run-time.

Next, you need to understand the concept of a scaffold. In ASP.NET Dynamic Data, a scaffold specifies which database tables and their fields belong to the editable objects in the resulting application. By default, no tables are visible in the application, but for testing purposes, you could enable every table and all their fields to be editable. This can be done by setting the ScaffoldAllTables property to true, as shown in the previous code listing.

With these registrations in place, you can now run the application. The default page of the application lists all the tables in your data model, and each table name is also a link. Clicking a link allows you to go to a page that displays the records on that particular table. If you take a look at the records, you can see that these listing pages also contain links to create new records as well as edit and delete them. By default, these edits are done using separate pages. However, ASP.NET Dynamic Data also supports in-place editing on the data grids.

Please click here to read Part 1 of our article

Please click here to read Part 2 of our article

or visit Kernelemente to find out what we can do for you.