originally published in CoDe Magazine Editorial Microsoft recently released the first CTP
of a new development environment called WebMatrix, which along with some
of its supporting technologies are squarely aimed at making the Microsoft Web Platform more approachable for first-time developers and hobbyists. But in the process, it also provides some updated technologies that can make life easier for existing .
NET developers. Let’s face it: ASP.
NET development isn’t exactly trivial unless you already have
a fair bit
of familiarity with sophisticated development practices. Stick
a non-developer in front
of Visual Studio .
NET or even the Visual Web Developer Express edition and it’s not likely that the person in front
of the screen will be very productive or feel inspired. Yet other technologies like PHP and even classic ASP did provide the ability for non-developers and hobbyists to become reasonably proficient in creating basic web content quickly and efficiently. WebMatrix appears to be Microsoft’s attempt to bring back some
of that simplicity with
a number
of technologies and tools. The key is to provide
a friendly and fully self-contained development environment that provides all the tools needed to build an application in one place, as well as tools that allow publishing
of content and databases easily to the web server. WebMatrix is made up
of several components and technologies: IIS Developer Express IIS Developer Express is
a new, self-contained development web server that is fully compatible with IIS 7.5 and based on the same codebase that IIS 7.5 uses. This new development server replaces the much less compatible Cassini web server that’s been used in Visual Studio and the Express editions. IIS Express addresses
a few shortcomings
of the Cassini server such as the inability to serve custom ISAPI extensions (i.e., things like PHP or ASP classic for example), as well as not supporting advanced authentication. IIS Developer Express provides most
of the IIS 7.5 feature set providing much better compatibility between development and live deployment scenarios. SQL Server Compact 4.0 Database access is
a key component for most web-driven applications, but on the Microsoft stack this has mostly meant you have to use SQL Server or SQL Server Express. SQL Server Compact is not new-it’s been around for
a few years, but it’s been severely hobbled in the past by terrible tool support and the inability to support more than
a single connection in Microsoft’s attempt to avoid losing SQL Server licensing. The new release
of SQL Server Compact 4.0 supports multiple connections and you can run it in ASP.
NET web applications simply by installing an
assembly into the bin folder
of the web application. In effect, you don’t have to install
a special system configuration to run SQL Compact as it is
a drop-in database engine: Copy the small
assembly into your BIN folder (or from the GAC if installed fully), create
a connection string against
a local file-based database file, and then start firing SQL requests. Additionally WebMatrix includes nice tools to edit the database tables and files, along with tools to easily upsize (and hopefully downsize in the future) to full SQL Server. This is
a big win, pending compatibility and performance limits. In my simple testing the data engine performed well enough for small data sets. This is not only useful for web applications, but also for desktop applications for which
a fully installed SQL engine like SQL Server would be overkill. Having
a local data store in those applications that can potentially be accessed by multiple users is
a welcome feature. ASP.
NET Razor View Engine What? Yet another native ASP.
NET view engine? We already have Web Forms and various different flavors
of using that view engine with Web Forms and MVC. Do we really need another? Microsoft thinks so, and Razor is an implementation
of a lightweight, script-only view engine. Unlike the Web Forms view engine, Razor works only with inline code, snippets, and markup; therefore, it is more in line with current thinking
of what
a view engine should represent. There’s no support for
a “page model” or any
of the other Web Forms features
of the full-page framework, but just
a lightweight scripting engine that works with plain markup plus embedded expressions and code. The markup syntax for Razor is geared for minimal typing, plus some progressive detection
of where
a script block/expression starts and ends. This results in
a much leaner syntax than the typical ASP.
NET Web Forms alligator (<% %>) tags. Razor uses the @ sign plus standard C# (or Visual Basic) block syntax to delineate code snippets and expressions. Here’s
a very simple example
of what Razor markup looks like along with some comment annotations: <!DOCTYPE html> <html> <head> <title></title> </head> <body> <h1>Razor Test</h1> <!-- simple expressions --> @DateTime.Now <hr /> <!-- method expressions --> @DateTime.Now.ToString("T") <!-- code blocks --> @{ List<string> names = new List<string>(); names.Add("Rick"); names.Add("Markus"); names.Add("Claudio"); names.Add("Kevin"); } <!-- structured block statements --> <ul> @foreach(string name in names){ <li>@name</li> } </ul> <!-- Conditional code --> @if(true) { <!-- Literal Text embedding in code --> <text> true </text>; } else { <!-- Literal Text embedding in code --> <text> false </text>; } </body> </html> Like the Web Forms view engine, Razor parses pages into code, and then executes that run-time compiled code. Effectively
a “page” becomes
a code file with markup becoming literal text written into the Response stream, code snippets becoming raw code, and expressions being written out with Response.Write(). The code generated from Razor doesn’t look much different from similar Web Forms code that only uses script tags; so although the syntax may look different, the operational model is fairly similar to the Web Forms engine minus the overhead
of the large Page object model. However, there are differences: -Razor pages are based on
a new base class, Microsoft.WebPages.WebPage, which is hosted in the Microsoft.WebPages
assembly that houses all the Razor engine parsing and processing logic. Browsing through the
assembly (in the generated ASP.
NET Temporary Files folder or GAC) will give you
a good idea
of the functionality that Razor provides. If you look closely,
a lot
of the feature set matches ASP.
NET MVC’s view implementation as well as many
of the helper classes found in MVC. It’s not hard to guess the motivation for this sort
of view engine: For beginning developers the simple markup syntax is easier to work with, although you obviously still need to have some understanding
of the .
NET Framework in order to create dynamic content. The syntax is easier to read and grok and much shorter to type than ASP.
NET alligator tags (<% %>) and also easier to understand aesthetically what’s happening in the markup code. Razor also is
a better fit for Microsoft’s vision
of ASP.
NET MVC: It’s
a new view engine without the baggage
of Web Forms attached to it. The engine is more lightweight since it doesn’t carry all the features and object model
of Web Forms with it and it can be instantiated directly outside
of the HTTP environment, which has been rather tricky to do for the Web Forms view engine. Having
a standalone script parser is
a huge win for other applications as well – it makes it much easier to create script or meta driven output generators for many types
of applications from code/screen generators, to simple form letters to data merging applications with user customizability. For me personally this is very useful side effect and who knows maybe Microsoft will actually standardize they’re scripting engines (die T4 die!) on this engine. Razor also better fits the “view-based” approach where the view is supposed to be mostly
a visual representation that doesn’t hold much, if any, code. While you can still use code, the code you do write has to be self-contained. Overall I wouldn’t be surprised if Razor will become the new standard view engine for MVC in the future – and in fact there have been announcements recently that Razor will become the default script engine in ASP.
NET MVC 3.0. Razor can also be used in existing Web Forms and MVC applications, although that’s not working currently unless you manually configure the script mappings and add the appropriate assemblies. It’s possible to do it, but it’s probably better to wait until Microsoft releases official support for Razor scripts in Visual Studio. Once that happens, you can simply drop .cshtml and .vbhtml pages into an existing ASP.
NET project and they will work side by side with classic ASP.
NET pages. WebMatrix Development Environment To tie all
of these three technologies together, Microsoft is shipping WebMatrix with an integrated development environment. An integrated gallery manager makes it easy to download and load existing projects, and then extend them with custom functionality. It seems to be
a prominent goal to provide community-oriented content that can act as
a starting point, be it via
a custom templates or
a complete standard application. The IDE includes
a project manager that works with
a single project and provides an integrated IDE/editor for editing the .cshtml and .vbhtml pages.
A run button allows you to quickly run pages in the project manager in
a variety
of browsers. There’s no debugging support for code at this time. Note that Razor pages don’t require explicit compilation, so making
a change, saving, and then refreshing your page in the browser is all that’s needed to see changes while testing an application locally. It’s essentially using the auto-compiling Web Project that was introduced with .
NET 2.0. All code is compiled during run time into dynamically created assemblies in the ASP.
NET temp folder. WebMatrix also has PHP Editing support with syntax highlighting. You can load various PHP-based applications from the WebMatrix Web Gallery directly into the IDE. Most
of the Web Gallery applications are ready to install and run without further configuration, with Wizards taking you through installation
of tools, dependencies, and configuration
of the database as needed. WebMatrix leverages the Web Platform installer to pull the pieces down from websites in
a tight integration
of tools that worked nicely for the four or five applications I tried this out on. Click
a couple
of check boxes and fill in
a few simple configuration options and you end up with
a running application that’s ready to be customized. Nice! You can easily deploy completed applications via WebDeploy (to an IIS server) or FTP directly from within the development environment. The deploy tool also can handle automatically uploading and installing the database and all related assemblies required, making deployment
a simple one-click install step. Simplified Database Access The IDE contains
a database editor that can edit SQL Compact and SQL Server databases. There is also
a Database helper class that facilitates database access by providing easy-to-use, high-level query execution and iteration methods: @{ var db = Database.OpenFile("FirstApp.sdf"); string sql = "select * from customers where Id > @0"; } <ul> @foreach(var row in db.Query(sql,1)){ <li>@row.FirstName @row.LastName</li> } </ul> The query function takes
a SQL statement plus any number
of positional (@0,@1 etc.) SQL parameters by simple values. The result is returned as
a collection
of rows which in turn have
a row object with dynamic properties for each
of the columns giving easy (though untyped) access to each
of the fields. Likewise Execute and ExecuteNonQuery allow execution
of more complex queries using similar parameter passing schemes. Note these queries use string-based queries rather than LINQ or Entity Framework’s strongly typed LINQ queries. While this may seem like
a step back, it’s also in line with the expectations
of non .
NET script developers who are quite used to writing and using SQL strings in code rather than using OR/M frameworks. The only question is why was something not included from the beginning in .
NET and Microsoft made developers build custom implementations
of these basic building blocks. The implementation looks
a lot like
a DataTable-style data access mechanism, but to be fair, this is
a common approach in scripting languages. This type
of syntax that uses simple, static, data object methods to perform simple data tasks with one line
of code are common in scripting languages and are
a good match for folks working in PHP/Python, etc. Seems like Microsoft has taken great advantage
of .
NET 4.0’s dynamic typing to provide this sort
of interface for row iteration where each row has properties for each field. FWIW, all the examples demonstrate using local SQL Compact files - I was unable to get
a SQL Server connection string to work with the Database class (the connection string wasn’t accepted). However, since the code in the page is still plain old .
NET, you can easily use standard ADO.
NET code or even LINQ or Entity Framework models that are created outside
of WebMatrix in separate assemblies as required. The good the bad the obnoxious - It’s still .
NET The beauty (or curse depending on how you look at it :))
of Razor and the compilation model is that, behind it all, it’s still .
NET. Although the syntax may look foreign, it’s still all .
NET behind the scenes. You can easily access existing tools, helpers, and utilities simply by adding them to the project as references or to the bin folder. Razor automatically recognizes any
assembly reference from assemblies in the bin folder. In the default configuration, Microsoft provides
a host
of helper functions in
a Microsoft.WebPages
assembly (check it out in the ASP.
NET temp folder for your application), which includes
a host
of HTML Helpers. If you’ve used ASP.
NET MVC before,
a lot
of the helpers should look familiar. Documentation at the moment is sketchy-there’s
a very rough API reference you can check out here: http://www.asp.net/webmatrix/tutorials/asp-net-web-pages-api-reference Who needs WebMatrix? Uhm… good Question Clearly Microsoft is trying hard to create an environment with WebMatrix that is easy to use for newbie developers. The goal seems to be simplicity in providing
a minimal development environment and an easy-to-use script engine/language that makes it easy to get started with. There’s also some focus on community features that can be used as starting points, such as Web Gallery applications and templates. The community features in particular are very nice and something that would be nice to eventually see in Visual Studio as well. The question is whether this is too little too late. Developers who have been clamoring for
a simpler development environment on the .
NET stack have mostly left for other simpler platforms like PHP or Python which are catering to the down and dirty developer. Microsoft will be hard pressed to win those folks-and other hardcore PHP developers-back. Regardless
of how much you dress up
a script engine fronted by the .
NET Framework, it’s still the .
NET Framework and all the complexity that drives it. While .
NET is
a fine solution in its breadth and features once you get
a basic handle on the core features, the bar
of entry to being productive with the .
NET Framework is still pretty high. The MVC style helpers Microsoft provides are
a good step in the right direction, but I suspect it’s not enough to shield new developers from having to delve much deeper into the Framework to get even basic applications built. Razor and its helpers is trying to make .
NET more accessible but the reality is that in order to do useful stuff that goes beyond the handful
of simple helpers you still are going to have to write some C# or VB or other .
NET code. If the target is
a hobby/amateur/non-programmer the learning curve isn’t made any easier by WebMatrix it’s just been shifted
a tad bit further along in your development endeavor when you run out
of canned components that are supplied either by Microsoft or the community. The database helpers are interesting and actually I’ve heard
a lot
of discussion from various developers who’ve been resisting .
NET for
a really long time perking up at the prospect
of easier data access in .
NET than the ridiculous amount
of code it takes to do even simple data access with raw ADO.
NET. It seems sad that such
a simple concept and implementation should trigger this sort
of response (especially since it’s practically trivial to create helpers like these or pick them up from countless libraries available), but there it is. It also shows that there are plenty
of developers out there who are more interested in ‘getting stuff done’ easily than necessarily following the latest and greatest practices which are overkill for many development scenarios. Sometimes it seems that all
of .
NET is focused on the big life changing issues
of development, rather than the bread and butter scenarios that many developers are interested in to get their work accomplished. And that in the end may be WebMatrix’s main raison d'être: To bring some focus back at Microsoft that simpler and more high level solutions are actually needed to appeal to the non-high end developers as well as providing the necessary tools for the high end developers who want to follow the latest and greatest trends. The current version
of WebMatrix hits many sweet spots, but it also feels like it has
a long way to go before it really can be
a tool that
a beginning developer or an accomplished developer can feel comfortable with. Although there are some really good ideas in the environment (like the gallery for downloading apps and components) which would be
a great addition for Visual Studio as well, the rest
of the development environment just feels like crippleware with required functionality missing especially debugging and Intellisense, but also general editor support. It’s not clear whether these are because the product is still in an early alpha release or whether it’s simply designed that way to be
a really limited development environment. While simple can be good, nobody wants to feel left out when it comes to necessary tool support and WebMatrix just has that left out feeling to it. If anything WebMatrix’s technology pieces (which are really independent
of the WebMatrix product) are what are interesting to developers in general. The compact IIS implementation is
a nice improvement for development scenarios and SQL Compact 4.0 seems to address
a lot
of concerns that people have had and have complained about for some time with previous SQL Compact implementations. By far the most interesting and useful technology though seems to be the Razor view engine for its light weight implementation and it’s decoupling from the ASP.NET/HTTP pipeline to provide
a standalone scripting/view engine that is pluggable. The first winner
of this is going to be ASP.
NET MVC which can now have
a cleaner view model that isn’t inconsistent due to the baggage
of non-implemented WebForms features that don’t work in MVC. But I expect that Razor will end up in many other applications as
a scripting and code generation engine eventually. Visual Studio integration for Razor is currently missing, but is promised for
a later release. The ASP.
NET MVC team has already mentioned that Razor will eventually become the default MVC view engine, which will guarantee continued growth and development
of this tool along those lines. And the Razor engine and support tools actually inherit many
of the features that MVC pioneered, so there’s some synergy flowing both ways between Razor and MVC. As an existing ASP.
NET developer who’s already familiar with Visual Studio and ASP.
NET development, the WebMatrix IDE doesn’t give you anything that you want. The tools provided are minimal and provide nothing that you can’t get in Visual Studio today, except the minimal Razor syntax highlighting, so there’s little need to take
a step back. With Visual Studio integration coming later there’s little reason to look at WebMatrix for tooling. It’s good to see that Microsoft is giving some thought about the ease
of use
of .
NET as
a platform For so many years, we’ve been piling on more and more new features without trying to take
a step back and see how complicated the development/configuration/deployment process has become. Sometimes it’s good to take
a step - or several steps - back and take another look and realize just how far we’ve come. WebMatrix is one
of those reminders and one that likely will result in some positive changes on the platform as
a whole. © Rick Strahl, West Wind Technologies, 2005-2010Posted in ASP.NET IIS7
