One of the highlights of my recent trip to Europe was getting the chance to publicly show off some of the new features in our next release of Visual Studio and the .NET Framework (codename: "Orcas") for the first time publicly.
You can download the deck I presented here. You can also watch a version of the Belgium talk that Tom posted on the web here (note: another version taken from my WebDD talk in the UK will also be posted shortly).
"Orcas" is going to be a pretty exciting release, and contains a ton of great functionality that I think you will really love. I'll be drilling down into more details of it over the next few months in many more blog posts. Below are a few screen-shots from demos I showed over the weekend in my talks in Europe. Note that they are just a few of the features - there are a lot more features I have yet to talk about. :-)
Multi-Targeting
Visual Studio "Orcas" will be the first version of Visual Studio that enables developers to target multiple versions of the .NET Framework. This means that you can open or create a project that explicitly targets either the .NET Framework 2.0, 3.0 and 3.5 releases, and Visual Studio will automatically filter intellisense, toolbox controls, and add reference dialog items (among other things) to only show those features supported within that specific version of the framework. You can then compile against each of these different framework releases, as well as get full debugging support for each.
The big benefit of Multi-Targeting is that you can now use most of the new features (for example: all the WYSWIYG designer and JavaScript editing ones) in Visual Studio "Orcas" immediately - even if you are still working on or updating an older project.
Below is an example that shows how to create a project that explicitly targets .NET Framework 2.0 (allowing you to create a web project in "Orcas" that will run on the current ASP.NET 2.0 release):
You can then adjust the version target to .NET Framework 3.5 (which is the "Orcas" release of the framework libraries and includes LINQ support), and you can see that several new project types are available (including WPF projects):
Assembly references, intellisense, and debugging within a project will automatically adjust based on the version of the framework you are targeting.
Rich HTML/CSS WYSIWYG Designer
As I mentioned in an earlier blog post, Visual Studio "Orcas" will ship a radically improved HTML and ASP.NET page designer. Among other things, this WYSIWYG designer provides:
- Split View Support (the ability to have both HTML Source and WYSIWYG design open simultaneously)
- Extremely rich CSS support (CSS property window, CSS inheritance viewer, CSS preview, and CSS manager)
- Dramatically improved view switching performance (moving from source->html design mode is now nearly instantaneous)
- Support for control designers within source view (property builders, event wire-up and wizards now work in source view)
- Richer ruler and layout support (better yet, values can be automatically stored in external CSS files)
- Designer support for nested master pages
Below is a screen-shot of an ASP.NET page in split-view mode editing mode (enabling you to work in both source and design mode simultaneously):
Visual Studio "Orcas" also now has radically improved CSS support. The new "Manage Styles" property window allows you to easily create, manage, and refactor CSS rules within style-sheets.
For example: you can see a list of all stylesheet rules within the c4f.css stylesheet below. Those with circles around them mean that the rule is being used within the current page (you can then right-click to see how many places it is being used and to highlight those elements that are using it in the WYWSIYG designer). You can drag/drop the rules to re-arrange their order within the stylesheet, refactor them across files, and to select an HTML element in the WYSIWYG designer to apply the CSS rule.
When you select an HTML element in the WYSIWYG designer, you can also now use the CSS Properties window to see all CSS rules and their corresponding settings. One really nice thing about this feature is that it shows you the cascading settings inherited from the various CSS rules.
For example: you can see below that the various rules I have set for a particular element set the color property 4 times (these are in turn overridden by lower rules in the CSS chain). You can click on any rule in the property-pane, or on any of the overridden values to identify exactly where each setting is coming from. This makes it much, much easier to figure out why a page or element looks a particular way when using CSS:
When changing CSS style values like color, the color-pickers also now have nice features such as showing you other colors already in use in the stylesheet or document:
The WYSIWYG designer now supports the ability to define and use "nested master pages" for ASP.NET. For example, you can now define a root "Site.Master" file for the entire site:
You can then obviously create new .aspx pages that uses this (like in VS 2005), Or you can now also create a new master page that derives from it, and adds its own content and other contentplaceholder controls within the contentplaceholder defined in the root site.master file. This is super useful when you want to have multiple types of layout used across a site. For example, you might want to introduce a Two Column content layout master file like below, which inherits and extends the root Site.Master file:
You can then create new pages that derive from this Two Column master page and fill-in content within the two contentplaceholders exposed by it:
The beauty is that any change made to the root master will now be picked up by all pages on the site - regardless of which master page they are based on (as long as that master is based on the root master). This enables much richer and more flexible organization of layout structure within your site.
ASP.NET AJAX and JavaScript
ASP.NET AJAX 1.0 shipped two weeks ago - with "Orcas" we are taking it even further (and obviously including all of the ASP.NET AJAX 1.0 functionality built-in). Included as part of this will be significantly improved AJAX and JavaScript tool support within Visual Studio -- including JavaScript intellisense and much richer debugging support.
Below is a screen-shot showing intellisense method summary information automatically being generated on the fly against standard inline JavaScript (any JavaScript code will work):
The JavaScript intellisense supports rich type inferencing - for example, notice how it has automatically inferred from the method below that the return argument is a string (and so can provide intellisense for a string on it later):
The JavaScript intellisense engine within VS will have rich support for all the standard ASP.NET AJAX library concepts (classes, properties, enums, etc). In addition to providing intellisense support against any regular JavaScript code, VS will also allow you to now add optional comment summary information to provide additional hints for Intellisense:
When debugging AJAX and JavaScript, you can now set client-JavaScript breakpoints within your server-code - VS can now automatically then wire these up on the client-side (these breakpoints will also optionally be persisted when you close a project/solution). When debugging you also now have full watch window, intermediate window and more support. The solution explorer in VS also now automatically lists running JavaScript document files - allowing you to easily set breakpoints in any script resource.
Significantly Improved Data Support
As I have blogged about in the past, "Orcas" will include support for LINQ - which makes data access with .NET radically better by making the concept of querying a first class programming concept. VS Orcas includes an object relational mapper that enables you to create data models for relational data:
You can then write rich LINQ queries in VB and C# to retrieve data, data bind it, and update it. Full intellisense is now supported inside VS for all LINQ queries and resulting value:
To start to see some of the power of LINQ, please watch my video here, In addition to allowing you to write code using LINQ, we'll also obviously have full data-binding support in ASP.NET, and enable you to easily hook up any ASP.NET UI control to LINQ entities (allowing you to support paging, sorting, editing, deleting, and insertion without having to write any code). We'll also have some new ASP.NET data controls (including a sweet new CSS based ListView control) that will help make building data driven UI even easier.
Summary
Orcas is going to be a fun release. The screen-shots above hopefully wet your appetite about what is coming. All of the features I showed above, and in the LINQ video, will ship within the February CTP of "Orcas" that will be available for public download in a few weeks. We are then looking to ship a first Beta later this spring. I'll be doing many more posts over the next few months that talk about some of the new features in much more detail.
Hope this helps,
Scott