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
