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
