Important .NET Feeds

Presenting in Europe Next Week(ScottGu)

Fri, 27 Nov 2009 00:33:49 -0800

http://weblogs.asp.net/scottgu/archive/2009/11/27/presenting-in-europe-next-week.aspx

I’m off to Europe next week to do a bunch of technical presentations. I’m presenting for 5-6 hours in a bunch of different cities, and will be doing talks that cover: ASP.NET 4 and VS 2010, ASP.NET MVC 2, and Silverlight 4.

Below are details on the different cities I’m visiting, and how to register to attend the talks:

I’ll also be attending the BizSpark Camp in Paris on December 8th and will be doing a presentation there as well:

Paris, France – December 8th

Hope to see some of you at once of these events in person!

Scott

P.S. In addition to blogging, I’m also now using Twitter for quick updates and to share links. Follow me at: twitter.com/scottgu

Screenshots: Amazon Kindle 2 gets Better Battery Life and Native PDF Support(Scott Hanselman)

Tue, 24 Nov 2009 22:22:03 -0800

http://feedproxy.google.com/~r/ScottHanselman/~3/Gpl_k-EEk6c/ScreenshotsAmazonKindle2GetsBetterBatteryLifeAndNativePDFSupport.aspx

I love my Kindle. I've talked about this before in my quest for the perfect ebook reader:

2006: Sony Reader and Amazon Kindle - Will eBooks happen this time?
2008: Amazon Kindle
2009: A year with an Amazon Kindle (and new Kindle Cases)
Late 2009: Amazon Kindle vs. Amazon Kindle DX - The Final Word

It's always come down to this. If you want to read PDFs, get a Kindle DX. The screen is larger and it's just better for 8.5x11 or A4 documents. The Kindle 2 is for novels and the DX is for documents. At least, until now.

Today the situation just got a little blurrier. My Kindle 2 has been firmware version 2.0.3 for a while now. However, soon you'll get 2.3 pushed to you over wireless, or you can go get it yourself manually if, like me, you can't wait.

Manually installing is trivial. Download the update, copy it to the root of your Kindle 2 via USB, go to Settings and hit Update Kindle. It'll take about 5-10 minutes.

Not only does the Kindle 2 get a built-in PDF reader, you also get longer battery life. How? Well, I love my Kindle, truly, but it's true that if the 3G radio is on and you forget about it, you'll find a dead Kindle in a few days, usually just before a trip. Nothing more embarrassing than telling the dude in the airline seat next to you that "my book has a dead battery." ;)

The new firmware is smarter about when it turns the radio on and they say: "You can now read for up to 1 week on a single charge with wireless on. Turn wireless off and read for up to 2 weeks." I have yet to test this, but I can say that with the radio off, yes, it'll be on standby for a week or two, easy.

You can also manually rotate the Kindle 2 screen, previously a DX-only feature.

Here's how things look on the Kindle 2 with a PDF using the older firmware, then using the new 2.3 firmware. The first PDF I'm using for A-B testing is "Producing Open Source Software" from http://www.producingoss.com. I also use the free ASP.NET MVC chapter from http://tinyurl.com/aspnetmvc.

Now, a pile of screenshots because there's no other way to get the point across. Forgive me.

NOTE: You can click any of these images to get the FULL 800x600 resolution screenshot directly from my Kindle 2.

Firmware 2.0.3 - a PDF converted by emailing to my Kindle

Firmware 2.3 - Same PDF viewed with the Native PDF Viewer

Firmware 2.3 - Wrox Book Cover viewed with the Native PDF Viewer

Firmware 2.3 - Wrox Book viewed with the Native PDF Viewer ROTATED

Firmware 2.3 - Wrox Book viewed with the Native PDF Viewer

Most importantly, is Code readable? Well, yes and no. It's readable, but it's not comfortable. It depends on the code and on the way the PDF is formatted. In the Wrox PDF example, the code was formatted kind of gray, which doesn't help given the Kindle screen. The important thing to note is that PDF formatting and fonts appear to be respected 100%. If it's clear and readable on your PC, it'll at least be readable on the Kindle, assuming the limitations of the screen hardware.

Note that when you rotate the screen (with the font button) that you can see the layout and text more clearly, but you'll only see the top or bottom half of the page. When you hit Prev/Next Page you'll move up and down the page before you actually turn a page. It's not perfect, but it's something.

Firmware 2.3 - Wrox Book with Code and Tables viewed with the Native PDF Viewer

Firmware 2.3 - Wrox Book with Code and Tables viewed with the Native PDF Viewer ROTATED

Conclusion

For a standard A4 or 8.5x11" page, it's not really easy to read on a 3.6 in (91 mm) × 4.8 in screen. Expect to read PDFs rotated.

Your Kindle 2 just got a new lease on life. This is totally new, free functionality for your Kindle 2. It's now a competent PDF reader. If you're a coder or a PDF reader, be thrilled. Now go get it.

Microsoft CFO Liddell to leave by year-end(Mary Jo Foley)

Tue, 24 Nov 2009 20:33:53 -0800

http://feedproxy.google.com/~r/zdnet/microsoft/~3/z6b65BAv4eI/

Microsoft Chief Financial Officer (CFO) Chris Liddell is leaving Microsoft after four years to pursue other interests, company officials announced via a November 24 press release issued quietly just before the start of the Thanksgiving holiday.

Microsoft isn't the only one developing a hardware-accelerated browser(Mary Jo Foley)

Tue, 24 Nov 2009 07:40:17 -0800

http://feedproxy.google.com/~r/zdnet/microsoft/~3/4wqRR6olJTc/

Microsoft, with IE 9, isn't the only browser provider planning to harness hardware acceleration. Mozilla is planning to do the same with Firefox. Firefox developers have posted a prototype demonstrating the ability to take advantage of Direct2D and DirectWrite. Google is interested in the possibilities of hardware-accelerating Chrome, as well, as News.com's Stephen Shankland notes.

Can (and will) Microsoft keep Silverlight compatible across platforms?(Mary Jo Foley)

Tue, 24 Nov 2009 06:47:25 -0800

http://feedproxy.google.com/~r/zdnet/microsoft/~3/-FRUOyQCEX0/

Microsoft is adding more and more WPF features to Silverlight (and vice versa). But there is a downside to this strategy: By adding technologies like COM support to Silverlight, Microsoft is doing damage to its story that Silverlight is a cross-platform browser plug-in that supports Windows, Mac -- and, thanks to the Mono folks at Novell , Linux -- equally.

Oredev Keynote - Information Overload and Managing the Flow: Effectiveness and Efficiency(Scott Hanselman)

Mon, 23 Nov 2009 14:36:03 -0800

http://feedproxy.google.com/~r/ScottHanselman/~3/lLrhIJIb9kQ/OredevKeynoteInformationOverloadAndManagingTheFlowEffectivenessAndEfficiency.aspx

I am by no means an expert on being effective or doing things efficiently, but I do OK and I get some stuff done. Most importantly, I think, I am attempting at least to be conscious as I do work.

Recently I was in Malmo, Sweden presenting at the Øredev conference. I presented this keynote as well as a talk on ASP.NET MVC 2 and also did a few panels, one of which we recorded LIVE and streamed online.

Here's my talk from that Friday keynote. I include links to each of the Creative Commons photos I used from Flickr, as well as links to each of the web pages where I did my research or where I used a diagram. I also tried to call out each place where the thoughts were not mine.

This talk is/was a mashup of the various techniques that I try to apply in my everyday life. There's a little GTD, a little Covey, a little Pomodoro, a little Jon Udell, a little 43 Folders, a little Merlin Mann, a little Gina Trapani, and a little Hanselman. I also show some of the tools I used to manage the flow of information in my life. I hope you enjoy it. I'm pretty happy with the way it turned out, given that I was freaking out about it for a week.

You can watch the talk in HD here, or if you're viewing this page from hanselman.com directly, you can watch it embedded below. The sound is a little hot (it's overdriven by the sound guy) so please forgive us.

Scott Hanselman - Information Overload and Managing the Flow from Øredev on Vimeo.

IE8 SmartScreen in action(ieblog)

Mon, 23 Nov 2009 13:32:00 -0800

http://blogs.msdn.com/ie/archive/2009/11/23/ie8-smartscreen-in-action.aspx

Last week at PDC, as we were about to start talking to people about IE9, I saw the following notification from my Facebook account:

From: Facebook [mailto:notification+mwm5axbx@facebookmail.com]
Sent: Tuesday, November 17, 2009 10:05 AM

Dina posted something on your Wall and wrote:

"funny vid of u, you see it? http://www.facebook.com/l/ca339;hTTP://www.N70.InFO/2d"

To see your Wall or to write on Dina's Wall, follow the link below:

<..>

Thanks,

The Facebook Team

The message was from someone I know pretty well, and I believed the message. The address itself (http://www.n70.info/2d) wasn’t that suspicious; there are a lot of URL shortening services, and the .info domain has many legitimate sites on it. So I clicked the it:

and thought – whew.

IE8’s SmartScreen now blocks malware sites over two million times a day. IE8 offers a lot of protection from real-world attacks: phishing protection, a cross-site scripting filter, and Protected Mode (I may run as an administrator, but my browser doesn’t). With attacks on the rise, using (or upgrading to) a browser with this much protection is more important than ever. IE8 also offers great reliability because of process-isolation, and offers users the ability to manage add-ons that affect performance and stability. InPrivate Browsing and InPrivate Filtering are also quite handy.

I wrote back to my friend, and she was surprised. You can read Facebook’s guidance about what to do if this happens to you or a friend.

Dean Hachamovitch

Migrating ASP.NET MVC 1.0 applications to ASP.NET MVC 2 Beta (updated!)(Eilon)

Mon, 23 Nov 2009 11:55:47 -0800

http://weblogs.asp.net/leftslipper/archive/2009/11/23/migrating-asp-net-mvc-1-0-applications-to-asp-net-mvc-2-beta-updated.aspx

Thanks to the great feedback I’ve received on my ASP.NET MVC conversion tool for ASP.NET MVC 2 Preview 2 I’ve updated it to support conversions to ASP.NET MVC 2 Beta. I’ve included a number of bugs fixes and improvements based on the feedback:

The JavaScript files have been updated to be compatible with ASP.NET MVC 2 Beta
A “Scripts” folder will be automatically created if one does not already exist
References to the System.Web.Mvc.dll assembly will be updated to use the fully-qualified name (public key token, etc.)
UI improvements

Download

The app is a single executable: Download MvcAppConverter.zip (226 KB).

Usage

The only requirement for this tool is that you have .NET Framework 3.5 SP1 on the machine. You do not need to have Visual Studio or ASP.NET MVC installed (unless you want to open your project!). Even though the tool performs an automatic backup of your solution it is recommended that you perform a manual backup of the solution as well.

To convert an ASP.NET MVC 1.0 project built with Visual Studio 2008 to an ASP.NET MVC 2 project in Visual Studio 2008 perform these steps:
- Launch the converter
- Select the solution
- Click the “Convert” button
To convert an ASP.NET MVC 1.0 project built with Visual Studio 2008 to an ASP.NET MVC 2 project in Visual Studio 2010:
- Perform the above steps, then open the project in Visual Studio 2010 and it will perform the remaining conversion steps

What it can do

Open up ASP.NET MVC 1.0 projects from Visual Studio 2008 (no other versions of ASP.NET MVC or Visual Studio are supported)
Create a full backup of your solution’s folder
For every VB or C# project that has a reference to System.Web.Mvc.dll it will (this includes ASP.NET MVC web application projects as well as ASP.NET MVC test projects):
- Update references to ASP.NET MVC 2
- Add a reference to System.ComponentModel.DataAnnotations 3.5 (if not already present)
For every VB or C# ASP.NET MVC Web Application it will:
- Change the project type to an ASP.NET MVC 2 project
- Update the root ~/web.config references to ASP.NET MVC 2
- Update the root ~/web.config to have a binding redirect from ASP.NET MVC 1.0 to ASP.NET MVC 2
- Update the ~/Views/web.config references to ASP.NET MVC 2
- Add or update the JavaScript files (add jQuery, add jQuery.Validate, add Microsoft AJAX, add/update Microsoft MVC AJAX, add Microsoft MVC Validation adapter)
Unknown project types or project types that have nothing to do with ASP.NET MVC will not be updated

What it can’t do

It cannot convert projects directly to Visual Studio 2010 or to .NET Framework 4.
It can have issues if your solution contains projects that are not located under the solution directory.
If you are using a source control system it might have problems overwriting files. It is recommended that before converting you check out all files from the source control system.
It cannot change code in the application that might need to be changed due to breaking changes between ASP.NET MVC 1.0 and ASP.NET MVC 2. Consult the readme for information on breaking changes.

Feedback, Please!

If you need to convert a project to ASP.NET MVC 2 please try out this application and hopefully you’re good to go. If you spot any bugs or features that don’t work leave a comment here and I will try to address these issues in an updated release.

Orchard team looking for a new developer(Bertrand Le Roy)

Mon, 23 Nov 2009 11:24:19 -0800

http://weblogs.asp.net/bleroy/archive/2009/11/23/orchard-team-looking-for-a-new-developer.aspx

My team is looking for a new full-time developer. The project is to build a completely new open-source CMS based on ASP.NET MVC 2. It’s a lot of fun :)

https://careers.microsoft.com/JobDetails.aspx?ss=&pg=0&so=&rw=1&jid=9434&jlang=EN

Office Starter 2010: The fine print on Microsoft's Works replacement(Mary Jo Foley)

Mon, 23 Nov 2009 07:33:23 -0800

http://feedproxy.google.com/~r/zdnet/microsoft/~3/IjCGgtAxIUk/

More information is coming in from various testers regarding the Office Starter 2010 build that Microsoft released to a group of selected testers late last week -- including details on macro and file type support. Do any of these make Office Starter a non-starter, in your book?

Enabling the ASP.NET Ajax script loader for your own scripts(Bertrand Le Roy)

Mon, 23 Nov 2009 07:00:00 -0800

http://weblogs.asp.net/bleroy/archive/2009/11/23/enabling-the-asp-net-ajax-script-loader-for-your-own-scripts.aspx

In previous posts, I’ve shown different ways to build a client-side class browser, using the ASP.NET Ajax Libary and jQuery.

In this post, I’ll focus on a few lines of code from the latest version of that sample. Those few lines of code enable my custom script to benefit from the script loader’s features such as lazy and parallel loading and dependency management.

An important feature of the script loader is the separation of the script meta-data from the script code itself. The meta-data can include the name of the script, its dependencies, instructions on how to figure out if it’s already loaded, its debug and release URL patterns and a declaration of the lazy components and plug-ins it introduces. The script loader can also handle composite scripts but I won’t cover that in this post.

The name of the script is what will be used to reference it from other scripts and to generate the URL from a pattern. It shouldn’t include the “.js” extension.
The dependencies and executionDependencies are each a simple array of script names that the script depends on. I’ll explain the difference in a minute.
The is loaded criterion is a JavaScript expression that returns true if the script is already loaded. This is usually a test on an object that the script file defines. For example, the “templates” script uses !!(Sys.UI && Sys.UI.Templates). It can assume Sys because it’s defined by start.js.
Debug and release patterns are expressions that enable the framework to map script names into debug and release URLs. The ASP.NET Library uses “%/MicrosoftAjax{0}.debug.js” and “%/MicrosoftAjax{0}.js” where % gets replaced with the path where the script loader was downloaded from (this can be CDN or local) and {0} gets replaced with the script name. You can create your own pattern or just provide fixed URLs if you have only one script file. The debug pattern is optional.
Lazy components and plug-ins are helpers that the script loader can create for you and that enable developers to start using your components before they are even loaded and hide the script loading aspects as much as possible. For example, it’s that feature that enables you to write this while still having only start.js loaded:
```
Sys.create.dataView("#myDataView", { data: myData
});
```
The code that needed to be written for this helper to be created was this:
```
behaviors: ["Sys.UI.DataView"]
```
This gets automatically transformed by the script loader into the Sys.create.dataView method, before it even tries to load the actual script that defines Sys.UI.DataView. And if you have jQuery loaded as well, you’ll also get a jQuery plug-in out of it for free, which means that you can do:
```
$(".data").dataView({data: myData});
```
and instantiate DataView controls over the results of a selector query in one operation. Groovy. Of course, you can do the same with the behaviors and controls that you write in your own scripts, with lots of options to customize names, add parameters, etc.

In the case of the class library code, here’s the meta-data declaration code that I had to write:

Sys.loader.defineScript({ name: "classBrowserTree", releaseUrl: "%/TreejQuery.js", executionDependencies:
 ["jQuery", "Templates", "ComponentModel"], isLoaded: !!(window.jQuery &&
 window.jQuery.fn.classBrowserTreeView)
});

This declares that my script, named “classBrowserTree”, can be found at the URL TreejQuery.js relative to the base URL of the script loader, that it depends on jQuery, Templates and ComponentModel (which themselves have their own dependencies) and that the loader can determine whether it’s already loaded by evaluating the classBrowserTreeView jQuery plug-in.

Now, loading that script and all its dependencies is as simple as writing this:

Sys.require(Sys.scripts.classBrowserTree);

Notice that as you’re typing this, you actually get full IntelliSense in Visual Studio on the name of the script, which is great for speed and to avoid typos:

One of the things that enable the script loader to do its job is a special way to write your script that makes it possible to separate the loading and parsing of the code from its execution.

Don’t freak out (yet) though as the code you have to introduce is very lightweight and it doesn’t prevent your script from being loaded without the script loader (with a plain old script tag for example).

Reversely, a script that doesn’t have the special script loader code can be handled by the script loader but its dependencies must be declared using “dependencies” instead of “executionDependencies” in the meta-data declaration code, which will in effect disable the more advanced features of the script loader such as parallel loading.

The special code in question is the following:

(function() { function execute() { // Your code goes here.
 } if (window.Sys && Sys.loader) { Sys.loader.registerScript(
 "classBrowserTree", null, execute); } else { execute(); }
})();

What you see here is a (function() {…})(); wrapper, which is standard practice to isolate code from the global namespace (essentially, it’s a local scope); we also have another named scope in there that we arbitrarily call “execute” (but the name doesn’t matter). This is where you’ll typically put your actual code. Then we have the bootstrapping code that looks for the script loader. If it isn’t found, the code in the execute function is immediately run. If it is found, the execute function is registered with the script loader but is not immediately executed.

This wrapper code is what enables the script loader to do its magic. Thanks to this little bit of code, it doesn’t care at all in what order the scripts are being loaded, because it can delay the time when any script actually gets executed until all its dependencies have been successfully loaded.

This also allows the script loader to load scripts in parallel, even if one depends on another. Normally a script loader would have to download a dependent script first and wait for it to completely load before loading the next script. This ‘serializes’ the loading process and is not good for performance. Modern browsers can download 6 to 8 scripts simultaneously. Separating the loading of a script from its execution allows the loader to take advantage of that, and in most cases, even complex dependency trees can be downloaded completely in parallel, meaning the total time is not the sum of each script, but only the longest one.

Of course, in order to be wrappable, your code needs to be able to run in a non-global scope. This is good practice anyways and is relatively easy to achieve in most cases, so if it can’t, it may be a good idea to try to determine why and fix it.

And this is it. I hope I’ve convinced you that the script loader can help you to improve the performance of your applications at a really low cost. It also provides a very worthy client-side equivalent of the server-side ScriptManager that ASP.NET has been providing to developers for years: switching the whole application between debug and release scripts is a breeze, which minimizes the risk of deploying debug scripts in production; dependencies are being handled automatically; script combination is handled.

(many thanks to Dave Reed for helping with this post and of course for implementing an awesome script loader)

LIDNUG: Online chat with me Monday Nov 23rd(ScottGu)

Sun, 22 Nov 2009 23:30:16 -0800

http://weblogs.asp.net/scottgu/archive/2009/11/22/lidnug-online-chat-with-me-monday-nov-23rd.aspx

This past week was a busy one – with lots of announcements and cool releases happening at this year’s PDC conference. All of the PDC keynotes and breakout sessions are now posted online for anyone to watch for free. You can find sessions to watch here.

My PDC keynote covered our new Silverlight 4 release and was on Day 2. You can watch it here (I start at the 1 hour, 2 minute, and 45 second mark).

LIDNUG Online Chat Monday November 23rd

I’ll be doing a free online web chat Monday November 23rd at 11:30am PST where you can ask any questions about anything (including PDC announcements).

The chat is hosted by the LIDNUG user group. You can sign up and attend for free here. The chat will be recorded and I’ll update this post with a link to the recording when it is over.

You can ask questions either through the chat tool – or by posting them to Twitter. To ask questions via twitter simply post a tweet using this format:

@ScottGu #LidnugLiveQ question goes here

Post Show Update: You can now download the audio version of the talk here.

Other PDC Resources

I’ll be doing more blog posts about some of what was announced at PDC this past week. Below are a few good posts that summarize some of the announcements from my team in the meantime:

Silverlight 4 Overview
Silverlight 4 Resources (includes links to all SL4 videos at PDC)
ASP.NET MVC 2 Beta
ASP.NET AJAX Library Beta

Hope this helps,

Scott

P.S. In addition to blogging, I’m also now using Twitter for quick updates and to share links. Follow me at: twitter.com/scottgu (@scottgu is my twitter name)

Office Starter 2010 private beta, with 'Office to GO,' goes to testers(Mary Jo Foley)

Fri, 20 Nov 2009 08:21:02 -0800

http://feedproxy.google.com/~r/zdnet/microsoft/~3/Q2ONGX9RpsE/

Microsoft released a bunch of public betas of various Office 2010 products this week. But it also released another one under non-disclosure to a select group of testers: Office Starter 2010. Microsoft made the code for Office Starter 2010 available to select testers via its Connect Web site late this week.

Will Microsoft's Silverlight dampen the appeal of Google's Chrome OS?(Mary Jo Foley)

Fri, 20 Nov 2009 06:40:03 -0800

http://feedproxy.google.com/~r/zdnet/microsoft/~3/G9ngLTSNpqY/

I'm not one of those ready to write Windows an RIP certificate now that Google has finally taken (some of) the wraps off its Chrome OS. In fact, after reading through industry watchers' questions and Google's answers about it, I'm thinking that Chrome OS may not look quite so appealing by the time it rolls out in late 2010. Here's why.

Microsoft still working on an Adobe Lightroom competitor, but with a social twist(Mary Jo Foley)

Thu, 19 Nov 2009 07:28:07 -0800

http://feedproxy.google.com/~r/zdnet/microsoft/~3/e1PNgq9XabA/

It's been almost two years since I first got tips about Microsoft "SmartFlow," a product which allegedly was going to be a competitor with Adobe's Photoshop Lightroom post-production software for professional photographers. I had thought that incubation project may have been quietly eliminated somewhere along the way. But it's still alive and is in a new group with a new twist.

RIA Services: Jumpstarting RIA Development()

Thu, 19 Nov 2009 01:03:31 -0800

http://www.nikhilk.net/RIA-Services-Jumpstarting-RIA-Development.aspx

In my post on RIA Services: From Vision to Architecture, a while back (right after MIX09), I mentioned that I like to think of RIA Services as RAD for RIA. At that point we had a very early preview of framework bits with little tools support. A large part of jumpstarting your development actually centers around good tooling. VS2010 brings tooling for RIA Services (now: WCF RIA Services).

Scott Hanselman demonstrated some key features used in building a Contacts application (as shown on the right) during the keynote at PDC09.

The latest version of RIA Services is now available for download. It works on .NET 4 and VS2010 as well. You can also check out a video tutorial on using RIA Services and Visual Studio 2010.

In this post, I want to highlight the range of tooling features that span from the start to getting an application up and running.

[Full post continued here...]

Pivot: Microsoft's experiment to 'view the Web as a web'(Mary Jo Foley)

Wed, 18 Nov 2009 15:10:44 -0800

http://feedproxy.google.com/~r/zdnet/microsoft/~3/aAY96Qn2fDg/

Microsoft's Live Labs -- its Research and MSN mash-up -- fielded a new test project on November 18 known as "Pivot." Pivot (not to be confused with Microsoft's recently renamed PowerPivot) is meant to combine search, browsing and recommendations to create a more unified Web experience, according to a description on the Live Labs Web site.

Silverlight 4 Debuts with Killer Demos at PDC09()

Wed, 18 Nov 2009 14:35:45 -0800

http://www.nikhilk.net/Silverlight4-Killer-Demos-At-PDC09.aspx

Lots of wow from this morning with Silverlight 4 (and RIA Services) taking center stage in the keynote, here at PDC09.
[Full post continued here...]

Microsoft shares a few tidbits on IE9 and (lots) more on Silverlight 4(Mary Jo Foley)

Wed, 18 Nov 2009 11:20:09 -0800

http://feedproxy.google.com/~r/zdnet/microsoft/~3/rl9KcwIzluw/

Microsoft shared some information about what's coming in Internet Explorer 9 and Silverlight 4 during its November 18 Professional Developers Conference (PDC) keynotes.

Microsoft Office 2010, SharePoint 2010 public betas now available for download(Mary Jo Foley)

Wed, 18 Nov 2009 10:11:09 -0800

http://feedproxy.google.com/~r/zdnet/microsoft/~3/QVjKUzCGUNg/

Microsoft released on November 18 the public beta of Office 2010. It can be downloaded by anyone for free, as of 1 pm ET today, as can new public betas of SharePoint Server 2010 and Office Web Apps.

An Early Look At IE9 for Developers(ieblog)

Wed, 18 Nov 2009 09:23:00 -0800

http://blogs.msdn.com/ie/archive/2009/11/18/an-early-look-at-ie9-for-developers.aspx

We’re just about a month after the Windows 7 launch, and wanted to show an early look at some of the work underway on Internet Explorer 9.

At the PDC today, in addition to demonstrating some of the progress on performance and interoperable standards, we showed how IE and Windows will make the power of PC hardware available to web developers in the browser. Specifically, we demonstrated hardware-accelerated rendering of all graphics and text in web pages, something that other browsers don’t do today. Web site developers will see performance gains and other benefits without having to re-write their sites.

Performance Progress. Browser performance involves many different sub-systems within the browser. Different sites – and different activities within the same site – place different loads and demands on the browser.

For example, two news sites might look similar to a user but have very different performance characteristics. Because of how the developers authored the sites, one site might spend most of its time in the Javascript engine and DOM, while the other site might spend most of its time in layout and rendering. A site that’s more of an “application” than a page (like web-based email, or the Office Web Apps) can exercise browser subsystems in completely different ways depending on the user’s actions.

The chart below shows how much time different sites spends in different subsystems of IE. For example, it shows that one major news site spends most of its time in the script engine and marshalling, while another spends most of its time in script and rendering, and the Excel Web App spends very little of its time running script at all.

Note that this chart shows the percentages of total time spent in each subsystem, not relative time between sites. It focuses on just the primary browsing sub-systems and doesn’t include “frame” functionality (like anti-phishing), or third-party software that’s running in the IE process (like toolbars, or controls like Flash). It also factors out networking since that’s dependent on the users network speed. Notice also that a site’s profile can change significantly across scenarios; for example, the Excel Web App profile for loading a file is quite different from the profile for selecting part of the sheet.

The script engine is just one of these browser subsystems. There are many benchmarks for script performance. One common test of script performance is from Apple’s Webkit team, the SunSpider test. The chart below shows the relative performance of different browsers on the same machine running the SunSpider test.

In addition to IE7 and the current “final release” versions of major browsers, we’ve included the latest pre-release “under development” builds of the major browsers. We’re just about a month after IE8 was released as part of the Windows 7 launch, and the version of IE under development is no longer an outlier.

It is worth noting that once the differences are this small, the other subsystems that contribute to performance become much more important, and perceiving the differences may be difficult on real-world sites. That said, we remain committed to improving script performance.

We’re looking at the performance characteristics of all the browser sub-systems as real-world sites use them. Our goal is to deliver better performance across the board for real-world sites, not just benchmarks.

Standards Progress. Our focus is providing rich capabilities – the ones that most developers want to use – in an interoperable way. Developers want more capabilities in the browser to build great apps and experiences; they want them to work in an interoperable way so they don’t have to re-write and re-test their sites again and again. The standards process offers a good means to that end.

As engineers, when we want to assess progress, we develop a test suite that exercises the breadth and depth of functionality. With IE8, we delivered a highly-interoperable implementation of CSS 2.1 and contributed over 7,200 tests to the W3C. Standards that do not include validation tests are much more difficult to implement consistently, and more difficult for site developers to rely on.

Some standards tests – like Acid3 – have become widely used as shorthand for standards compliance, even with some shortcomings. Acid3 tests about 100 aspects of different technologies (many still in the “working draft” stage of standardization), including many edge cases and error conditions. Here’s the latest build of IE9 running Acid3:

As we improve support in IE for technologies that site developers use, the score will continue to go up. A more meaningful (from the point of view of web developers) example of standards support involves rounded corners. Here’s IE9 drawing rounded corners, along with the underlying mark-up:

Another example of standards support that matters to web developers is CSS3 selectors. Here’s a test page that some people in the web development community put together at css3.info; it’s a good illustration of a more thorough test, and one that shows some of the progress we’ve made since releasing IE8:

Community testing efforts like this one can be helpful. Ultimately, we want to work with the community and W3C and other members of the working groups to define true validation test suites, like the one that we’re all working on together for CSS 2.1, for the standards that matter to developers. For example, this link tests one of the HTML5 storage APIs; some browsers (including IE8) support it today, while others don’t.

The work we do here, both in the product and on test suites, is a means to an end: a rich interoperable platform that developers can rely on.

Bringing the power of PC hardware and Windows to web developers in the browser. The PC platform and ecosystem around Windows deliver amazing hardware innovation. The browser should be a place where the benefits of that hardware innovation shine through for web developers.

We’re changing IE to use the DirectX family of Windows APIs to enable many advances for web developers. The starting point is moving all graphics and text rendering from the CPU to the graphics card using Direct2D and DirectWrite. Graphics hardware acceleration means that rich, graphically intensive sites can render faster while using less CPU. (This interview includes screen captures of a few examples.) Now, web developers can take advantage of the hardware ecosystem’s advances in graphics while they continue to author sites with the same interoperable standards patterns they’re used to.

In addition to better performance, this technology shift also increases font quality and readability with sub-pixel positioning:

96 point Gabriola on a Lenovo X61 ThinkPad at 100% Zoom using GDI (note jaggies):

96 point Gabriola on a Lenovo X61 ThinkPad at 100% Zoom: Direct2D (without jaggies):

Last week, Channel 9 interviewed several of the engineers on the team. You can find videos of the interviews here:

Introduction, and Interoperable Standards

Early look at the Script Engine

Hardware accelerated graphics and text in the browser via Direct2D

While we’re still early in the product cycle, we wanted to be clear to developers about our approach and the progress so far. We’re applying the feedback from the IE8 product cycle, and we’re committed to delivering on another version of IE.

Thanks,
Dean Hachamovitch
General Manager, Internet Explorer

Update 11/23/09 - The IE9 demo from PDC is now available. The IE content starts around minute 48.

PDC09 - A Call to Dream()

Tue, 17 Nov 2009 11:15:12 -0800

http://www.nikhilk.net/PDC09-Call-To-Dream.aspx

Immediate thoughts after Ray Ozzie's keynote at PDC09
[Full post continued here...]

PDC week! Panel on OSS + ASP.NET(Bertrand Le Roy)

Mon, 16 Nov 2009 14:13:48 -0800

http://weblogs.asp.net/bleroy/archive/2009/11/16/pdc-week-panel-on-oss-asp-net.aspx

I’ll be at PDC tomorrow, Wednesday and Thursday. If you are attending and want to say hi, you’re most likely to find me in the Web Pavilion (in the big room, next to the Surface lounge).

Please also join us for a panel discussion on Wednesday about Open Source on ASP.NET. We’ll have the following people on the panel to answer your questions, and ask you a few too:

Scott Hanselman
Shaun Walker
Sara Ford
Glenn Block
Clemens Vasters
Myself

The discussion will be between 2PM and 3PM, in the Web Pavilion.

Metrics in software and physics(Bertrand Le Roy)

Fri, 13 Nov 2009 23:32:00 -0800

http://weblogs.asp.net/bleroy/archive/2009/11/13/metrics-in-software-and-physics.aspx

Every so often, somebody points out how bad of a metric code coverage is. And of course, on its own, it doesn’t tell you much: after all, it’s a single number. How could it possibly reflect all the subtlety (or lack thereof) of your designs and of your testing artillery? Of course, within all the various *DD approaches, some better than others enable you to know whether or not your code conforms to its requirements, but I thought I’d take a moment to reflect on the general idea of a software metric and how it relates to the mothers of all metrics: physical ones, cause you know, I used to be a scientist. Proof: the lab coat on the picture.

The theory of measurement is at the center of all experimental physics. This comes from the realization that any observation of the natural world is ultimately indirect.

For example, when you look at a red ball, you don’t directly perceive it. Rather, photons hit it, some of them are absorbed by the surface of the ball (violet, blue, green and yellow ones, but not red ones) and some of them bounce back (the red ones if you’ve been following). Those red photons that bounced back then hit your eyes, where a lens distorts their paths so that all those photons that came from a specific point on the ball converge to roughly the same spot on your retina. Then, the photoreceptor cells on the retina transform the light signal into electric impulses in your optic nerve, which conveys all that information into your brain and then, only then the complex mechanisms of conscience give you the wonderful illusion of seeing a red ball in front of your eyes.

The brain reconstructs a model of the universe, but what it really ever perceives is a pattern of electric impulses. Everything in between is a rather elaborate Rube-Goldberg contraption that can be trusted most of the time but that is actually rather easy to fool. That it can be fooled at all is the simple consequence that what you observe is an indirect and partial measure of reality rather than reality itself.

When we measure anything in physics, we build our own devices that transform objective reality into perceivable quantities. For example, when physicists say they have “seen” a planet around a faraway sun, they don’t (always) mean that they put their eyes on the smaller end of a telescope and perceived the shape of that planet with their own eyes like I saw the red ball of the previous paragraph. No, what they saw is something like this on a computer monitor:This shows the very small (1.5%) variation of the light coming from the star as the planet transits in front of it. All this really tells them is that something dark that takes about 1.5% of the area of the star passed in front of it. By repeating that observation, they can see that it happens every 3.5 days. That’s it. No image, just measures of the amount of light coming out of a powerful telescope aimed at a star against time.

But just from that minimal data and our centuries old knowledge of celestial mechanics, researchers were able to deduce that a planet 1.27 times the size of Jupiter but 0.63 times its mass and a surface gravity about the same as Earth’s was orbiting that star. That’s an impressively precise description of a big ball of gas that is 150 light years away (that’s 1.4 million billion kilometers in case you’re wondering or 880 thousand billion miles if you insist on using an archaic unit system).

The Rube Goldberg device that enables us to see that big ball of gas from so far away is a mix of optics, electronics and knowledge, the latter being the really awesome part. Science is awesome. The bottom line of all this is that although it seems less “direct” than seeing the red ball with our own eyes, it does just as well deserve to be described as “seeing” it. The only difference is that we’re not seeing with our eyes but more with our brains. How awesome is that?

Where was I?

Yes, you might be wondering what this has to do with software. Well, all that long digression was to show that little data is necessary to infer a lot about the object you’re observing. So code coverage? Sure, it’s just a number, but combined with a few other numbers, it can help get a reliable picture of software quality.

Another point I’d like to make is that a lot of resistance to software metrics comes from the illusion that we know a lot more about our own code than any tool can tell us. But as anyone who has ever tried to read code he wrote only five years ago knows, that is delusional. What you know about your code is a combination of what you remember and what you intended to write, neither of which is particularly reliably representative of what your code is doing. Tools give us a much more reliable picture. Sure, it’s a narrow projection of the code and it doesn’t capture its full reality, but that is exactly the point of a measure: to project a complex object along a scale of our choosing. What set of projections you choose to make is what determines their relevance.

The conclusion of all this is that we should assume that our code is an unknown object that needs to be measured, like that big ball of gas 150 light years away, if we want to get an objective idea of its quality without having our judgment clouded by our own assumptions.

And probably the best tool you can use to do exactly this by the way is NDepend by Patrick Smacchia.

My Favorite IE Add-on: Mouse Gestures by Ralph Hare(ieblog)

Fri, 13 Nov 2009 14:45:00 -0800

http://blogs.msdn.com/ie/archive/2009/11/13/my-favorite-ie-add-on-mouse-gestures-by-ralph-hare.aspx

I spend a lot of time dealing with problems users encounter when using Internet Explorer. As a result, when I write about add-ons, I’m usually talking about misbehaving code that is wrecking the browser. However, it’s not all doom-and-gloom out there, and I’m delighted to share my favorite browser add-on with you.

I first came across Ralph Hare’s work when perusing the IE add-on sample code at CodeProject. Ralph and I both liked mouse gestures and wished that Internet Explorer offered them. For those of you who have never used mouse gestures, basically, they allow you to trigger commands like back, forward, refresh, etc, without using the keyboard or clicking on toolbar buttons or menus. While not everyone wants to use mouse gestures, some of us find them incredibly compelling. This sweet spot makes gestures the sort of feature ripe for implementation as an add-on.

Fortunately for all of us, Ralph is a great developer and he put together a fantastic gestures add-on for IE which has evolved and improved a lot over the last six years. I’ve installed his add-on on every computer I’ve used since discovering it, and I now find it annoying to use browsers that don’t support gestures. It’s an ironic turn of events for me, since I’ve been a keyboard snob for over a decade. :-)

What makes this add-on so great?

Respect for the User. The gestures add-on respects your existing browser settings, and does not attempt to change your default homepage, search provider, favorites, user-agent string, etc. There’s no junk (e.g. adware, unexpected toolbars, etc) bundled with it either.

Stability. I’ve tried out a lot of different add-ons over the years, but almost always end up uninstalling each after a few days because they’re unstable and result in occasional or frequent browser crashes. In contrast, Ralph has delivered a rock-solid implementation of gestures; the few bugs I’ve found have been fixed quickly and the updated versions are automatically offered using an automatic notification service.

Best Practices. Ralph’s code is compiled following best-practices for secure and stable add-ons, including linking with the /NXCOMPAT and /DYNAMICBASE flags to opt-in to DEP/NX and ASLR memory protections.

Performance. Many browser extensions are useful from time-to-time, but I’m not willing to suffer a performance penalty when not actively using an extension. For some types of extensions (menu extensions, toolbar buttons) this isn’t a problem, because the add-on code only loads when I actively use the add-on. However, an add-on like Mouse Gestures inherently needs to be available at all times, so high performance is an absolutely critical consideration.

Ralph’s Browser Helper Object (BHO) is written in native C++, and designed and coded for speed. After installing, check out the Load Time column inside the IE Tools > Manage Add-ons dialog:

As mentioned previously, the extension offers an auto-update mechanism, but Ralph ensures that this won't hurt startup performance. He does so by running the check in a background thread, and waiting for about a minute after tab startup to kick off the webservice call. Ralph also sets the NoExplorer registry key to prevent his BHO from loading inside Windows Explorer.

Even the default configuration is optimized for performance: by default, mouse trails aren’t shown, and if a user wants them, they can choose between basic trails:

which work fine with all video cards, and the slightly fancier advanced trails:

which work best with higher-end hardware.

Cross-Version Support. Mouse Gestures is compiled in both 32-bit and 64-bit flavors (installed individually) making the gestures add-on one of the very few available for 64-bit IE. The add-on works in all versions of IE and I’ve personally used it on Windows XP, Server 2003, Vista, Server 2008, and Windows 7 without problems.

Ease-of-Installation. The 32bit and 64bit installers together weigh in just under 1 megabyte. The add-on is packaged using the same NSIS installer that I use to install Fiddler.

If you decide you don’t like the add-on, you can easily uninstall it using the Add/Remove Programs control panel.

Customizability and Power. You can customize its options using the Mouse Gestures… item added to the browser Tools menu. The configuration dialog allows you to assign gestures to built-in actions, define new gestures or actions, and change the appearance of mouse trails.

The most common gesture I use is Down,Right which by default is bound to the Close Tab action. I’ve also bound the Down,Up and Up,Down gestures to the Toggle FullScreen Mode action; this is slightly simpler than hunting for the F11 key on my small but beloved Lenovo X200.

If you’d like, you can bind any gesture to open any of your browser Favorites in the current tab, or a new foreground or background tab.

One of the most powerful features of the add-on allows you to bind a JavaScript file to an action. I use this feature to bind a simple page cleanup script to the Left,Right gesture. When I’m reading an online newspaper or similar page with flashing images or other unwanted distractions, I simply hold the right mouse button and waggle the mouse—all of the images and flash objects are instantly removed, allowing me to read in peace.

Price. Mouse Gestures add-on is clearly a labor of love, and Ralph makes it available for free. If you’d like, you can help defray his web hosting costs using the unobtrusive “Donate via Paypal” link buried at the bottom of his site.

Conclusion

If you’re willing to get hooked on a new way of interacting with your browser, give Ralph’s Mouse Gestures add-on a try, and join me in thanking Ralph Hare for his great work!

Eric Lawrence

Our little team is growing - Welcome to Jon Galloway and Pete Brown(Scott Hanselman)

Thu, 12 Nov 2009 13:54:31 -0800

http://feedproxy.google.com/~r/ScottHanselman/~3/i-6GOJVi0UI/OurLittleTeamIsGrowingWelcomeToJonGallowayAndPeteBrown.aspx

Just about two years ago I joined Microsoft. I'm fortunate to work in a home office with a great team that I now lead. We work for the group at Microsoft that runs MSDN, TechNet, ASP.NET, Silverlight.NET, WindowsClient.NET, basically all the online education stuff. The giant group is called STO (Server & Tools Online) and our little group is "stoninja." That's our internal mailing alias.

We create content for all of the sites above but we're also active members of the community. We listen and drive feedback back into the product group. We're not part of the product evangelism group (DPE - Developer Platform Evangelism), but rather we focus primarily on online content creation. I like to think that we're the team that happens you after you go File|New Project, although we're constantly influencing what happens on both sides.

Fast forward to today and my little team is growing.

I'd like to announce that Jon Galloway is joining my team, he's coming to work for us via our good friends at Vertigo (who just announced a new Vertigo Software - Portland office which is cool). It's a bit of a change for Jon and it's something he's always wanted to do. Jon's official title will be Community Program Manager but I like to think of each member of the team as a Community Liaison. We're a small group, but we're sneaky (like ninjas, just fat, middle-aged somewhat pasty ninjas) and we are continually applying pressure to what we think are the right places within Microsoft.

You might know Jon from the Herding Code podcast he does with K. Scott Allen, Kevin Dente and Scott Koon. You might have read the ASP.NET 2.0 Anthology book that he worked on with Jeff, Phil, K. Scott and Wyatt. Jon's also done open source and works on SubText. Jon will be focusing on ASP.NET (all of it). He'll help get the http://asp.net site in shape and provide a much needed pragmatic view of all things web.

Also joined just a few weeks ago is Pete Brown. Pete comes to us after a long stint as .NET Architect, Project Manager, and Client Technologies Evangelist at Applied Information Sciences (AIS).

You may know Pete from his amazing C64 Emulator port to Silverlight. Pete has been working on the WindowsClient.NET site creating content and code samples that show some of the cool stuff you can do in Windows 7. He's started a multi-part video series just recently on the Windows 7 Sensor and Location APIs and will be filling the Learn section with even more great videos as well as working on http://msdn.com/windows.

When I came to work at Microsoft I posted a Venn diagram that looked like this:

I hope Jon and Pete's personal Venn diagram looks like mine, or since they are working from home (my whole team is remote) perhaps like this one ;)

Please welcome both Jon and Pete to the team! The whole team - Me, Joe, Jesse, Tim, Pete and Jon - will be at PDC this year so do stop us and say Hello if you're there!

Download Podcasts with Powershell(Scott Hanselman)

Mon, 09 Nov 2009 15:38:18 -0800

http://feedproxy.google.com/~r/ScottHanselman/~3/7gprmpbsbS0/DownloadPodcastsWithPowershell.aspx

A number of people have mentioned to me that they didn't realize that Powershell is included by default in Windows 7. If you haven't yet jumped on the Powershell bandwagon, this is a good time. Powershell 2 includes a bunch of cool features like remoting (kind of like SSH) as well as a visual IDE for writing, editing and interactively debugging Powershell scripts.

Powershell great for system administration, but I mostly use it for quick and dirty "portable" apps that I don't feel like writing C#/VB for. Plus, I'm using .NET anyway, so it's all the same.

I wanted to download all my podcasts with Powershell, so I wrote this quick script in about 5 minutes. Other improvements I (or preferably you) could make to it could be: check the file size against the enclosure and re-download partials, rename the files to included a version of the title, include a progress bar.

Here's what I came up with. Perhaps you'll find it useful if you're not an iTunes/Zune person:

cd "C:\users\scottha\desktop\Hanselminutes Complete Download"
[Environment]::CurrentDirectory=(Get-Location -PSProvider FileSystem).ProviderPath
$a = ([xml](new-object net.webclient).downloadstring("http://feeds.feedburner.com/HanselminutesCompleteMP3"))
$a.rss.channel.item | foreach{ 
 $url = New-Object System.Uri($_.enclosure.url)
 $file = $url.Segments[-1]
 $file
 if (!(test-path $file))
 {
 (New-Object System.Net.WebClient).DownloadFile($url, $file)
 }
}

Of course you'll want to change the first line and the RSS Feed URL as you like.

If you've never used Powershell before, note that it's locked down from running scripts be default. You'll need to run it as Administrator once and run

Set-ExecutionPolicy unrestricted

This opens it up to run scripts, but it's not only VBS, the scripts won't run if you double-click them. You need to run powershell then type the name of your script to run it:

.\myscript.ps1

You can always set the execution policy back if it bothers you.

Hope this primitive mass podcast enclosure downloader is useful.

Herding Cats: Organize your Desktop Icons with Stardock Fences for Windows(Scott Hanselman)

Sun, 08 Nov 2009 01:32:15 -0800

http://feedproxy.google.com/~r/ScottHanselman/~3/-sPcg8aSXEk/HerdingCatsOrganizeYourDesktopIconsWithStardockFencesForWindows.aspx

There are few issues that divide computer people like that thousand-year-old question: How many icons should you have on your desktop? Some folks say, "Load 'em up! Make those pixels work for you." Others say, "I like a fresh ~~bowl~~ desktop with no icons." Some folks find a spot in between with just My Computer and the Recycle Bin.

For me, the desktop is my work space. It's where I live and breathe and it's in front of my face all the time. I want as much information on there as possible. If I wanted a picture of the beach, I'd live at the beach and look up from my keyboard.

I'm thrilled with Windows 7. Frankly, I'm not sure what I'm going to do with all the free time that I'm saving not dicking around with my computer trying to get it to work. Many of the tools I've espoused over the years simply aren't needed in Windows 7 as they were filling gaps that are no longer there.

That said, Fences from Stardock is one of those apps that extends Windows in such a comfortable and natural way, it should be built in. What's wonderful about Fences is that it is so subtle but so powerful that it truly becomes part of Explorer and feels like it's always there. It's not like to many loud or garish utilities that take over some aspect of Windows and feel the need to announce their presence with bright colors obnoxious splashscreens.

Kudos, truly, to Stardock for showing not only a sense of restraint but also for embracing what I think of as the "new Windows aesthetic." Years of ridiculous toolbars, poor icon design, the Crayola-color themes of Windows XP and general gaudiness has watered down Windows and made it almost impossible to consider it an "visually attractive" OS. I think it's great that Windows 7 has a definable style that developers are embracing. I'm thrilled each time I download and play with some throwaway little utility but the developer has taken the time to integrate a Windows 7 feature like JumpLists, Taskbar Progress or even just taken the time to create a decent high-res icon. This is definitely a cue we can take from the Apple folks.

Fences Augments Windows Explorer

Back to Fences. It allows you to create just that - little "Fences" around icons on your desktop. The Fences can be any color and can have labels or not, or just show labels on mouseover.

To create a Fence you just right-drag a rectangle and click "create new fence here." Alternatively you can select from a series of presets to jump start your organization. You can also take snapshots when you get things just so. I do this for presentations because switching from 1920x1200 to 1024x768 tends to wreak havoc on icons and fences. Snapshots put things back they way they were.

Once you drag an icon into a fence, it auto-arranges with a satisfying animation as all the icons rearrange themselves to make room for the new addition.Another great subtle feature is if you double-click on the desktop it'll hide your icons. This is not only great for presentations where you might not want to let the eating public see the chaos in the kitchen, but it's also a nice compromise for those of you who want a clean desktop, but can also appreciate a a few icons here and there. You can even exclude specific icons (like perhaps My Computer) from quick-hide.

One obscure bug that I hope the Fences guys and gals fix is that there are some applications that take a regular folder, like Live Mesh for example, and "augment" it to make it more than a regular folder. They might change the icons or plug in a sidebar window. For whatever reason, Fences can't see those Folders while they are different. For now, the workaround is to exit Mesh, move the folder into the Fence, then turn Mesh on. Truly a minor irritant and best, but still it'd be nice to see it fixed.

Regardless, I whole-heartedly recommend Fences and encourage you to go download it NOW and try it out. Note that when you install it, you should pay attention to what it installs, as it also added an "auto-updater" for Stardock products that you may want to remove afterwards if those kinds of extra-applets bother you.

Enjoy!

Oredev 2009 - LIVE (now recorded) Closing Panel Video(Scott Hanselman)

Fri, 06 Nov 2009 16:46:44 -0800

http://feedproxy.google.com/~r/ScottHanselman/~3/8w59yqf_eEo/Oredev2009LIVENowRecordedClosingPanelVideo.aspx

I was at Øredev 2009 in Malmö, Sweden this week. Øredev is fast becoming one of the premier conferences in Europe focused on the software development process. It's a consciously technology agnostic conference so there was not only a .NET tracks and a Java track, but also tracks like Agile Ways, User Experience and Cloud Computing.

I believe there were something like 100 speakers so it was an incredibly diverse conference. I hung out with some friends from Sun, an iPhone hacker from AT&T, ASP.NET Debugger Tess Ferrandez, Trygve Reenskaug the inventor of the MVC Model, as well as old friends like Carl and Richard and new ones like James Bach.

Oredev was interesting for a number of reasons, not the least of which being that they didn't use regular plates and utensils, but rather organic ones made from collected banana leaves.

I presented at the keynote on Friday. My topic was "Information Overload and Managing the Flow" and I talked about the differences between Effectiveness and Efficiency and how apply some personal introspective and get more work done. That video will be up soon and I'll post it along with my slides ASAP. I also presented on ASP.NET MVC 2.

Recorded Panel of Silly People

One of the random but fun things we did was the final panel of the conference. These are always silly things, presented just before the beer and chips arrive, and they are a nice way for everyone to blow off steam. Basically some of the ~~biggest egos~~ speakers participate in a panel where questions come from the audience and from Twitter.

The Panel was moderated by Björn Granvik, and the folks on the stage were:

James Bach - Author of Lessons Learned in Software Testing
Ola Bini - Thoughtworker, core developer of JRuby and creator of Ioke
Stu Halloway - Author of Programming Clojure
Me - Me
Oren Eini (Ayende Rahien) - NHibernate Profiler, NHibernate, Castle, Rhino Mocks
Chris Hughes - AT&T iPhone Hacker

Here's the video:

I had the idea to stream this panel live (I've done this a few times - fairly guerilla - at other conferences) over UStream.tv. I figured I'd just point my laptop webcam and crappy integrated mic at the stage and while it'd be lame, it'd be something fun to do as I know there's a bunch of people who'd like to participate.

Turns out the sound and video guys at this conference really know their stuff. We were able to jerry-rig a fairly nice little setup. They took the XLR cables and the complete mix from their mixing board and not only switched it down to a 1/8 male mic jack, but they also change it from line-output to mic-output to deal with my laptops lack of a line input.

Then, a guy said, hey, I've got a Professional Canon DV Video Camera with Firewire. It turns out I had a Firewire port on my laptop and I just plugged his camera in on a lark. Boom, Windows 7 found the drivers online and the Firewire Camera showed up as a webcam.

Using the uStream software, we mixed in video and audio and recorded this 60minute panel discussion.

To be clear, there is likely no actual "content" here. We were asked to "edutain" more than educate as it was the final fun of the conference. We were all pretty good friends by this point so we were flicking the mud fairly liberally.

One warning if you listen to this without headphones, there are about three swear words on the recording.

I hope the fun we had comes out in this spontaneous recording. Also, thanks to the roughly 200 people who heard about this LIVE stream on Twitter and joined the chat and drove the discussion.

If you like this kind of thing, let me know and I'll continue to put together these kinds of web-events. Enjoy!

Hanselminutes on 9 - Debugging Crash Dumps with Tess Ferrandez and VS2010(Scott Hanselman)

Thu, 05 Nov 2009 08:11:41 -0800

http://feedproxy.google.com/~r/ScottHanselman/~3/NM-VgzLgdWo/HanselminutesOn9DebuggingCrashDumpsWithTessFerrandezAndVS2010.aspx

I'm in Sweden this week at Øredev and I got a chance to talk to legendary ASP.NET Debugger and Escalation Engineer Tess Ferrandez.

In this video Tess shows me how to debug a dump of an ASP.NET Web Site with a pile of awesome and totally new features in Visual Studio 2010. You can open up dump files in Visual Studio directly and see visual representations of parallel call stacks. If you spend any time in WinDBG you're going to be excited by these new improvements in the debugging experience.

I also talked to Tess for an extended Debugging 101 session on the full 30 minute audio edition of my Hanselminutes Podcast out later this week.

Enjoy!

November Conferences(ScottGu)

Mon, 02 Nov 2009 22:05:20 -0800

http://weblogs.asp.net/scottgu/archive/2009/11/02/november-conferences.aspx

I’m doing keynotes at two big conferences later this month:

ASP.NET Connections in Las Vegas: November 9th to 12th

I’ll be doing a keynote talking about ASP.NET 4 and VS 2010 at the ASP.NET Connections conference next week. I’ll also be doing an evening Q&A session together with the ASP.NET team.

ASP.NET Connections is a great conference that is jointly hosted with the VS, SharePoint, SQL and Windows Connections conferences (enabling you to choose from tons of great sessions). The speakers at the event are also really top-notch.

You can learn more about the conference and register online here.

PDC in Los Angeles: November 17th to 19th

I’m also doing a keynote at the Microsoft PDC conference in two weeks. The PDC is Microsoft’s big platform conference, where we talk about future platform and technology roadmaps. There is almost always some cool new stuff...

You can learn more about the conference and register online here.

Hope I might be able to see some of you in person at one of these events!

Scott

P.S. In addition to blogging, I’m also now using Twitter for quick updates and to share links. Follow me at: twitter.com/scottgu (@scottgu is my twitter name)

Participating at W3C’s TPAC 2009(ieblog)

Mon, 02 Nov 2009 16:54:00 -0800

http://blogs.msdn.com/ie/archive/2009/11/02/participating-at-w3c-s-tpac-2009.aspx

This week the W3C holds its annual Technical Plenary and Advisory Committee meeting (TPAC 2009). There will be about a dozen people from the IE team participating and this is a valuable opportunity to continue working together with other W3C members on the next generation of web standards. High quality specifications that improve interoperability between browsers are important. Our goal is to help ensure these new standards work well for web developers and will work well in future versions of IE.

We will participate in a number of browser related working group meetings including accessibility, CSS and HTML sessions. For many groups, this is the only face to face time participants will get and so this is a perfect time to put faces to email addresses. Held in Santa Clara, California this year, the close proximity to many of the companies involved in the W3C means a large number of attendees is expected.

Over the last few months, some of us in the IE team have been working through the HTML5 working draft reviewing the specification text. It is interesting to exchange ideas and help the specification become clearer and I am looking forward to seeing many of the people involved again. There has been a long discussion about the submission we made to the HTML working group about distributed extensibility. Tony Ross, the author of our discussion document, will be participating in a panel on extensibility with Jonas Sicking from Mozilla on Wednesday.

Eliot Graff, a lead technical editor for IE, who is helping edit an updated draft of the Canvas API document that Doug Schepers started will also be at the HTML working group meeting this week.

Kris Krueger, one of our lead test managers, has volunteered to help the newly formed Testing Task Force within the HTML working group. Having a comprehensive test suite that thoroughly tests a specification is a key step to ensuring implementations interoperate successfully. Kris will be taking part in the HTML working group meeting on Thursday and Friday.

Paul Cotton, who was recently appointed as a co-chair of the HTML working group as Chris Wilson changed his focus to programmability in the web platform, will also be with us at the TPAC to help the overall work.

On Thursday, the W3C has organised a Developer Gathering for web and application developers who don’t normally participate in the W3C to join discussions about web standards. In my experience the participation of web developers is extremely important to check the overall ease of use of the specifications and APIs being proposed as standards. One of our program managers, Sylvain Galineau, will be amongst the CSS Strike Force presenting CSS demos.

I don’t have room in this short blog post to mention everyone who will be involved this week but I’ve tried to give a flavour for the work that we will be participating in. Above all, it’s fun to hang out with people you mostly see only by email so there will be lots of hallway conversations and debates over lunch or dinner. I can’t wait.

Adrian Bateman
Program Manager

Offline installer for Windows Live Essentials - WLSetup-All.exe(Scott Hanselman)

Sat, 31 Oct 2009 23:52:46 -0700

http://feedproxy.google.com/~r/ScottHanselman/~3/lKMS3cs9ENo/OfflineInstallerForWindowsLiveEssentialsWLSetupAllexe.aspx

My brother and his wife came over today and the kids went trick or treating. His wife mentioned she wanted to make a quick DVD of the pictures and movies we took, so I suggested Movie Maker. However, they only have dial-up and wanted an offline installer I could just put on a USB Stick (I actually figured I'd put it on their camera's SD Card.)

I went to http://download.live.com and searched all over, looking for an offline installer. I Googled with Bing, and then Googled with Google for things like "Windows Live Offline Installer" and found nothing but confusion.

Then I figured out this bizarre bit of UI on the Live Essentials download page. Rather than offering a small link for "offline installer" or a choice, you have to click Download which will attempt to start a Download of Windows Live Essentials online bootstrapper. It will then go and download just the programs you want.

However, if you cancel the download immediately, there's a "Try Again" button and some text that no one (including me) reads:

"Trying again downloads a standalone installer to your computer. This takes a little while, but may work better, depending on your connection settings."

Um, OK. I wouldn't label that Try Again, but OK.

Long story short, here's direct downloads for the Windows Live Essentials English Language ONLINE and OFFLINE installers. They are current as of the writing of this blog post. I'm not sure if they are version-specific downloads but I will try to keep them up to date.

Windows Live Essentials OFFLINE English Installer - 134 megabytes total.
Windows Live Essentials ONLINE English Installer - 1 megabyte bootstrapper

Or, if you want an offline installer in other languages, go to http://download.live.com, click Download, cancel it, then click Try Again. I think it's weird, but there you go.

Enjoy.

JavaScript class browser: once again with jQuery(Bertrand Le Roy)

Fri, 30 Oct 2009 10:43:00 -0700

http://weblogs.asp.net/bleroy/archive/2009/10/30/javascript-class-browser-once-again-with-jquery.aspx

I’ve already posted twice about that little class browser application. The first iteration was mostly declarative and can be found here:
http://weblogs.asp.net/bleroy/archive/2009/09/14/building-a-class-browser-with-microsoft-ajax-4-0-preview-5.aspx

The second one was entirely imperative and can be found here:
http://weblogs.asp.net/bleroy/archive/2009/10/15/entirely-unobtrusive-and-imperative-templates-with-microsoft-ajax-4-preview-6.aspx

This new version builds on top of the code for the imperative version and adds the jQuery dependency in an attempt to make the code leaner and simpler. I invite you to refer to the imperative code (included in the archive for this post) and compare it with the jQuery version, which shows a couple of ways the Microsoft Ajax Library lights up when jQuery is present.

The first thing I want to do here is convert the plain function I was using to build the browser’s namespace and class tree into a jQuery plug-in:

$.fn.classBrowserTreeView = function (options) { var opts = $.extend({},
 $.fn.classBrowserTreeView.defaults,
 options); return this;
};

That plug-in will have two options: the data to render (which will default to the root namespaces in the Microsoft Ajax Library), and the node template selector (which will default to “#nodeTemplate”):

$.fn.classBrowserTreeView.defaults = { data: Type.getRootNamespaces(), nodeTemplate: "#nodeTemplate"
};

For the moment, as you can see, this plug-in does nothing. We want it to create a DataView control on each of the elements of the current wrapped set. We will do this by calling into the dataView plug-in.

You may be wondering where this plug-in might come from. Well, that’s the first kind of lighting up that the Microsoft Ajax Library’s script loader (start.js) will do in the presence of jQuery: every control and behavior will get surfaced as a jQuery plug-in, and components will get added as methods on the jQuery object. This is similar to what I had shown a while ago in this post, only much easier:
http://weblogs.asp.net/bleroy/archive/2009/05/04/creating-jquery-plug-ins-from-microsoftajax-components.aspx

For example, we can write this in our own plug-in to create DataView components over the current jQuery wrapped set:

return this.dataView({ data: opts.data, itemTemplate: opts.nodeTemplate,
});

Now we can wire up the itemRendered event of the data view and start enriching the markup that the DataView control rendered for each data item. First, let’s get hold of the nodes in the rendered template and wrap them:

var elt = $(args.nodes);

Then, if the current node is representing a namespace, we want to hook up the expansion button’s click event so that it toggles visibility of the list of children, and we want to “unhide” the button itself (it has a “hidden” class in the default markup):

if (Type.isNamespace(args.dataItem)) { elt.find(".toggleButton").click(function (e) { e.preventDefault(); return toggleVisibility(this); }).removeClass("hidden");
}

You can see here that we’re taking advantage of chaining.

Next thing is to set-up the node link itself. We start by inhibiting the link’s default action. Then we set the text for the link, and finally we set the command that will bubble up to the DataView when the link gets clicked:

elt.find(".treeNode").click(
 function (e) {
 e.preventDefault();
 return false;
 }) .text(getSimpleName(args.dataItem.getName())) .setCommand("select");

Here, I’m using a small plug-in to set the command:

$.fn.setCommand = function (options) { var opts = $.extend({},
 $.fn.setCommand.defaults, options); return $(this).each(function () { $.setCommand(this,
 opts.commandName,
 opts.commandArgument,
 opts.commandTarget); });
}
$.fn.setCommand.defaults = { commandName: "select", commandArgument: null, commandTarget: null
};

I’m using $.setCommand here, which does get created by the framework for me, but I still need to create that small plug-in to make it work on a wrapped set instead of a static method off jQuery. I’ve sent feedback to the team that setCommand and bind should get created as plug-ins by the framework and hopefully it will happen in a future version.

The last thing we need to do here is to recursively create the child branches of our tree:

elt.find("ul").classBrowserTreeView({ data: getChildren(args.dataItem)
});

This just finds the child UL element of the current branch and calls our plug-in on the results with the children namespaces and classes as the data.

And this is it for the tree, we can now create it with this simple call:

$("#tree").classBrowserTreeView();

The details view rendering will only differ in minor ways from the code we had in our previous imperative version. The only differences is the use of jQuery to traverse and manipulate the DOM instead of the mix of native DOM APIs and Sys.get that we were using before. For example,

args.get("li").innerHTML =
 args.dataItem.getName ?
 args.dataItem.getName() :
 args.dataItem.name;

becomes:

$(args.nodes).filter("li").text(
 args.dataItem.getName ?
 args.dataItem.getName() :
 args.dataItem.name);

Notice how jQuery’s text method makes things a little more secure than the innerHTML we had used before.

Updating the details view with the data for the item selected in the tree is done by handling the select command of the tree from the following function:

function onCommand(sender, args) { if (args.get_commandName() === "select") { var dataItem = sender.findContext(
 args.get_commandSource()).dataItem; var isClass = Type.isClass(dataItem) &&
 !Type.isNamespace(dataItem); var childData =
 (isClass ? getMembers : getChildren)(dataItem); var detailsChild =
 Sys.Application.findComponent("detailsChild"); detailsChild.onItemRendering =
 isClass ?
 onClassMemberRendering :
 onNamespaceChildRendering; detailsChild.onItemRendered =
 onDetailsChildRendered; detailsChild.set_data(childData); $("#detailsTitle").text(dataItem.getName()); $(".namespace").css(
 "display",
 isClass ? "none" : "block"); $(".class").css(
 "display",
 isClass ? "block" : "none"); $("#details").css("display", "block"); }
}

Not much change here from the previous version, again, except for the use of jQuery and some chaining.

And that is pretty much it. I’ve made other changes in the script to make use of the new script loader in the Microsoft Ajax Library but that will be the subject of a future post.

Hopefully, this has shown you how the Microsoft Ajax Library can light up with jQuery. The automatic creation of plug-ins feels very much like native jQuery plug-ins and brings all the power of client templates to jQuery. Once we have bind and setCommand plug-ins as well, the Microsoft Ajax Library may become a very useful tool to jQuery programmers just as much as jQuery itself is a very useful tool to Microsoft Ajax programmers.

The code can be found here:
http://weblogs.asp.net/blogs/bleroy/Samples/ClassBrowserWithjQueryUpdated.zip

Update: fixed a problem in Firefox & Chrome.

Now Available: IEAK8 can create custom Internet Explorer 8 packages in 19 additional languages(ieblog)

Thu, 29 Oct 2009 16:49:00 -0700

http://blogs.msdn.com/ie/archive/2009/10/29/now-available-ieak8-can-create-custom-internet-explorer-8-packages-in-19-additional-languages.aspx

We are pleased to announce that the Internet Explorer Administration Kit (IEAK) 8 now supports creating custom Internet Explorer 8 packages in a total of 43 languages. IEAK8 can be downloaded from http://ieak.microsoft.com.

Custom Internet Explorer 8 packages can be created in the following platform and language combinations:

Windows XP SP2 or SP3 x86:

Total languages:
- Arabic, Bengali, Bulgarian, Chinese (Simplified), Chinese (Traditional), Croatian, Czech, Danish, Dutch, English, Estonian, Finnish, French, German, Greek, Hebrew, Hindi, Hong Kong Chinese, Hungarian, Indonesian, Italian, Japanese, Kannada, Korean, Lithuanian, Latvian, Malayalam, Norwegian Bokmal, Polish, Portuguese (Brazil), Portuguese (Portugal), Punjabi, Romanian, Russian, Serbian, Slovak, Slovenian, Spanish, Swedish, Telugu, Thai, Turkish, Ukrainian
New languages:
- Bengali, Bulgarian, Croatian, Estonian, Hindi, Hong Kong Chinese, Indonesian, Kannada, Lithuanian, Latvian, Malayalam, Punjabi, Romanian, Serbian, Slovak, Slovenian, Telugu, Thai, Ukrainian

Windows XP SP2 x64 and Windows Server 2003 SP2 x64:

Total languages:
- Chinese (Simplified), Chinese (Traditional), German, English, Spanish, French, Italian, Japanese, Korean, Portuguese (Brazil), Russian

Windows Server 2003 SP2 x86:

Total languages:
- Chinese (Simplified), Chinese (Traditional), Czech, German, English, Spanish, French, Hungarian, Italian, Japanese, Korean, Dutch, Polish, Portuguese (Brazil), Portuguese (Portugal), Russian, Swedish, Turkish

Windows Vista x86, Windows Vista SP1 x86 , Windows Server 2008 x86, and Windows 7 x86:

Total languages:
- Arabic, Bengali, Bulgarian, Chinese (Simplified), Chinese (Traditional), Croatian, Czech, Danish, Dutch, English, Estonian, Finnish, French, German, Greek, Hebrew, Hindi, Hong Kong Chinese, Hungarian, Indonesian, Italian, Japanese, Kannada, Korean, Latvian, Lithuanian, Malayalam, Norwegian Bokmal, Polish, Portuguese (Brazil), Portuguese (Portugal), Punjabi, Romanian, Russian, Serbian, Slovak, Slovenian, Spanish, Swedish, Telugu, Turkish, Thai, Ukrainian
New languages:
- Bengali, Bulgarian, Croatian, Estonian, Hindi, Hong Kong Chinese, Indonesian, Kannada, Latvian, Lithuanian, Malayalam, Punjabi, Romanian, Serbian, Slovak, Slovenian, Telugu, Thai, Ukrainian

Windows Vista x64, Windows Vista SP1 x64, Windows Server 2008 x64, and Windows 7 x86:

Total languages:
- Arabic, Bulgarian, Chinese (Simplified), Chinese (Traditional), Croatian, Czech, Danish, Dutch, English, Estonian, Finnish, French, German, Greek, Hebrew, Hungarian, Italian, Japanese, Korean, Latvian, Lithuanian, Norwegian Bokmal, Polish, Portuguese (Brazil), Portuguese (Portugal), Romanian, Russian, Serbian, Slovak, Slovenian, Spanish, Swedish, Thai, Turkish, Ukrainian, Hong Kong Chinese
New languages:
- Bulgarian, Croatian, Estonian, Latvian, Lithuanian, Romanian, Serbian, Slovak, Slovenian, Thai, Ukrainian, Hong Kong Chinese

To create custom packages in these new languages, you’ll need to install the latest version of IEAK8.

Thanks,
Jatinder Mann
Internet Explorer Program Manager

Add Reference Dialog Improvements (VS 2010 and .NET 4.0 Series)(ScottGu)

Thu, 29 Oct 2009 00:12:09 -0700

http://weblogs.asp.net/scottgu/archive/2009/10/29/add-reference-dialog-improvements-vs-2010-and-net-4-0-series.aspx

[In addition to blogging, I am now using Twitter for quick updates and to share links. Follow me at: twitter.com/scottgu (@scottgu is my twitter name)]

This is the twelfth in a series of blog posts I’m doing on the upcoming VS 2010 and .NET 4 release. Today’s post covers a small, but nice, change coming with VS 2010 – an “Add Reference” dialog that loads fast.

Add Reference Dialog in VS 2008

The slow performance of the “Add Reference” dialog in previous releases of Visual Studio has been a common complaint that many a developer (including yours truly) has ranted about.

Previous releases of VS opened the “Add Reference” dialog on the “.NET” tab by default – and when that tab was loaded VS would synchronously scan the global assembly cache (GAC) retrieving .NET assembly information. Because the GAC scan was done on the UI thread, it would freeze the IDE until the scan completed – which meant that you couldn’t cancel the operation, even if you didn’t want to use that tab.

Because GAC scans can often take awhile (if you have lots of assemblies installed and/or a slow hard drive), you could end up having to wait a really long time for the dialog to respond.

Add Reference Dialog in VS 2010

The Beta2 release of VS 2010 introduces a few welcome changes to the “Add Reference” dialog behavior that significantly improves its performance.

The first improvement is that the “Add Reference” dialog in VS 2010 now defaults to opening on the “Projects” tab instead of the .NET tab. This means that the dialog always loads really fast. If you want to setup a project-to-project reference, or browse the file-system to select a file assembly, etc. you can now select these tabs immediately without having to wait for anything to load.

The second improvement is that the .NET and COM tabs now load asynchronously and do not block the UI thread while their lists are populated. This means that if you accidentally click the tabs you are no longer blocked waiting for them to synchronously load – with VS 2010 you can now either click “Cancel” to close the dialog or click on another tab instead.

Hope this helps,

Scott

WPF 4 (VS 2010 and .NET 4.0 Series)(ScottGu)

Mon, 26 Oct 2009 23:11:49 -0700

http://weblogs.asp.net/scottgu/archive/2009/10/26/wpf-4-vs-2010-and-net-4-0-series.aspx

[In addition to blogging, I am now using Twitter for quick updates and to share links. You can follow me on Twitter at: twitter.com/scottgu (@scottgu is my twitter name)]

This is the eleventh in a series of blog posts I’m doing on the upcoming VS 2010 and .NET 4 release. Today’s post covers WPF 4.

WPF 4 Improvements

WPF (Windows Presentation Foundation) is one of the core components of the .NET Framework, and enables developers to build rich, differentiated Windows client applications. WPF 4 includes major productivity, performance and capability improvements – in particular in the areas of Controls, XAML, Text, Graphics, Windows 7 integration (multitouch, taskbar integration, etc), Core Fundamentals, and Deployment. This is the first of several posts I’ll do over the coming months about some of the improvements and new features.

I will do a separate post soon that covers some of the major advances coming with VS 2010’s WPF and Silverlight Designer – which also includes a ton of improvements.

Controls

Controls for Building Rich Clients

WPF 4 adds a variety of new controls that make building rich line-of-business applications for the client easier and faster. The new, richer control set includes LOB essentials such as DataGrid, DatePicker, and Calendar controls. These new controls are 99% API- and behaviorally-compatible with their Silverlight counterparts, enabling developers to create a consistent experience across the client and web while optimizing workflow by reusing code between Silverlight and WPF implementations.

Bag O'Tricks is back

We are also releasing an out-of-band collection of eight controls called the WPF Bag O’ Tricks download. It includes the following controls: AnimatingTilePanel, ColorPicker, InfoTextBox, ListPager, NumericUpDown, Reveal, TransitionsPresenter, TreeMapPanel.

Windows 7 & Office Ribbon Control

A new WPF Ribbon Control will be available for download shortly after the release of WPF 4. It features skins for Windows 7 and Office, as well as all the standard Ribbon features that end-users are familiar with, including tabs and groups, dynamic resizing, quick access toolbar, application menu, contextual tabs, key tips, and more.

The WPF Ribbon will be fully extensible to meet changing guidelines for future releases. A CTP with a limited feature set is available today here

GRAPHICS

Cached Composition

Massive performance wins are possible with the new Cached Composition feature in WPF 4, which allows applications to cache arbitrary content including live and fully-interactive controls, vector geometry, etc. as bitmaps which persist in video memory. Once cached, these elements can be arbitrarily transformed, animated, manipulated, and can have Effects applied, all without having to re-render the cached element.

This spares both the CPU and the GPU the cost of re-rendering content, and instead allows the GPU to render straight from the cache. The cache(s) understand dirty regions, so a blinking cursor in a cached textblock, for example, will only need to re-render the cursor between frames. There’s even a new Brush which specifically uses these intelligent caches – effectively a VisualBrush with vastly better performance.

Pixel Shader 3 Support

WPF 4 builds on top of the very popular ShaderEffect support first introduced in WPF 3.5 SP1 by allowing applications to now write Effects using Pixel Shader version 3.0. The PS 3.0 shader model is dramatically more sophisticated than PS 2.0, allowing for even more compelling Effects on supported hardware.

LayoutRounding

WPF 4 adopts the UseLayoutRounding property, originally introduced in Silverlight 2. WPF’s layout engine frequently calculates sub-pixel positioning coordinates. This can lead to rendering artifacts as elements positioned on sub-pixel boundaries are anti-aliased over multiple physical pixels.

UseLayoutRounding will force the layout engine to place elements on whole pixel boundaries, thus removing most of the rendering artifacts caused by this problem – which generates cleaner and crisper UI by default.

Animation Easing Function

Discrete, linear, and spline animations were supported with previous versions of WPF. WPF 4 introduces a new concept of Easing Functions – which allows application authors to create fluid behavior using animations. This can be used in an infinite number of ways, such as creating a springy behavior, or adding anticipation to an animation. Easing Functions customize the manner in which animations progress from start to finish. The built-in easing functions provide a range of behaviors such as circular, exponential, elastic, and bouncy animation progress. The extensibility design also allows application authors to create custom easing functions to define the manner in which their animations progress. With this easy-to-use feature, designers can effortlessly create fluid, organic animations.

CleartypeHint

The new CleartypeHint attached property allows application authors to enable higher-quality Cleartyped text rendering in many situations where it would have previously been disabled. Such situations include text in layered windows, text in VisualBrushes, DrawingBrushes, BitmapCacheBrushes, and anywhere else where the introduction of an intermediate render target would have previously resulted in grayscale text rendering.

TEXT STACK

New Text Rendering Stack

The WPF text rendering stack has been completely replaced – a change that brings with it significant improvements to text rendering clarity, configurability, and support for international languages. The new text stack now supports display-optimized character layout, to produce text with comparable sharpness to Win32/GDI text:

WPF’s new text stack also now supports explicitly selecting aliased, grayscale, or ClearType rendering modes:

The new text stack allows optimizing text hinting and snapping for either animated or static text. Additionally, the new text stack now supports fonts with embedded bitmaps. This allows many East Asian fonts to render with the sharpness to which Win32 users have grown accustomed.

BindableRun

Since the initial release of WPF, Run.Text has been a normal CLR property. This has meant that Run.Text lacks all the benefits of the WPF dependency property system, most notably the ability to be bound. In WPF 4, we have converted Run.Text to a dependency property allowing developers to use the first WPF supplied bindable Run. More details can be found here.

Custom Dictionaries

WPF includes a spell checker which before WPF 4 only used the OS-provided dictionary for input validation. This has been a major issue for apps which target specific industries with specialized terminology, as those apps were plagued by misspelling notifications. WPF 4 has introduced an API to allow an application to add words to the dictionaries used by WPF for spell checking. More details can be found here.

Selection and Caret Brush

In a push to allow rich customization of the look and feel of WPF apps, developers can also now change the brush used to paint WPF text selection and carets via two simple properties: SelectionBrush and CaretBrush:

WINDOWS 7 LIGHT UP

Windows 7 Multitouch Support

With the introduction of multi-touch input and manipulation processing support, WPF 4 provides a great way to light up your client applications in Windows 7. Multiple finger input are exposed through existing and new input events in WPF 4, while new manipulation and inertia events are now available for developers to use. New features include:

Multi-touch Manipulation, Inertia (Pan, Zoom, Rotate) events on UIElement
Raw multi-touch events (Up, Move, Down) on UIElement, UIElement3D and ContentElement
Multiple capture supporting multiple active controls
ScrollViewer enhancement to support multi-touch panning
Touch device extensibility
Future Surface SDK compatibility

Windows 7 Shell Integration

WPF 4 also exposes several new and key Windows 7 Shell features to WPF developers. These Shell features enable a richer, integrated user experience. The new taskbar is less cluttered and can convey more information at a glance. The Aero thumbnails support user commands. Jump lists provide access to contextual startup tasks and files available to the application.

WPF 4 integrates Windows 7 Jump List functionality, including:

Tasks
Items
Recent and Frequent Lists integration
Custom Categories

Windows 7 Taskbar integration, including:

Progress bar
Overlay Icon
Thumbnail buttons with commanding support
Description Text DWM Thumbnail clipping

In Windows 7, the taskbar has been redesigned to be less cluttered and to help users perform tasks with fewer clicks. WPF 4 provides integration with the Windows 7 taskbar in XAML, allowing applications to surface useful information to the user from the application's taskbar icon using icon overlays, progress bar, thumbnail toolbars, thumbnail description text, and thumbnail clipping.

There is also a new TaskbarItemInfo class in WPF 4 that is exposed as a dependency property. It encompasses all the new taskbar features introduced in Windows 7.

Icon Overlays

Icon overlays allow an application to communicate certain notifications and status to the user through its taskbar button by display of small overlays which appear at the lower-right corner of the button.

Progress Bars

A taskbar button can be used to display simple progress information to the user without that user having to switch to the application window itself. Progress bars can be used to track file copies, downloads, installations, media burning, or any other operation that will take a period of time.

Thumbnail Toolbars

Thumbnail Toolbars provide access to the key commands for an application without the user having to restore or activate the window. This feature enables application authors to embed an active toolbar control in a window's thumbnail preview. The application can show, enable, disable, or hide buttons from the thumbnail toolbar as required by its current state:

WPF FUNDAMENTALS

New XAML/BAML Parser Engine

WPF 4 has replaced its implementation of XamlReader.Load(), BAML loading, Control & DataTemplates functionality with a new engine built on top of the new System.Xaml.dll. As part of this effort, we’ve fixed many bugs and made many functionality improvements. Users of XamlReader.Load() can take advantage of several new language features in XAML2009 such as support for generic types. MarkupExtensions and TypeConverters can now get more services during object graph creation, enabling more scenarios, such as access to the Root object. Tools to analyze and manipulate XAML will also be much easier to create with many of the new low level APIs provided in System.Xaml.dll.

Data Binding Support for DLR

Unlike CLR classes, the members of dynamic objects are defined at runtime. DynamicObject is a new abstract class in the .NET Framework 4 that allows developers to easily implement IDynamicMetaObjectProvider. With C#’s new DLR support with the ‘dynamic’ keyword, we are expecting some library implementations to switch to using DynamicObject and IDynamicMetaObjectProvider as a standard way to exposing runtime defined properties and members of objects. WPF 4 data binding support for IDynamicMetaObjectProvider will allow the use of natural property syntax to access dynamic properties.

This feature extends the WPF data binding engine to map the existing property and indexer access data binding syntax to support access to dynamic members offered by IDynamicMetaObjectProvider.

Visual State Manager (VSM)

Another new feature supporting the WPF-Silverlight continuum is the VisualStateManager, which introduces a simple new way to apply visual states to controls. This mechanism provides a way to easily customize both the look and feel of a control by providing the means to map the control logic to its respective start and end visual states.

VSM is very flexible in that it automatically generates the transition animations in between the respective states, so the control author spends less time writing code and more time on the visual states that are defined in a control template. That means VSM can give a control author the ability to easily interchange the look and feel of controls, and VSM gives the control author a way to easily interchange how a control visually responds to user interaction. This is fully supported with Expression Blend.

HTML-XBAP Script Interop

WPF 4 provides the means for direct communication between an XBAP and script in the host HTML page (where the XBAP is loaded in an HTML frame or IFRAME element). The XBAP can get deep access to the HTML DOM, including to any ActiveX controls embedded in the containing HTML page and including handling of DOM events.

WPF exposes the main script object from the host frame. This is a dynamic object that represents the frame’s window object plus any custom script functions and global variables from script in the HTML page. From it, an application can invoke script functions directly or “dot into” the HTML DOM. The functionality is available in partial-trust XBAPs and under all supported versions of Internet Explorer and Firefox.

UIAutomation Virtualization

WPF has introduced virtualized controls in past releases; however there was never a standardized way for an automation client to interact with a virtualized control. Two control patterns, ItemsContainerPattern and VirtualizedItemPattern, have been added in WPF 4 to support access and interact with virtualized elements. ItemsContainerPattern is used to access the virtualized controls & find virtualized items and VirtualizedItemPattern is used to realize virtualized items.

SynchronizedInput Pattern

This is another UIA control pattern added in WPF 4. This pattern could be used by automation clients to track whether the given input event is routed to the correct element by WPF framework. This pattern has three associated automation events, viz. InputReachedTargetEvent, InputReachedOtherElementEvent and InputDiscardedEvent to indicate where the input is handled.

CLIENT DEPLOYMENT

.NET Framework 4 Client Profile

To improve deployment size, time and overall experience of the .NET Framework 4 deployment, there is now a more compact version of .NET that is a subset of the full .NET Framework 4 - called the .NET Framework 4 Client Profile. The current redistributable size of the .NET Framework 4 Client Profile is about 30MB. The full Microsoft .NET Framework 4 is a pure superset of the Client Profile.

The goal of the .NET Framework 4 Client Profile is to improve and help streamline the deployment size, time, reliability and overall deployment experience for client applications. The Client Profile contains the functionality that most common desktop client applications (including Windows Forms and WPF applications) would need so it is anticipated that the majority of client application developers will target it instead of the Full .NET Framework 4. For that reason, most Visual Studio 2010 Beta 2 client project templates target the .NET Framework 4 Beta 2 Client Profile by default.

Unlike the .NET Framework 3.5 SP1 Client Profile, an important enhancement in the NET Framework 4 Client Profile is its support on all platforms and OSs, including those supported by the Full Framework like Windows Vista, Windows XP, Windows Servers 2003 and 2008, Windows 7, all for both x86 and x64.

You can view or change the version of the framework that you target by opening your project’s properties window, and then select the "Application" page. You can then change the “Target framework” drop-down to either the full .NET Framework or the .NET Client Profile. The project Publish property page also allows you to select the prerequisite needed for your ClickOnce deployment. In Beta2, VS2010 automatically selects the correct profile (Client Profile or Full) depending on your primary project target:

The same prerequisite dialog from above appears when you create “Setup and Deployment” projects (under “Add New Project”/“Other Project Types”). The NET4 Client Profile prerequisite entry is checked by default in this case.

Enhancements in NET4 Client Profile vs. NET 3.5 SP1 Client Profile

Although the concept of a Client Profile is not new and was introduced in .NET Framework 3.5 SP1, the .NET Framework 4 Client Profile contains several important improvements:

	.NET Framework 4 Client Profile (NEW)	.NET Framework 3.5 SP1 Client Profile
Supported OS	Supported on all platforms and OSs that are supported by the .NET Framework (excluding IA64 and the Server Core role in W2K8)	Supported only on Windows XP 32-bit machines that did not have any .NET Framework version installed. (Client Profile setup silently installs the full 3.5 SP1 Framework otherwise)
Redistributable	Supports redistributable as well as web download	Supports web download only
Add Remove Programs entries	The full Framework comprises the Client Profile and another part called “Extended”. Thus it has two entries in the Add/Remove Programs dialog (or Programs and Features window). If you installed the Full Framework, you can switch to the Client Profile by simply removing “Extended” from Add/Remove Programs.	Single entry in Add Remove Programs
Visual Studio	Improved support for Client Profile targeting in Visual Studio 2010. By default many Visual Studio 2010 Beta2 Client project target the NET4 Client Profile.	Single checkbox in Visual Studio 2008 Service Pack 1 “Application” Project properties for .NET Framework 3.5 projects. Client Profile support unavailable in out-of-the-box VS 2008.
Features	Includes new .NET 4 features (such as Managed Extensibility Framework (MEF), C# 4 Dynamic Keyword, etc) as well as features previously included in NET 3.5 SP1 Full (Speech, WPF Spell Check, etc)	Subset of features in .NET 3.5 SP1 Full

Because .NET 4.0 is a side-by-side release from previous releases of the .NET Framework, installation of the .NET 4.0 Framework does not require that prior versions of .NET on the machine need to be serviced/patched. This means that the .NET 4.0 Client Profile installs much faster on a machine than the .NET 3.5 SP1 Client Profile.

Full Trust XBAP Deployment

Starting in WPF 4, the ClickOnce elevation prompt is also enabled for XAML Browser Applications (XBAPs) in Intranet and Trusted Zones, making it easier to deploy full-trust XBAPs. For XBAPs that require security permissions greater than the minimum code access security (CAS) permission grantset of the Intranet and Trusted Zones, the user will be able to click 'Run' on the ClickOnce elevation prompt when they navigate to the XBAP to allow the XBAP to run with the requested permissions.

Summary

As you can tell above – there is a bunch of great new functionality coming with WPF 4.0. Below are a few links and resources you can follow to learn more some of these features:

I’ll do more posts in the coming months that also highlight some of the new WPF 4 capabilities and how to take advantage of them. I’ll also be doing another post shortly that talks about the new VS 2010 WPF and Silverlight designer – which makes it possible to build great WPF and Silverlight applications using a WYSIWYG designer directly within Visual Studio 2010.

Hope this helps,

Scott

VS 2010 Code Intellisense Improvements (VS 2010 and .NET 4.0 Series)(ScottGu)

Thu, 22 Oct 2009 23:47:54 -0700

http://weblogs.asp.net/scottgu/archive/2009/10/22/vs-2010-code-intellisense-improvements-vs-2010-and-net-4-0-series.aspx

This is the tenth in a series of blog posts I’m doing on the upcoming VS 2010 and .NET 4 release.

In today’s blog post I’m going to cover a small but really nice improvement to code intellisense with VS 2010 – which is its ability to better filter type and member code completion. This enables you to more easily find and use APIs when writing code.

Code Intellisense with VS 2008

To help illustrate this intellisense improvements coming with VS 2010, let’s start by doing a simple scenario in VS 2008 where we want to write some code to enable an editing scenario with a GridView control.

We might start off by typing “GridView1.Edit” to bring up intellisense to see what Edit members are available on the control. Doing this with VS 2008 brings up the intellisense drop-down and filters the current location in the dropdown to the members that start with the word “Edit”:

This is great if the method/property/event we want to work with starts with “Edit” – but doesn’t really help us if the “Edit” member we are looking for starts with something else (for example: the “RowEditing” event or the “SetEditRow()” helper method). We have to either manually scroll up and down looking for the other edit members, or pull up the object browser or help system to find them.

Code Intellisense with VS 2010

Let’s now try out the same scenario with VS 2010. When we type “GridView1.Edit” within VS 2010 we’ll find that the EditIndex property is still highlighted by default. But the intellisense list has also been filtered so that it enables you to quickly locate all other members that have the word “Edit” anywhere in them:

This allows us to quickly see all of the edit related methods/properties/events and more quickly find what we are looking for.

Searching for Keywords

This new intellisense filtering feature of VS 2010 is useful for searching for any member – regardless of what word it starts with. For example, if we want to enable paging on a datagrid and can’t remember how to-do it, we could just type “GridView1.Paging” and it would automatically filter out everything but members that have the word paging. Notice below how no members on the GridView class actually start with the word “Paging” – but I am still finding the two members that do have paging in them later in their names:

Searching for Types

This new intellisense filtering capability of VS 2010 is also useful for quickly finding classes and types. For example, when we type “List” to declare a variable, the editor will provide automatic filtering to show all types that have the word “List” somewhere in them (including IList<> and SortedList<> – which do not start with List):

This makes it much easier to find type names you can’t entirely remember – without having to resort to searching through the object browser and/or using help documentation.

Pascal Case Intellisense

The .NET Framework naming guidelines specify that type and member names should be “Pascal Cased” by default. This means that each word in a type or member should start with a capitalized letter (for example: PageIndexChanged).

VS 2010’s intellisense filtering support now enables you to take advantage of this to quickly find and filter methods based on their pascal naming pattern. For example, if we typed “GridView1.PIC” VS 2010 would filter to show us the members that have PIC in their name, as well as those members which have a pascal cased name where the word segments start with that letter sequence:

Notice above how PIC caused both “PageIndexChanged” and “PageIndexChanging” to show up. This saves us a few keystrokes when resolving either member or type names.

Summary

I think you’ll find that the new intellisense filtering approach in VS 2010 makes it easier to quickly find and use classes and members when writing code. You can take advantage of it with both VB and C#.

Hope this helps,

Scott

P.S. In addition to blogging, I have recently been using Twitter to-do quick posts and share links. You can follow me on Twitter at: www.twitter.com/scottgu (@scottgu is my twitter name)

Searching and Navigating Code in VS 2010 (VS 2010 and .NET 4.0 Series)(ScottGu)

Wed, 21 Oct 2009 00:50:57 -0700

http://weblogs.asp.net/scottgu/archive/2009/10/21/searching-and-navigating-code-in-vs-2010-vs-2010-and-net-4-0-series.aspx

This is the ninth in a series of blog posts I’m doing on the upcoming VS 2010 and .NET 4 release. In today’s blog post I’m going to cover some of the new code searching and navigation features that are now built-into VS 2010.

Searching and Navigating code

Developers need to be able to easily navigate, search and understand the code-base they are working on. In usability studies we’ve done, we typically find that developers spend more time reading, reviewing and searching existing code than actually writing new code.

The VS 2010 code editor adds some nice new features that allow you to more productively search and navigate a code-base, and enable you to more easily understand how code is being used within a solution.

Searching and Navigating the ASP.NET MVC Source Code

For this blog post I’m going to use the ASP.NET MVC framework code-base (which has many thousand lines of code) to help demonstrate some of the new VS 2010 searching and navigation features. If you have VS 2010 Beta 2 installed, you can follow along by downloading and opening the ASP.NET MVC framework source code from here.

You should find that the performance of the below features is really fast with this project – despite it being many thousands of lines of code in size. All of the features I’m demonstrating below are also now built-into VS 2010 (and work for all project types and for both VB and C#).

VS 2010 “Navigate To” Support

Being able to quickly find and navigate code is important with both big and small solutions.

Visual Studio 2010 now supports a new (Ctrl+comma) keyboard shortcut (meaning the control key is held down together with the comma key). When you press the (Ctrl+comma) combination, a new VS 2010 “Navigate To” dialog will appear that allows you to quickly search for types, files, variables and members within your solution – and then open and navigate to them:

The “Navigate To” dialog provides an fast incremental search UI – with results immediately populating as soon as you start typing search terms. For example, type “cont” (without pressing enter) and you’ll see that 176 results immediately show up within the results list as you start to type:

Type a few more characters and you’ll see the list automatically filters to just those results that match “controller”:

You can use the scroll bar to scroll through the results – or alternatively press the tab key and then use the cursor arrows if you don’t want to take your hands off the keyboard. You’ll find that the “Navigate To” window lists all types of results that match your search term – including Type names, Method/Property names, Field declarations, and file names:

Selecting any of the results in the results list will open the relevant source file within VS 2010 (if it isn’t already open) and take you immediately to the relevant source location (and highlight the relevant name within it):

Nice Fuzzy Search Capabilities

The “Navigate To” search box supports some nice “fuzzy search” capabilities that allow you to perform smart filters and searches without having to know exactly the name of the thing you are looking for. These work well with the incremental/immediate search UI of the dialog – and allow you to refine your searches and get real-time results as you type.

To try this out let’s first search on the word “cache”. Notice how the search results include not just items that start with the word “cache” – but also display any results that have the word “cache” in it:

We can add multiple words to the search textbox to further filter the results. For example, below I am filtering the list to only include those that have both “cache” and “action” in the name:

Types and members within the .NET Framework using a naming design-guideline pattern called “Pascal Casing” – which means that the first letter of each word in a Type or Member name is capitalized. The “Navigate To” dialog allows you to optionally use this “Pascal Casing” convention to quickly filter types. Just type the uppercase first letter of names in a type/member and it will automatically filter for results that match the uppercase pascal naming convention.

For example, typing “AMS” will filter to the below results (just those types and members that have words in them that start with A then M then S):

The “Navigate To” dialog allows you to quickly filter and locate code with a minimum of keystrokes – and avoid you ever having to use the mouse, open the solution explorer, and click on a file directly.

View Call Hierarchy

Having the ability to quickly search and navigate to code is great. Being able to also quickly discover how that code is being used is even better. VS 2010 introduces a new “View Call Hierarchy” feature that allows you to quickly discover where a particular method or property within your code-base is being called from, and allows you to quickly traverse the call tree graph throughout the code-base (without having to run or debug the solution).

To use this feature, simply select a method or property name within your code-base, and then either type the (Ctrl+K,Ctrl+T) keyboard shortcut combination, or right-click and select the “View Call Hierarchy” context menu command:

This will bring up a new “Call Hierarchy” tool window that by default shows up under the code editor. Below you can see how the “Call Hierarchy” window is displaying the two methods within our solution that invoke the ViewPage.RenderView() method we selected above.

We can then optionally drill down hierarchically into the first “RenderViewAndRestoreContentType” method to see who in-turn calls it:

For virtual methods/properties you can also use the call hierarchy window to see what types sub-class and override them.

Double clicking any of the members within the “Call Hierarchy” window will open the appropriate source file and take you immediately to that source location:

This allows you to quickly navigate throughout a code-base and better understand the relationships between classes and methods as you code.

Highlighted References

With VS 2010, when you select or highlight a variable / parameter / field declaration within the code-editor, all subsequent usages of it are now automatically highlighted for you within the editor. This makes it easy to quickly identify where and how a variable or parameter is being used.

For example, when we select the “controllerContext” parameter passed to the ControllerActionInvoker.GetParameterValue() method in the editor below, notice how the 4 usages of it within that method are also now automatically highlighted:

If I select a local variable within the method, all the places it is used are also now automatically highlighted:

If multiple usages are highlighted, you can cycle through them using the (Ctrl-Shift-up arrow) and (Ctrl-Shift-Down arrow) keystrokes to quickly move the cursor to the previous or next highlighted symbol.

Summary

The new VS 2010 text editor makes it easy to quickly search, navigate and explore code within a project or solution. The performance of these operations is really fast (even with a large code-base) and are kept up to date as you work on the project and make changes to it. The end result enables you to be much more productive.

Hope this helps,

Scott

P.S. In addition to blogging, I have recently been using Twitter to-do quick posts and share links. You can follow me on Twitter at: www.twitter.com/scottgu (@scottgu is my twitter name)

VS 2010 and .NET 4.0 Beta 2(ScottGu)

Mon, 19 Oct 2009 22:01:00 -0700

http://weblogs.asp.net/scottgu/archive/2009/10/19/vs-2010-and-net-4-0-beta-2.aspx

I’m happy to announce that today we shipped the Beta 2 release of Visual Studio 2010 and .NET 4.0. You can download it now.

VS 2010 and .NET Improvements

VS 2010 and .NET 4 bring a huge number of improvements and additions. They include big advances for ASP.NET web development, WPF and WinForms client development, SharePoint development, Silverlight development, data development, parallel computing development, and cloud computing development. VS 2010 also delivers a ton of improvements in the core IDE, code editors, programming languages, and enterprise design, architect, and testing tools.

TFS 2010 is now easy to install (only 20 minutes to setup source control, bug and work item tracking, build automation, and continuous integration), can be installed on both servers as well as client OS and domain controller machines, and is now included with all MSDN subscriptions of Visual Studio.

I’ve started a series of blog posts that will cover some of the improvements and feature additions in VS 2010 and .NET 4. Stay tuned to my blog as I post many, many more posts over the coming months.

VS 2010 Product Line SKU Simplifications

With VS 2010 we are simplifying the product lineup and pricing options of Visual Studio, as well as adding new benefits for MSDN subscribers. With VS 2010 we will now ship a simpler set of SKU options:

Visual Studio Express: Free Express SKUs for Web, VB, C#, and C++

Visual Studio 2010 Professional with MSDN: Professional development tools as you are used to today with the addition of source control integration, bug tracking, build automation, and more. It also includes 50 hours/month of Azure cloud computing.

Visual Studio 2010 Premium with MSDN: Premium has everything in Professional plus advanced development tools (including richer profiling and debugging, code coverage, code analysis and testing prioritization), advanced database support, UI testing, and more. Rather than buying multiple “Team” SKUs like you would with VS 2008, you can now get this combination of features in one box with VS 2010. It also includes 100 hours/month of Azure cloud computing.

Visual Studio 2010 Ultimate with MSDN: Ultimate has everything in Premium plus additional advanced features for developers, testers, and architects including features like Intellitrace (formerly Historical Debugging), the new architecture tools (UML, discovery), test lab management, etc. It also includes 250 hours/month of Azure cloud computing.

Side by Side Support with VS 2008

VS 2010 and .NET 4.0 can be installed side-by-side on the same machine as VS 2008 and .NET 3.5. You can install the Beta 2 version on a machine and it will not impact your existing VS 2008 / .NET 3.5 development.

Go-Live License Available

.NET 4 and VS 2010 Beta 2 include a “go-live” license which means you can start using the products for production projects.

Summary

VS 2010 and .NET 4.0 deliver some significant new capabilities and improvements. The goal with today’s Beta 2 release was to work hard on performance, stability, and the integration of the overall feature set. The team’s focus is now transitioning to getting your feedback on the product and preparing for the final release candidate (RC) milestone. Please send us any feedback you have on the Beta 2 release.

Hope this helps,

Scott

P.S. In addition to blogging, I have recently been using Twitter to-do quick posts and share links. You can follow me on Twitter at: www.twitter.com/scottgu (@scottgu is my twitter name)

Migrating ASP.NET MVC 1.0 applications to ASP.NET MVC 2(Eilon)

Mon, 19 Oct 2009 12:38:23 -0700

http://weblogs.asp.net/leftslipper/archive/2009/10/19/migrating-asp-net-mvc-1-0-applications-to-asp-net-mvc-2.aspx

To help our customers adopt ASP.NET MVC 2 I built an application that helps upgrade Visual Studio 2008 solutions that use ASP.NET MVC 1.0 to use ASP.NET MVC 2 Preview 2. This application is inspired by Scott Hanselman’s blog post on updating ASP.NET MVC projects to work in Visual Studio 2010 Beta 1.

Download

The app is a single executable: Download MvcAppConverter.zip (220 KB).

Usage

To convert an ASP.NET MVC 1.0 project built with Visual Studio 2008 to an ASP.NET MVC 2 project in Visual Studio 2008 perform these steps:
- Launch the converter
- Select the solution
- Click the “Convert” button
To convert an ASP.NET MVC 1.0 project built with Visual Studio 2008 to an ASP.NET MVC 2 project in Visual Studio 2010:
- Perform the above steps, then open the project in Visual Studio 2010 and it will perform the remaining conversion steps

What it can do

Open up ASP.NET MVC 1.0 projects from Visual Studio 2008 (no other versions of ASP.NET MVC or Visual Studio are supported)
Create a full backup of your solution’s folder
For every VB or C# project that has a reference to System.Web.Mvc.dll it will (this includes ASP.NET MVC web application projects as well as ASP.NET MVC test projects):
- Update references to ASP.NET MVC 2
- Add a reference to System.ComponentModel.DataAnnotations 3.5 (if not already present)
For every VB or C# ASP.NET MVC Web Application it will:
- Change the project type to an ASP.NET MVC 2 project
- Update the root ~/web.config references to ASP.NET MVC 2
- Update the root ~/web.config to have a binding redirect from ASP.NET MVC 1.0 to ASP.NET MVC 2
- Update the ~/Views/web.config references to ASP.NET MVC 2
- Add or update the JavaScript files (add jQuery, add jQuery.Validate, add Microsoft AJAX, add/update Microsoft MVC AJAX, add Microsoft MVC Validation adapter)
Unknown project types or project types that have nothing to do with ASP.NET MVC will not be updated

What it can’t do

It cannot convert projects directly to Visual Studio 2010 or to .NET Framework 4.
It can have issues if your solution contains projects that are not located under the solution directory.
If you are using a source control system it might have problems overwriting files. It is recommended that before converting you check out all files from the source control system.
It cannot change code in the application that might need to be changed due to breaking changes between ASP.NET MVC 1.0 and ASP.NET MVC 2. Consult the readme for information on breaking changes.

Feedback, Please!

How to render the same template on the server and client with minimal redundancy(Bertrand Le Roy)

Mon, 19 Oct 2009 01:50:00 -0700

http://weblogs.asp.net/bleroy/archive/2009/10/19/how-to-render-the-same-template-on-the-server-and-client-with-minimal-redundancy.aspx

Last week, I wrote a post about how the new Microsoft Ajax Library Preview 6 made it a lot easier to write unobtrusive and imperative data-driven applications. Because for the previous preview, I had written a cool little class browser using a declarative style, I thought it would be nice to rewrite this in a completely imperative way. The mistake I made though was to call it unobtrusive. Never mind that ‘unobtrusive’ is a perfectly well-defined word that actually existed way before JavaScript. ‘Unobtrusive JavaScript’ has a very specific meaning that people feel strongly about. To be worthy of that label, an application must basically conform to (at least) those two requirements:

Markup and behavior are strictly separated. That means no DOM-0 event handlers, no custom attributes or tags, and even no microformats imo.
Graceful degradation / progressive enhancement. This means that the application’s script is only used to improve what would work without script, in other words that the application is entirely usable without script.

While my little sample strictly conformed to (1), it didn’t conform to (2). Not because I’m too dumb or ignorant, mind you, but because for this application, it didn’t make any sense at all: the application’s whole point is to display client-side script objects. The server does not have the first clue about the data that needs to be rendered. Which makes it impossible for anything to render without script. Which in turn triggered some unpleasant comments on the post: this was not really unobtrusive JavaScript in the full sense of the term. Not the library’s fault though, just my own for using the wrong example.

The right example

So I thought the best thing to fix this is to provide a more relevant example, one where the server could actually be a fallback scenario.

The new sample code is a fairly simple master-details view on a silly data set: jedi data. We have a WCF web service that is returning a list of jedis and their associated data, which the application can render on the server-side or on the client-side. Once you have data that is available from both the server and client sides, your best and simplest tool to achieve progressive enhancement is the plain <a> tag. You can build the links in your application so that without script, they do something meaningful:

<a href="?jedi=all" id="expandButton">+</a>

What you see above is the + link on the top-left of the screen that will expand the list of jedis. To make it work client-side instead of the server-side, you use script to add a click handler that suppresses the default behavior of the link and replaces it with the equivalent client-side action:

Sys.UI.DomEvent.addHandler(
 Sys.get("#expandButton"), "click", function(e) { e.preventDefault(); jediList.fetchData(); return false; });

That’s fairly easy and has been possible since, well, I’m not sure but it’s been a looong time.

Now there’s the templated rendering. Rendering the same thing from the server and the client without repeating oneself too much is not as simple. The key to it is to render the server template with an empty data item and then to use the result of that as the client template.

<ul id="jediList"
<%if (!isDetails) { %> class="sys-template"<% } %>>
<%var jedis = !isDetails ? new List<Jedi>() {new Jedi()} : new JediService().GetJedis(); foreach (var jedi in jedis) { %>
 <li>
 <a href="?jedi=<%= jedi.Name %>">
 <%= jedi.Name%>
 </a>
 </li>
<%} %>
</ul>

This way, there is only one template, only one version of the markup, that we are using on both the server and client sides. When rendered from the server with the actual data set, we get the list right away, and the browser just displays it (and search engines can see the list as well, something you can’t achieve with pure script). When rendered with the dummy dataset, we get the following:

<ul id="jediList" class="sys-template">
 <li><a href="?jedi=all">all</a></li>
</ul>

This markup can be used as a template on the client-side by this code:

var jediList = Sys.create.dataView("#jediList", { dataProvider: "JediService.svc", fetchOperation: "GetJedis", autoFetch: false, itemRendered: function(sender, args) { var link = args.get("a"); var dataItem = args.dataItem; link.innerHTML = dataItem.Name; Sys.UI.DomEvent.addHandler(
 link, "click", function(e) { e.preventDefault(); details.set_data(dataItem); return false; }); }
});

The details view is built on pretty much the same principle. The main difference is that it does have additional markup to delimit the fields that we’ll want to set dynamically. Here’s how it renders with the dummy data:

<div id="details" class="sys-template"> <span id="jediName"></span> owns a <span id="jediLightSaber"></span> lightsaber and is on the <span id="jediSide"></span> side.
</div>

All the itemRendered handler has to do then is fill in the blanks:

var details = Sys.create.dataView("#details", { itemRendered: function(sender, args) { args.get("#jediName").innerHTML =
 args.dataItem.Name; args.get("#jediLightSaber").innerHTML =
 args.dataItem.LightsaberColor; args.get("#jediSide").innerHTML =
 args.dataItem.DarkSide ? "dark" : "light"; }
});

So what do you think?

Here’s the code (by the way, I’m using the Microsoft CDN in there):
http://weblogs.asp.net/blogs/bleroy/Samples/ServerClientTemplate.zip

Announcing Microsoft Ajax Library (Preview 6) and the Microsoft Ajax Minifier(ScottGu)

Thu, 15 Oct 2009 23:48:09 -0700

http://weblogs.asp.net/scottgu/archive/2009/10/15/announcing-microsoft-ajax-library-preview-6-and-the-microsoft-ajax-minifier.aspx

The ASP.NET team today released a significant new update of the Microsoft Ajax Library (Preview 6). This update includes a bunch of new capabilities and improvements to our client-side AJAX library, and can be used with any version of ASP.NET (including ASP.NET 2.0, 3.5 and 4.0), and can be used in both ASP.NET Web Forms and ASP.NET MVC projects. Today’s release includes the following feature improvements:

Better Imperative Syntax: A new, simplified, code syntax for creating client controls.

Client Script Loader: A new client-side script loader that can dynamically load all of the JavaScript files required by a client control or library automatically, and executes the scripts in the right order.

Better jQuery Integration: All Microsoft Ajax controls are now automatically exposed as jQuery plug-ins.

In addition to the client library improvements, we also today released a new (free) Microsoft AJAX Minifier tool. This tool allows you to substantially improve the performance of your websites by reducing the size of your JavaScript files. It can be run both as a command-line tool, and also ships as a Visual Studio MSBuild task that you can integrate into your VS projects to automatically minify your JavaScript files whenever you do a build.

Using the Microsoft AJAX Library (Preview 6)

There are two ways that you can start building applications with the Microsoft Ajax (Preview 6) release:

1) You can visit the ASP.NET CodePlex website and download the Preview 6 release (which also includes a large set of samples with it).

2) Alternatively, you can access the Microsoft Ajax Library scripts directly from the Microsoft Ajax Content Delivery Network (CDN). You can do this by just adding the following script tag to either an .aspx or .html page:

You read my blog post from last month to learn more about the Microsoft AJAX CDN (or visit http://www.asp.net/ajax/cdn).

Better Imperative Code Syntax with this release

The ASP.NET team heard feedback from the community that many developers preferred an imperative code approach (as opposed to a declarative syntax approach) when creating client controls. With today’s release we are introducing a simple imperative code syntax for creating client controls and binding them to HTML elements within a page. This syntax is fully supported by the JavaScript Intellisense in both VS 2008 and VS 2010.

Below is an example of the imperative code you can now write to programmatically create a client-side DataView control that displays data from a WCF web service:

The above code instantiates a new Microsoft Ajax DataView control and attaches the control to an HTML <div> element with the id “imageView”. The URL of the WCF service is specified with the “dataProvider” property, and the name of the method to call on the service is specified with the “fetchOperation” property. The “autoFetch” property indicates that the control should automatically bind against the WCF service when it loads.

Below is what the “imageView” HTML <div> element that the DataView control is attached to looks like. This <div> contains a template that will be used for displaying each data item retrieved from the service (note: templates were a feature we introduced with an earlier Microsoft Ajax Preview release):

The {{ Uri }} and {{ Name }} expressions within the template above are replaced with the Name and Uri properties of the images retrieved from the service. The attribute namespace prefix “sys:src” on the <img> element is used to prevent browsers from attempting to load an image at the actual path {Uri}. The value of the sys:src attribute gets plugged into the src attribute when the template is loaded.

When the page is rendered in the browser, we then get a simple photo gallery like below:

Alternatively, if you don’t want to use a declarative binding syntax within a template, you can modify the template to be pure HTML markup like below (no more {{ }} expressions):

You can then wire-up and specify a itemRendered event handler when you create the DataView control like below:

You can then implement the “imageRendered” event handler using the JavaScript below, and use the Sys.bind() method to programmatically assign values to the <img> and <span> tags within the template:

This allows you to maintain your template as pure HTML markup, while still displaying the same photo gallery experience at runtime.

Using the Microsoft Ajax Client Script Loader

The Microsoft AJAX Client-side library is now split up across multiple JavaScript files – allowing you to download and use only those script files that you actually need (reducing download sizes).

Manually adding all of the script files required to use Ajax controls can be tedious though (and error prone). To make it easier to use both client controls as well individual client library components, we are introducing a new client script loader with today’s release. This client script loader helps you automatically load all of the scripts required by a control and execute the scripts in the right order when a page loads.

For example, the following page uses the client script loader to load all of the scripts required by the “watermark” control, and then wires up the watermark control to an <input> textbox:

Notice the call to the Sys.require() method above. When you call Sys.require(), you supply the name of a client component (or an array of client components) that you want to load. The sys.require() client loader then automatically downloads all of the required script files in parallel (allowing your scripts to load faster and also allow you to avoid blocking the page from rendering). When all of the scripts required by the components requested are loaded, the Sys.onReady() method is called and the watermark is created.

Above we are binding the “watermark” control to a <input> textbox with an id of “name”. At runtime the watermark control will cause the textbox to have a watermark (that automatically disappears when a user sets the focus on the textbox and starts typing):

The client script loader supports many advanced features including automatic script combining and lazy loading. It can also be smart about downloading either debug or release versions of libraries. It also allows you to register your own libraries and have them automatically be loaded as well using the Sys.require() syntax.

Using Microsoft Ajax Library Controls with jQuery

Microsoft ships jQuery as a standard part of the ASP.NET MVC framework, and also adds it by default to new ASP.NET Web Forms projects created with Visual Studio 2010.

With today’s preview we are making it easy to integrate jQuery and Microsoft Ajax controls, and enable developers using jQuery to use the Microsoft Ajax controls with a familiar jQuery plug-in API syntax. Specifically, we are now exposing all Microsoft Ajax controls as jQuery plug-ins automatically. In other words, when you add jQuery to a page, you can use Microsoft Ajax controls just like jQuery plug-ins.

For example, the following script demonstrates how you can use jQuery to create a DataView that displays data from a WCF service (using a jQuery plugin like code syntax):

Notice above that I’m loading jQuery by calling the Sys.require() client-side loader API. You can load jQuery using the new client script loader, or alternatively you can just include the jQuery library in the page using a standard <script> tag.

Once jQuery is added to the page, Microsoft Ajax Library controls are automatically exposed as jQuery plug-ins. This means you can create and attach Microsoft Ajax controls using a standard jQuery plugin syntax (like above), and fully integrate with the jQuery selector syntax.

Reducing the Size of JavaScript Files with the Microsoft Ajax Minifier

There are two common ways that people use to reduce the download size of a JavaScript file: compression and minification.

When you host your website on a Windows Server using IIS 7.0, you can configure IIS to automatically compress your JavaScript files using GZIP compression – which can provide a significant improvement on performance and the download size of files. However, you can get additional performance benefits by both compressing and minifying your JavaScript files. Steve Sounders describes these additional benefits in his excellent book High Performance Web Sites.

In addition to releasing Microsoft Ajax Library (Preview 6), we are today also releasing a new (free) Microsoft Ajax Minifier utility that can help reduce the size of your JavaScript files considerably. It was created by Ron Logon who works on the MSN team. You can download the Microsoft Ajax Minifier from the ASP.NET CodePlex website for free.

The following screenshot demonstrates the results of minifying the standard jQuery library using various minification tools such as Douglas Crockford’s JSMin, Dean Edward’s Packer, and the YUI Compressor. The bottom two files were minified using the Microsoft Ajax Minifier utility. Notice that the Microsoft Ajax Minifier has reduced jQuery from 125 KB to only 53 KB.

The Microsoft Ajax Minifier supports two levels of minification: normal and hypercrunched. When you use normal minification, the Microsoft Ajax Minifier removes all unnecessary whitespace, comments, curly braces, and semi-colons. When you enable hypercrunching, the Microsoft Ajax Minifier becomes more aggressive in reducing the size of a JavaScript file, and it minifies local variable names and removes unreachable code.

Here’s a sample of a JavaScript file:

Here’s what the JavaScript file looks like after it has been minified with the Microsoft Ajax Minifier (with hypercrunching enabled):

Notice that all unnecessary whitespace has been removed. Notice also that the function parameters firstValue and secondValue have been renamed to b and a.

The Microsoft Ajax Minifier download includes the following components:

ajaxmin.exe – A command-line tool for minifying JavaScript files.
ajaxmintask.dll – A MSBuild task for minifying JavaScript files in a Visual Studio project.
ajaxmin.dll – A component that you can use in your C# or VB.NET applications to minify JavaScript files.

After you install the Microsoft Ajax Minifier, you can use the Microsoft Ajax Minifier command-line tool to minify a JavaScript file from a command-prompt.

You also have the option of adding the Microsoft Ajax Minifier as a custom MSBuild task to Visual Studio. Adding the Microsoft Ajax Minifier MSBuild task to your Visual Studio project file allows you to automatically minify all of the JavaScript files in your project whenever you perform a build, and enables you to perform minification in an automated way.

Summary

Today’s release of the Microsoft Ajax Library has several exciting new features for client-side developers. The new simplified imperative syntax should appeal to JavaScript developers. The client script loader makes it much easier to create client controls and optimize the download of files. And, the jQuery integration enables developers using jQuery to take advantage of the client controls, templating, and data access features of the Microsoft Ajax Library without changing their programming style.

Finally, the new Microsoft Ajax Minifier enables you to significantly improve the performance of your Ajax applications by reducing the size of your JavaScript files. You can use the minifier from a command prompt or you can use the minifier when building a project in Visual Studio.

Read Bertrand Le Roy’s Blog Post about Preview 6 to learn even more about the release. Click here to download both the Microsoft Ajax Library (Preview 6) release and the new Microsoft Ajax Minifier release.

Hope this helps,

Scott

P.S. In addition to blogging, I have recently been using Twitter to-do quick posts and share links. You can follow me on Twitter at: www.twitter.com/scottgu (@scottgu is my twitter name)

Entirely unobtrusive and imperative templates with Microsoft Ajax Library Preview 6(Bertrand Le Roy)

Thu, 15 Oct 2009 02:12:00 -0700

http://weblogs.asp.net/bleroy/archive/2009/10/15/entirely-unobtrusive-and-imperative-templates-with-microsoft-ajax-4-preview-6.aspx

Today is the release of the sixth preview of Microsoft Ajax Library. Don’t get fooled by the somewhat silly and long name: this is a major release in many ways. The scripts have been majorly refactored since preview 5. Check out the other posts out there (links at the bottom of this post) to see just some of the many new features that are in there. Some of my favorite are all the small improvements that have been made to make imperative instantiation of components and templated contents easier than ever. Many of you have told us that you preferred to do things imperatively and this release makes it a lot better.

When Preview 5 came out, I built a simple class browser using the declarative syntax. The class browser shows the hierarchy of namespaces and classes in a tree view on the left side of the page, and the details of whatever’s selected in the tree on the right side of the page:http://weblogs.asp.net/bleroy/archive/2009/09/14/building-a-class-browser-with-microsoft-ajax-4-0-preview-5.aspx

It still works (and an updated version is attached to this post), but I thought I would demonstrate how you can take that same sample and re-implement it in a completely imperative way. Of course, you never have to go all the way one way or another, and it’s always possible for example to use the nice declarative syntax for bindings but instantiate your components imperatively if you choose to do so. In this post, I’m deliberately going imperative all the way. Just keep in mind this is rather extreme.

The first thing to notice in the new version is that the markup is perfectly clean and contains no weird extension, namespace or custom binding syntax whatsoever. It’s 100% pure HTML 5. Here is for example the complete markup for the tree view on that page:

<ul id="tree" class="tree"></ul> <ul id="nodeTemplate" class="sys-template"> <li> <a class="toggleButton" href="#">+</a> <a class="treeNode" href="#"></a> <ul></ul> </li>
</ul>

The script that builds the dynamic contents is bootstrapped by the following code:

<script type="text/javascript"
 src="Scripts/start.js"></script>
<script type="text/javascript">
Sys.loadScripts(["Scripts/Tree.js"], function() { Sys.require([Sys.components.dataView], function() { createTreeView("#tree",
 Type.getRootNamespaces(),
 "#nodeTemplate"); Sys.create.dataView("#detailsChild", { itemRendered: onDetailsChildRendered }); });
});
</script>

We’re making use of the new script loader here: we first include the bootstrapper file, start.js, and then we declare that we need one custom script, “tree.js” and everything necessary to instantiate a DataView. The script loader will figure out on its own the set of scripts it needs to download for that. Once those scripts have been downloaded, we call createTreeView, which is custom code that we’ll look at in a moment that creates nested DataView controls over the markup. We also create a second DataView to display the details of what’s selected in the tree.

Notice that we set some properties to a selector string here (for example “#nodeTemplate”). This is actually a breaking change from the previous preview, which only understood id strings. Microsoft Ajax does not include a full selector engine but it does understand the most basic of selectors (.class, tagName and #id). But where it gets really interesting is that if you had included jQuery on the page, the framework would detect it and enable you to use full selectors everywhere. Isn’t that sweet?

So how does the imperative approach compare with the declarative one? Well, for instantiating components, you already have an example above, where we use Sys.create.dataView. But what about wiring up events, setting text contents and attribute values, instantiating components over the markup inside the template?

All those are done by post-processing the template instances after they’ve been instantiated, by handling the itemRendered event:

itemRendered: function(sender, args) { // do magic
}

Wiring up events is as simple as getting a reference to an element and calling addHandler:

var toggleButton = args.get(".toggleButton");
Sys.UI.DomEvent.addHandler(toggleButton, "click",
 function(e) { toggleVisibility(this); }, true);

The args.get function, which you will use a lot, takes a selector and returns the first element that matches it inside the template. Here, we are looking for an element with class “toggleButton”, but a local id would work just as well.

To set text contents and attribute values is trivial once you know how to get references to elements from local selectors (remember, jQuery also works here transparently or even explicitly when and if you need it).

Finally, instantiating components is also quite easy. For example, here is the code that creates an inner DataView for the child nodes of a node in the tree, recursively:

var childView = args.get("ul");
createTreeView(childView,
 getChildren(args.dataItem),
 nodeTemplate);

The args.get funtion is used once more to get a reference to the first UL element within the template, and it is then easy to do a recursive call into our tree creation function and build the new branch of the tree.

The command bubbling feature that makes it so easy to wire up custom commands into a template is still usable in imperative code:

var treeNode = args.get(".treeNode");
Sys.setCommand(treeNode, "select");

Finally, there is one feature that I’m not using in that sample, but that’s immensely useful, and I’m talking of course of live bindings. Those work too, all you have to do is call the Sys.bind function and give it the target object, the name of the target property to bind, the source object and the source property name.

To render the details view, I decided to not use a single item DataView like I did with the declarative version: since I’m going to use imperative code instead of declarative bindings, it is just as easy to directly manipulate the DOM that already exists, and do some hiding and showing of elements:

function onCommand(sender, args) { if (args.get_commandName() === "select") { var dataItem = sender.findContext(
 args.get_commandSource()).dataItem; var isClass = Type.isClass(dataItem) &&
 !Type.isNamespace(dataItem); var childData =
 (isClass ? getMembers : getChildren)(dataItem), namespaceElementsDisplay = 
 isClass ? "none" : "block", classElementsDisplay =
 isClass ? "block" : "none", detailsChild =
 Sys.Application.findComponent("detailsChild"); detailsChild.onItemRendering =
 isClass ?
 onClassMemberRendering :
 onNamespaceChildRendering; detailsChild.set_data(childData); Sys.get("#detailsTitle").innerHTML =
 dataItem.getName(); Sys.get("#namespacesColumn").style.display = Sys.get("#classesColumn").style.display =
 namespaceElementsDisplay; Sys.get("#propertiesColumn").style.display = Sys.get("#eventsColumn").style.display = Sys.get("#methodsColumn").style.display = Sys.get("#staticMethodsColumn").style.display =
 classElementsDisplay; Sys.get("#details").style.display = "block"; }
}

We do have a DataView to render the contents of the currently selected object though. The nice trick we used with the declarative version to dynamically switch the target place holder where the template gets rendered is still there, which enables a single DataView control to dispatch the data into two to four separate lists (or however much you want for that matter):

function onNamespaceChildRendering(args) { args.set_itemPlaceholder( Type.isClass(args.get_dataItem()) ? "#classPlaceHolder" : "#namespacePlaceHolder" );
}

I think all this is pretty cool and I hope the comparison between the declarative version and the imperative version of this little application gives you a sense of the flexibility that the Microsoft Ajax library now offers, and of how much you can choose your own development style and do pretty much anything with the same ease.

Download the code for this post here:
http://weblogs.asp.net/blogs/bleroy/Samples/Preview6ClassBrowser.zip

Microsoft Ajax Library Preview 6 can be downloaded from here:
http://aspnet.codeplex.com/Release/ProjectReleases.aspx?ReleaseId=34488

Here are a few links about this release:
http://weblogs.asp.net/scottgu/archive/2009/10/15/announcing-microsoft-ajax-library-preview-6-and-the-microsoft-ajax-minifier.aspx
http://channel9.msdn.com/posts/jsenior/Announcing-Microsoft-Ajax-Library-Preview-6/
http://www.jamessenior.com/post/How-the-Script-Loader-in-the-Microsoft-Ajax-Library-will-make-your-life-wonderful.aspx

IE October 2009 Security Update Now Available(ieblog)

Tue, 13 Oct 2009 12:50:00 -0700

http://blogs.msdn.com/ie/archive/2009/10/13/ie-october-2009-security-update-now-available.aspx

The IE Cumulative Security Update for October 2009 is now available via Windows Update or Microsoft Update.

This update addresses three privately reported vulnerabilities and one publicly disclosed vulnerability. The security update addresses these vulnerabilities by modifying the way that Internet Explorer processes data stream headers, validates arguments, and handles objects in memory. For detailed information on the contents of this update, please see the following documentation:

This security update is rated Critical for all supported releases of Internet Explorer: Internet Explorer 5.01, Internet Explorer 6, Internet Explorer 6 Service Pack 1, Internet Explorer 7, and Internet Explorer 8.

As a reminder, IE security updates are cumulative and contain all previously released updates for each version of Internet Explorer.

I encourage everybody to download this security update and other non-IE security updates via Windows Update or Microsoft Update. Windows users are also strongly encouraged to configure their systems for automatic updates to keep their systems current with the latest updates from Microsoft.

Terry McCoy
Program Manager
Internet Explorer Security

URL Routing with ASP.NET 4 Web Forms (VS 2010 and .NET 4.0 Series)(ScottGu)

Tue, 13 Oct 2009 00:13:25 -0700

http://weblogs.asp.net/scottgu/archive/2009/10/13/url-routing-with-asp-net-4-web-forms-vs-2010-and-net-4-0-series.aspx

[In addition to blogging, I have recently been using Twitter to-do quick posts and share links. You can follow me on Twitter at: www.twitter.com/scottgu (@scottgu is my twitter name)]

This is the eighth in a series of blog posts I’m doing on the upcoming VS 2010 and .NET 4 release. Today’s post covers a cool new runtime feature in ASP.NET 4 – which is the ability to use URL routing with Web Forms based pages.

What is URL Routing?

URL routing was a capability we first introduced with ASP.NET 3.5 SP1, and which is already used within ASP.NET MVC applications to expose clean, SEO-friendly “web 2.0” URLs. URL routing lets you configure an application to accept request URLs that do not map to physical files. Instead, you can use routing to define URLs that are semantically meaningful to users and that can help with search-engine optimization (SEO).

For example, the URL for a traditional page that displays product categories might look like below:

http://www.mysite.com/products.aspx?category=software

Using the URL routing engine in ASP.NET 4 you can now configure the application to accept the following URL instead to render the same information:

http://www.mysite.com/products/software

With ASP.NET 4.0, URLs like above can now be mapped to both ASP.NET MVC Controller classes, as well as ASP.NET Web Forms based pages.

Mapping URLs using ASP.NET MVC

The URL Routing engine introduced with ASP.NET 3.5 SP1 provides a powerful way to handle incoming URLs. Typically you write code as part of application startup to register/map URLs that match a specific URL format to code handlers.

Below is an example of how you can use ASP.NET MVC today to map the /products/software URL to a controller class called “Products” that has an action method named “Browse”:

The first “products-browse” parameter to the MapRoute() helper method above is a friendly name for the route. The second “products/{category}” parameter is the URL filter that matches the /products/software URL – and which treats the second segment of the URL as a parameter value called “category”. This parameter will then be passed to the ProductsController’s Browse() action method to process.

Mapping URLs using ASP.NET Web Forms

ASP.NET 4.0 now allows you to also use the URL Routing engine to map URLs to ASP.NET Web Forms pages as well as ASP.NET MVC Controllers.

Below is an example of how you can use the new MapPageRoute() helper method in ASP.NET 4.0 to map the /products/software URL to a “Products.aspx” page that lives immediately under the application root directory:

The first two parameters to the MapPageRoute() helper are the same as in MapRoute(). The first parameter provides a friendly name for the route, and the second specifies the URL format to match. The third parameter, though, points to a Products.aspx page to handle the URL instead of a controller class. You can optionally specify additional parameters to MapPageRoute() that take advantage of features like “route constraints” and provide “default values for parameters” just like you can with ASP.NET MVC based route registrations.

Within the Products.aspx page you can then write code like below that uses the new Page.RouteData property in ASP.NET 4.0 to retrieve the “category” parameter value mapped using the /products/{category} URL filter, and then databind the category products to display them:

In addition to programmatically accessing incoming route parameters using code like above, you can also take advantage of the new declarative <asp:routeparameter> control with any ASP.NET DataSource control to declaratively bind a value from a route as well. For example, below we are using a <asp:routeparameter> statement to bind the select statement’s @category parameter from the /products/{category} parameter in the URL route:

Retrieving URLs within an ASP.NET Web Form

The URL routing engine in ASP.NET can be used to both map incoming URLs to code handlers, as well as be used to programmatically generate outgoing URLs using the same mapping registration logic.

For example, above when we mapped the /products/{category} URL we gave it a “friendly name” of “products-browse”. This allows us to now also use the new Page.GetRouteUrl() helper method to lookup the route within the URL routing system, optionally specify parameters to it, and then retrieve an actual URL that it maps back to. For example, the below code would retrieve a URL value of “/products/software”:

You can access the above helper method within either your code-behind file or within your .aspx markup.

There is also now a Response.RedirectToRoute() set of methods that you can use to redirect users to a route (regardless of whether it is a MVC or Web Forms handled one) and optionally pass parameters to it.

Handling PostBack Scenarios

URL Routing with ASP.NET 4.0 fully supports postback scenarios. The <form runat=”server”> control will automatically emit the same URL that caused the page to be rendered. For example, if you access a page with a /products/software URL then any server-side <form runat=”server”> control within it would render out a <form action=”/products/software”> HTML element back to the client – which means that any postback scenarios that happen on the page will preserve the original URL.

This makes supporting clean, SEO friendly, URLs easy with Web Forms and postback scenarios – and avoids some of the tricks people need to use today when using URL rewriting modules to achieve similar effects.

Summary

ASP.NET 4.0 makes it easy to implement clean, SEO friendly, URLs using both ASP.NET MVC and now ASP.NET Web Forms (you can also have applications that mix the two).

The URL routing engine makes it easy to register URLs of any shape or format and map them to any handler you want. Because the URL routing engine can be used for both mapping incoming URLs as well as generating outgoing URLs, you can at a later point change the URL mappings and not have to modify any page or controller specific code to reflect them – which makes building SEO optimized applications much easier.

Hope this helps,

Scott

HTML now a data format(Bertrand Le Roy)

Fri, 09 Oct 2009 23:54:00 -0700

http://weblogs.asp.net/bleroy/archive/2009/10/09/html-now-a-data-format.aspx

About a year ago, I asked the question on this blog whether HTML could and should be used as a data format:

http://weblogs.asp.net/bleroy/archive/2008/11/26/should-html-be-considered-as-a-data-format.aspx

After all, it actually already has semantic constructs appropriate for tabular data, for collections, for hierarchical data and for object graphs of any kind.

Well, apparently I wasn’t the only one to think that (not that I expected I was):

http://www.whatwg.org/specs/web-apps/current-work/multipage/microdata.html

Introducing SmartyRoute: A smarty-ier way to do routing in ASP.NET applications(Eilon)

Wed, 07 Oct 2009 10:38:19 -0700

http://weblogs.asp.net/leftslipper/archive/2009/10/07/introducing-smartyroute-a-smarty-ier-way-to-do-routing-in-asp-net-applications.aspx

Inspired by ideas I have heard from people on my team (ideas that apparently I misunderstood!), I am introducing the new SmartyRoute, which provides a smarty-ier way to do routing in ASP.NET applications.

The basic idea is that you can make a request to a resource in an ASP.NET application without specifying a file extension in the URL. SmartyRoute will try to append a set of supported file extensions to find a handler to serve the request.

Basic Routing

In the simplest usage a user can make a request to ~/helloworld and SmartyRoute will find ~/helloworld.aspx on disk and use that as the handler. This is a very common scenario: Many developers don’t want to have file extensions in the URLs of their web sites. SmartyRoute enables developers to do that without making other changes to the application.

Slightly More Advanced Routing

A more advanced scenario is where a developer wants to have a URL such as ~/category/beverages. With the feature shown so far the developer has to have a ~/category/beverages.aspx on disk. There would also need to be another ASPX for every category in the application. However, SmartyRoute can walk up the path segments of the URL to locate a parent ASPX file. In this case SmartyRoute will detect that there is a file ~/category.aspx and load that instead. The rest of the data on the URL (in this case "beverages") can get passed in as parameters to the ASPX page.

Even More Advanced Routing

To get parameter values there are a number of helper APIs that SmartyRoute offers. The simplest way is to call SmartyRoute.GetRouteMatch().PathInfo, which will return everything after the last "/" of what was handled in the request. For example, if the user requests ~/category/beverages and it gets handled by ~/category.aspx then the remaining "beverages" value in the URL will be the path info:

 string category = SmartyRoute.GetRouteMatch().PathInfo; // category == "beverages"

If the path info contains multiple segments there is an alternative API that will do some of the heavier lifting for the developer. For example, if the URL is ~/category/beverages/5 (where "5" is the page number) there are these helpers:

 string category = SmartyRoute.GetNextRouteValue(); // category == "beverages" int page = SmartyRoute.GetNextRouteValue<int>(); // page == 5

Setting It Up

To use SmartyRoute in an application add a reference to the eStuff.Routing project and then go to your global.asax.cs and add this simple registration:

 string[] supportedExtensions = new[] { "aspx", "ashx" }; RouteTable.Routes.Add(new SmartyRoute(supportedExtensions));

And that’s it!

Sample Project

In the attached sample project (13KB) there is the eStuff.Routing project and a sample ASP.NET Web Application Project. Open the solution in Visual Studio 2008 (with SP1) and try out these URLs:

http://localhost:59519/Default (will load ~/default.aspx)
http://localhost:59519/foo/bar (will load ~/foo/bar.aspx)
http://localhost:59519/category/beverages/5/soda (will load ~/category.aspx with parameters)
http://localhost:59519/MyHandlers/Boring (will load ~/MyHandlers/Boring.ashx handler)
http://localhost:59519/MyHandlers/CoolStuff/Quote (will try to load ~/MyHandlers/CoolStuff/Quote.ashx handler but will fail due to web.config security)

Note that you can still make requests using the file extensions: SmartyRoute doesn’t block any current functionality (not really, anyway).

Feedback, Please!

I’d love to hear whether people find this sort of routing functionality useful. The key advantage of this simplified routing system is that you, the developer, don’t have to specify any URL route formats, yet you get most of the advantages of ASP.NET Routing: Extensionless URLs, custom data in the path info, better SEO.

Would you use this in an application that you are building?

Are you already doing something similar in an existing application?

Add-on Guidelines in action – AVG Security Toolbar(ieblog)

Tue, 06 Oct 2009 19:47:00 -0700

http://blogs.msdn.com/ie/archive/2009/10/06/add-on-guidelines-in-action-avg-security-toolbar.aspx

The AVG Security Toolbar team has recently released a new version of their toolbar. It has a more predictable user experience and does a better job of allowing users to stay in control of their browser. It’s a great example of the Guidelines for add-on developers in action.

It’s encouraging to see the example set by the AVG Security Toolbar team. They’re building valuable add-ons for people and at the same time they’re respecting user choice. Here are some high level examples of the changes they’ve made in the new version of their toolbar:

It no longer takes over the search provider. Instead it uses the proper IE8 set default provider API so that users can choose their default.
The close button is visible so that users can manage it like other toolbars. Additionally, the toolbar is positioned in a supported location which improves stability and performance.
It no longer modifies the new tab page to maintain a predictable new tab experience for users.

Kudos goes out to the AVG Security Toolbar team. On behalf of our shared customers, thanks. Following the Guidelines and using supported extensibility points in this way means that people have a consistent and reliable experience that allows them to stay in control of their browser. This is exactly what we’d like to see from all add-on developers.

Before: Previous version of AVG Security Toolbar

After: Newest version (2.507.24.1) of the AVG Security Toolbar provides a predictable experience and lets users stay in control of their browser

-Paul Cutsinger and Herman Ng

Ajax Control Toolkit: new controls, bug fixes(Bertrand Le Roy)

Wed, 30 Sep 2009 17:28:00 -0700

http://weblogs.asp.net/bleroy/archive/2009/09/30/ajax-control-toolkit-new-controls-bug-fixes.aspx

And we have a new release of Ajax Control Toolkit. I didn’t work on this one but there are some nice things in there nonetheless :)

First, new controls!

SeaDragon: I’ve blogged before about Seadragon, the JavaScript-only way to do Deep Zoom. It became a lot easier to use a few month ago when the need for tools disappeared and you can just point to any image on the web and immediately get the URL and script tag to put on your page:

Now with this release of Ajax Control Toolkit, including and controlling Deep Zoom from an ASP.NET page is also very easy:

<ajaxToolkit:Seadragon ID="Seadragon"
 CssClass="seadragon" runat="server"
 SourceUrl="sample.xml"/>

James Senior just released a screencast on how to create Deep Zoom contents for the new Seadragon control:
http://channel9.msdn.com/posts/jsenior/Seadragon-Ajax-Control-Quick-Start-Guide/

AsyncFileUpload: This is by far one of the most requested controls for ACT. File upload fields, while a part of HTML, do not work with Ajax/XHR requests (for security reasons, JavaScript can’t access the contents of the field). The only way to use them is to get the browser to do a real form post.

This new control makes it a lot easier to handle file uploads from your Ajax applications by providing an abstraction on top of the form posting:

<ajaxToolkit:AsyncFileUpload OnClientUploadError="uploadError"
 OnClientUploadComplete="uploadComplete" runat="server" ID="AsyncFileUpload1"
 Width="400px" UploaderStyle="Modern" UploadingBackColor="#CCFFFF"
 ThrobberID="myThrobber"/>

It works pretty much as advertised: just drop the control on the page, and you can upload files without a full postback. It looks just like Ajax and requires no plug-in of any kind.

The control has client and server-side events that get triggered when the file has been uploaded. On the server-side, you have access to the uploaded file’s byte stream, which you can save to disk (or database, or whatever).

Bug fixes: This release also has some new bug fixes (courtesy of Obout) for some of the top-voted issues.

Download the new release here:
http://ajaxcontroltoolkit.codeplex.com/Release/ProjectReleases.aspx?ReleaseId=33804

Try the live demos here:
http://www.asp.net/ajax/ajaxcontroltoolkit/samples/

Stephen's in-depth post about this release:
http://stephenwalther.com/blog/archive/2009/10/01/new-ajax-control-toolkit-release.aspx

Announcing the WebsiteSpark Program(ScottGu)

Thu, 24 Sep 2009 02:45:06 -0700

http://weblogs.asp.net/scottgu/archive/2009/09/24/announcing-the-websitespark-program.aspx

I’m excited to announce a new program – WebsiteSpark – that Microsoft is launching today.

WebsiteSpark is designed for independent web developers and web development companies that build web applications and web sites on behalf of others. It enables you to get software, support and business resources from Microsoft at no cost for three years, and enables you to expand your business and build great web solutions using ASP.NET, Silverlight, SharePoint and PHP, and the open source applications built on top of them.

What does the program provide?

WebSiteSpark provides software licenses that you can use for three years at no cost. Once enrolled, you can download and immediately use the following software from Microsoft:

3 licenses of Visual Studio 2008 Professional Edition
1 license of Expression Studio 3 (which includes Expression Blend, Sketchflow, and Web)
2 licenses of Expression Web 3
4 processor licenses of Windows Web Server 2008 R2
4 processor licenses of SQL Server 2008 Web Edition
DotNetPanel control panel (enabling easy remote/hosted management of your servers)

The Windows Server and SQL Server licenses can be used for both development and production deployment. You can either self-host the servers on your own, or use the licenses with a hoster. WebsiteSpark makes it easy to find hosters who are also enrolled in the program, and who can use your licenses to provide you with either dedicated or virtual dedicated servers to host your sites on.

In addition to software, WebsiteSpark provides partner opportunities to grow and build your business (including customer referrals through our partner programs). It also includes product support (including 2 professional support incidents) and free online training for the products.

Who can join the program?

WebSiteSpark is available to independent web developers and small web development companies. The only two requirements to join the program are:

Your company builds web sites and web application on behalf of others.
Your company currently has less than 10 employees.

If you meet these requirements you can visit the WebsiteSpark website and sign-up today.

As part of the enrollment process you can pick either a network referral partner (for example: a hoster or an existing Microsoft partner), or enter a referral code that you have received at an event or from a Microsoft employee. If you send mail to webspark@microsoft.com you can get a referral code quickly. You can then use that code to enroll in the program on the WebsiteSpark website. Once enrolled you can immediately download and use the software, as well as begin to participate in the network/partner opportunities.

If you have any problems enrolling, you can also send me mail (scottgu@microsoft.com) and I can connect you with someone who can help.

What happens after the 3 years?

WebsiteSpark is a 3 year program. There is no obligation to continue to use any of the software after the three years is over, and there are no costs for the three years other than a $100 program fee at the end of the three years.

At the end of the three years, WebsiteSpark participants can optionally choose to purchase all of the software in the WebsiteSpark program via a $999/year package. This includes 3 copies of VS Professional, 1 copy of Expression Studio (including Blend and Sketchflow), 2 copies of Expression Web, and 4 processor licenses of Windows Web Server 2008 and 4 processor licenses of SQL Server Web edition that can be used for production deployment.

Alternatively, if you want to purchase only the production server licenses, you can take advantage of a $199/year offering that includes both 1 Windows Web Server processor license and 1 SQL Server Web edition processor license. You can buy the quantity you need of this package at $199/year each.

Summary

The WebsiteSpark program joins the other two successful “Spark” programs we’ve previously launched - BizSpark for startups, and DreamSpark for students.

Coming at a time when the current economic climate is still tough, WebsiteSpark will help support developers and companies by providing the business resources, training, and software necessary for companies to get started and grow successful businesses on the Microsoft Web Platform.

Visit www.microsoft.com/web to learn more about the Microsoft Web Platform, as well as download and install the new Microsoft Web Platform Installer V2 we released today – which makes it really easy to quickly provision web servers and web development machines. You can then browse and download and use open source web applications from the Windows Web Application Gallery.

Hope this helps,

Scott

P.S. In addition to blogging, I have been using Twitter more recently to-do quick posts and share links. You can follow me on Twitter at: http://www.twitter.com/scottgu (@scottgu is my twitter name)

Tip/Trick: Increase your VS screen real estate by disabling HTML Navigation Bar(ScottGu)

Mon, 21 Sep 2009 00:50:53 -0700

http://weblogs.asp.net/scottgu/archive/2009/09/21/tip-trick-increase-your-vs-screen-real-estate-by-disabling-html-navigation-bar.aspx

Below is a tip/trick I twittered via my Twitter account earlier today. A number of people seemed interested in – so I thought i'd blog it here too.

HTML Navigation Bar in VS 2008

By default, when you are in HTML source-editing mode with VS 2008 and Visual Web Developer 2008 Express edition there is a set of drop-downs that are rendered immediately above the HTML text editor view:

This set of drop-downs is called the "Navigation Bar", and in the VS 2008 HTML editor they allow you to navigate between functions and methods defined within the HTML. These include both JavaScript client-side functions defined inline within the .aspx/.html file, and server-side methods defined in-line within the .aspx file when in single-file mode (meaning no code-behind file).

Disabling the HTML Navigation Bar and Getting back some pixels

Personally I don't find the HTML navigation bar super useful – since I tend not to define JavaScript functions inline within the HTML (instead I use more unobtrusive JavaScript techniques and put my JavaScript code in separate files), and I usually use code-behind instead of single-file event handlers for server-side code.

If you are like me and also don't find yourself using that particular navigation toolbar much, you'll be happy to know that you can turn it off in VS 2008 and get back about 40-50 pixels that can instead be applied toward your HTML source code view. To-do this, just select the Tools->Options menu item within VS, navigate to the "Text Editor->HTML" node and uncheck the "Navigation Bar" checkbox option:

Once you do this and press the "ok" button, you'll find that the drop-downs are gone and you have more screen real estate:

(Note: if there is no immediate change after you hit ok, try closing and then re-opening the HTML/ASP.NET file)

Hope this helps,

Scott

P.S. By default with VS 2010 (starting with Beta2) we are hiding the navigation bar when in HTML mode with the standard web profile – you can then turn it back on via Tools->Options if you find it useful. VS 2010 also has a new optional "code optimized" web profile as well that turns off all toolbars, dropdown and HTML designers.

Fluent API for .NET RIA Services Metadata()

Sun, 20 Sep 2009 21:34:10 -0700

http://www.nikhilk.net/RIA-Services-Fluent-Metadata-API.aspx

.NET RIA Services relies heavily on metadata annotations for expressing intent beyond what can be inferrd via convention. For example, validation rules on entities and members can be declared as annotations, which then enable a variety of consumption scenarios. We also have metadata for describing model aspects in DAL-agnostic fashion, and hints for automatic UI-generation. What we have today is just a first step.

The general design we're enabling is actually quite flexible. For example, a number of developers want to have metadata specified external to their code, for example in XML files or in a database. Some don't like attributes, and have asked for a fluent interface instead. In RIA Services, we wanted to create a consistent API for consumers to lookup metadata. In short the CLR metadata API, or the TypeDescriptor API from component model. And we want to let producers or specifiers of metadata choose a persistence store or specification mechanism that meets the needs of their scenario, as long as they can surface attribute instances when needed.

In fact, we have an over-arching vision for a metadata pipeline (which I'll get to later in the post).

However, the first concrete experience developers have with our metadata model when adding validation rules and UI hints, is unfortunately not very pretty. The out-of-the-box approach is based on an associated metadata class (or buddy class) mechanism that we share with ASP.NET dynamic data. Some folks have called them “ugly buddies” and that name has caught on in terms of how the feature is described! The ugly buddies mechanism suffers from usability issues (eg. lots of repetition, and room for typos, or names getting out of sync) and discoverability issues. At the end of the day, it is no more than a workaround for the missing language feature that would enable adding metadata to members via a partial class.

Using the extensibility mechanisms in the bits today, we've published a sample that demonstrates specifying metadata in XML. In this post, I'll show you my first stab at providing a fluent-API-based metadata approach. I'd obviously love to see this in the product out-of-the-box, but it is another feature, and there is the realities of a product cycle. However, there is always a v-next. In the meantime, do provide feedback via comments - it will definitely feed into the design process.

[Full post continued here...]

Fun with C# 4.0’s dynamic(Bertrand Le Roy)

Thu, 17 Sep 2009 00:50:29 -0700

http://weblogs.asp.net/bleroy/archive/2009/09/17/fun-with-c-4-0-s-dynamic.aspx

There’s been some debate recently on the new “dynamic” keyword in C# 4.0. As has been the case with many features before it, some love it, some hate it, some say it bloats the language, yadda yadda yadda. People said that about lambdas. Me, I’ll just use it where I see a use case, thank you very much.

In the case of dynamic, another frequent comment is that a statically-typed language should not try to look like a dynamic language. Well, I just don’t believe in that distinction.

Being dynamic is a trait that a language can have, and some have it more than others. But as soon as a language has a dictionary type or indexers, and most modern languages do, it starts having dynamicity. What people call a dynamic language is just one where it’s the only available type.

Now there is type safety of course, but to me that’s a different feature that is not as coupled with “statically-typed-ness” as we usually tend to think. Case in point, many modern JavaScript engines analyze the code in order to apply many of the optimization techniques that static languages have been applying at compile-time.

So just how dynamic was C# before 4.0? Well, there are dictionaries and indexers, as I’ve said, but there are also other interesting and less known features such as custom type descriptors. Go look them up if you don’t know about them. Type descriptors are for example used to provide a level of indirection between a design surface and the components being edited.

But type descriptors can also be built completely dynamically and decide to expose a completely virtual object model that is entirely built at runtime. Of course, the client code for that object has to go through the right APIs to make use of that quasi-dynamic model. And of course those APIs are not simple. Implementing a custom type descriptor in itself is not exactly trivial.

If anything, the dynamic keyword is going to provide a friendlier syntax for this sort of thing. One problem is that it has no relationship whatsoever with custom type descriptors.

So I thought I’d try to bridge that gap. How can we take a type that exposes a custom type descriptor, such as DataRowView, and transform that into something that plays nice with the dynamic keyword? What we want to be able to write is something like the following:

var table = new DataTable("People");
table.Columns.Add("FirstName", typeof(string));
table.Columns.Add("LastName", typeof(string));
table.Columns.Add("Children", typeof(int));
table.LoadDataRow(
 new object[] {"Bertrand", "Le Roy", 2},
 LoadOption.OverwriteChanges);
var tableView = new DataView(table);

dynamic dynRecord = 
 new TypeDescriptorDynamicWrapper(tableView[0]);
Console.WriteLine("{0} {1} has {2} children.", dynRecord.FirstName, dynRecord.LastName, dynRecord.Children);

To do that, I built the TypeDescriptorDynamicWrapper that you see being used above. What is does is pretty simple, as it just inherits from DynamicObject and implements TryGetMember as follows:

public override bool TryGetMember(
 GetMemberBinder binder, out object result) {
 var name = binder.Name; var property = _properties.Find( p => p.Name.Equals(name, binder.IgnoreCase ? StringComparison.OrdinalIgnoreCase : StringComparison.Ordinal)); if (property == null) { result = null; return false; } result = property.GetValue(
 _descriptor.GetPropertyOwner(null)); return true;
}

As you can see, the method just finds the right property on the type descriptor and delegates to it if it finds it. I didn’t implement the setting of properties but it would be fairly easy to do so.

Using that simple wrapper, the program above just works and displays:

Bertrand Le Roy has 2 children.

That was easy. Now what about the reverse, getting any dynamic object to expose a custom type descriptor?

Well, that’s where things get tricky.

The dynamic capabilities of C# 4.0 are targeted at two things:

Providing syntactic sugar for getting to dynamic members that looks like accessing statically-defined ones.
An easy way to create dynamic types by implementing a form of method_missing.

But there is one thing that exists in DLR but didn’t make it to C# yet, which is the ability to easily reflect on dynamic objects (other than by using the #1 syntactic sugar above).

For example, in JavaScript, a.foo and a[“foo”] are exactly the same thing, which enables easy reflection: you can enumerate the members of an arbitrary object and do stuff like a[someStringVariable].

Doing the same thing with C# on dynamic objects is much more difficult. The equivalent of a.foo is easy, but not the equivalent of a[someStringVariable].

Forget about using reflection, it doesn’t work on dynamic objects because dynamic really is a compiler trick. There is no such thing as a “dynamic” type to reflect on. It’s a keyword that tells the compiler to relax type-checking and generate code to access those dynamic members at runtime. If you try to reflect on an instance of one of the dynamic-friendly type, such as ExpandoObject, you’ll see the statically-defined members of that type, but not the dynamic ones. In a way, you’re looking at the messenger instead of the message.

This is a problem because in order to wrap an arbitrary dynamic object into a custom type descriptor, we need to be able to reflect on the dynamic members of that object.

To solve the problem, and with some help from the nice folks who are building the DLR, I compiled a simple program that sets and gets a property on a dynamic object, an then I looked at the generated code from Reflector (“luckily”, Reflector is not yet aware of dynamic and shows the generated code instead of something closer to the actual code you wrote).

I was then able to refactor that code and replace the string constants for the accessed member with a method parameter, thus creating a generic way to access dynamic object properties:

public static object GetValue(
 object dyn, string propName) {
 // Warning: this is rather expensive,
 // and should be cached in a real app var GetterSite = 
 CallSite<Func<CallSite, object, object>>
 .Create( new CSharpGetMemberBinder(propName, dyn.GetType(), new CSharpArgumentInfo[] { new CSharpArgumentInfo(
 CSharpArgumentInfoFlags.None, null) })); return GetterSite.Target(GetterSite, dyn);
} public static void SetValue(
 object dyn, string propName, object val) {
 // Warning: this is rather expensive,
 // and should be cached in a real app var SetterSite = 
 CallSite<Func<CallSite, object, object, object>>
 .Create( new CSharpSetMemberBinder(propName, dyn.GetType(), new CSharpArgumentInfo[] { new CSharpArgumentInfo(
 CSharpArgumentInfoFlags.None, null), new CSharpArgumentInfo(
 CSharpArgumentInfoFlags.LiteralConstant | CSharpArgumentInfoFlags.UseCompileTimeType,
 null) })); SetterSite.Target(SetterSite, dyn, val);
}

Once we have that, implementing the custom type provider is relatively straightforward. The only part that is not immediately obvious is how to enumerate the properties of the dynamic object.

This is done as follows. Dynamic objects implement IDynamicMetaObjetProvider, which has a GetMetaObject method, which returns a DynamicMetaObject object on which you can call GetDynamicMemberNames to get the list of members.

We can now take any dynamic object and for example present it in a property grid, which is one of those components that know how to handle custom type descriptors but not the new dynamic objects:

dynamic person = new ExpandoObject();
person.FirstName = "Bertrand";
person.LastName = "Le Roy";
person.Children = 2;
propertyGrid1.SelectedObject = 
 new DynamicTypeDescriptorWrapper(person);

And here’s what the results look like:

In conclusion, I’d say that although we are having a healthy debate on the dynamic keyword (and we should have that debate), I’m confident that in one or two years, we’ll have some incredibly imaginative uses of the feature that will simply blow us away and will make the current conversation a little sillier than it seems today. The feature itself is also in its infancy and not only will the use cases emerge way beyond what even its designers envisioned, it will also grow and become more usable with future versions of the language, as is made clear by the gap in functionality that still exists today with the full DLR project.

You can download the code for this article here:
http://weblogs.asp.net/blogs/bleroy/Samples/Bleroy.Sample.Dynamic.zip

Announcing the Microsoft AJAX CDN(ScottGu)

Tue, 15 Sep 2009 23:46:17 -0700

http://weblogs.asp.net/scottgu/archive/2009/09/15/announcing-the-microsoft-ajax-cdn.aspx

Earlier today the ASP.NET team launched a new Microsoft Ajax CDN (Content Delivery Network) service that provides caching support for AJAX libraries (including jQuery and ASP.NET AJAX). The service is available for free, does not require any registration, and can be used for both commercial and non-commercial purposes.

What does a CDN provide?

Content delivery networks (CDNs) are composed of "edge cache" servers that are strategically placed around the world at key Internet network points. These "edge cache" servers can be used to cache and deliver all types of content – including images, videos, CSS and JavaScript files.

Using a CDN can significantly improve a website's end-user performance, since it enables browsers to more quickly retrieve and download content. For example, instead of having a browser request for an image traverse all the way across the Internet to your web server to download, a CDN can instead serve the request directly from a nearby "edge cache" server that might only be a single network hop away from your customer (making it return much faster – which makes your pages load quicker).

What does the Microsoft AJAX CDN provide?

The Microsoft AJAX CDN makes it really easy to add the jQuery and ASP.NET AJAX script libraries to your web sites, and have them be automatically served from one of our thousands of geo-located edge-cache servers around the world.

For example, if you want to use jQuery from the Microsoft AJAX CDN then you can simply add a standard script tag to your page using the URL below:

When the browser requests the script file it will be automatically served by the CDN "edge cache" server that is closest to the end-user. This means:

The request will be processed much faster than if it had to hit your web-server (making the end-user's page load much faster)

You don't have to pay for the bandwidth of this file – since the file comes from our server we pay the bandwidth cost (saving you money)

The script can be easily cached across multiple web-sites – which means it might not even need to be downloaded if the user has already hit a web-site that requested the file (and as such has it already in the browser's cache).

You can get a full listing of the JavaScript libraries (and associated URLs) we already have loaded in our CDN cache here: www.asp.net/ajax/cdn

We'll update the available libraries in the CDN as we ship new versions of ASP.NET AJAX, and continue to update it to include all of the JavaScript files we ship with ASP.NET and Visual Studio (including jQuery, the jQuery Validation plugin, and additional libraries we ship in the future).

The CDN service is free and available for anyone in the community to use for both commercial and non-commercial purposes. You do not need to register to take advantage of it.

Using the Microsoft AJAX CDN with the ASP.NET 4.0 ScriptManager

In addition to allowing you to reference script files directly using a <script> element, ASP.NET 4.0 will make it easy to use the CDN from ASP.NET Web Forms applications that use the <asp:scriptmanager/> server control.

The ASP.NET 4.0 <asp:ScriptManager> control includes a new property named EnableCdn. When you assign the value true to this property, your application will use the Microsoft CDN to request JavaScript files automatically:

When you enable the CDN with the ScriptManager, your application will retrieve all JavaScript files that it normally retrieves from the System.Web.dll or System.Web.Extensions.dll assemblies from the CDN instead. This includes both the JavaScript files within ASP.NET AJAX, as well as the built-in Web Forms JavaScript files (for example: the WebUIValidation.js file for client-side validation, and the JavaScript files for controls like TreeView, Menu, etc).

This provides a nice end-user performance improvement, and means that users accessing your ASP.NET website won’t need to re-download these files if they have visited another ASP.NET website that uses the CDN.

Using ASP.NET AJAX Preview 5 from the CDN

In addition to launching the AJAX CDN site, the ASP.NET team has also recently released ASP.NET AJAX Preview 5. You can download ASP.NET AJAX Preview 5 (with sample code) from CodePlex: http://aspnet.codeplex.com/Release/ProjectReleases.aspx?ReleaseId=32770

You can also now use the ASP.NET AJAX libraries simply by adding the following script tags that point at the CDN:

These script tags reference the beta version of the September 2009 release of the ASP.NET AJAX library (the /0909/ part of the URL represents the year and month that the version of ASP.NET AJAX was released).

After you add script tags that reference the ASP.NET AJAX library, you can start using the library in your page. For example, the following code attaches a client DataView control that represents an array of photos to a DIV element in the body of the page.

The DIV element – with an id of "photos" – contains a template for formatting each photo in the array of photos. Here’s how the photos element is declared:

When the DataView is rendered, the contents of the photos DIV element is rendered for each photo in the array of photos. The following photos are displayed:

Because ASP.NET AJAX is a pure JavaScript library, the code above works perfectly well in an ASP.NET Web Forms, ASP.NET MVC, HTML, or even with classic Active Server Pages. The code also works with all modern browsers.

You can learn more about ASP.NET AJAX Preview 5 by downloading the sample code from the CodePlex project: http://aspnet.codeplex.com/Release/ProjectReleases.aspx?ReleaseId=32770

Below are several blog posts that delve into the features of ASP.NET AJAX Preview 5 in more depth:

Microsoft Ajax 4 Preview 5: The DataView Control -- Dave Reed explains how to take advantage of the new Dynamic Templates and Placeholders feature added to Preview 5.

ASP.NET Ajax Preview 5 and UpdatePanel – Jim Wang explains how you can use Preview 5 with existing websites that use the standard ASP.NET UpdatePanel control.

Building a class browser with Microsoft Ajax 4.0 Preview 5 – Bertrand Le Roy builds a very cool Ajax class browser application by taking advantage of several new features of Preview 5 including recursive templates.

How the DataContext can change your data and your life (well, sort of, but not really) – Jonathan Carter has a great series of posts that dive into the details of the Ajax DataView and DataContext.

Summary

The Microsoft Ajax CDN enables you to significantly improve the performance of ASP.NET Web Forms and ASP.NET MVC applications that use ASP.NET AJAX or jQuery. The service is available for free, does not require any registration, and can be used for both commercial and non-commercial purposes.

ASP.NET 4.0 will make it especially easy for ASP.NET Web Forms developers to take advantage of the CDN. By setting one property of the ScriptManager control, you will be able to redirect all requests for the built-in ASP.NET JavaScript files to the CDN and improve the performance of your Web Forms applications.

Hope this helps,

Scott

P.S. In addition to blogging, I have been using Twitter more recently to-do quick posts and share links. You can follow me on Twitter at: http://www.twitter.com/scottgu (@scottgu is my twitter name)

Supporting Web Standards Development with SuperPreview(ieblog)

Tue, 15 Sep 2009 19:03:00 -0700

http://blogs.msdn.com/ie/archive/2009/09/15/supporting-web-standards-development-with-superpreview.aspx

This post is a guest post from Steve Guttman, of the Expression Web team. Expression Web has created an interesting tool, SuperPreview, which we thought the IE blog audience would be interested in.

Internet Explorer 8 is an important release because it reconfirms Microsoft’s commitment to interoperability and renewed emphasis on Web Standards. My team—which develops the authoring tool, Expression Web—is also pretty emphatic about Web Standards. We’re in the process of doing significant tooling (and retooling) so we can support existing and emerging specifications, reliably.

The Expression Web team recently shipped SuperPreview for Internet Explorer, a FREE tool for performing cross-browser debugging across Internet Explorer, including versions 6, 7, and 8. This tool also helps developers and site owners in migrating their sites from earlier versions of Internet Explorer to the standards-compliant Internet Explorer 8. This is a subset of the full version of SuperPreview (which also supports Firefox) and which ships with Expression Web 3. You can download it here. You can learn more about SuperPreview for Internet Explorer on the Expression Web team blog.

Thanks,
Steve Guttman
Product Unit Manager
Expression Web

Auto-Start ASP.NET Applications (VS 2010 and .NET 4.0 Series)(ScottGu)

Tue, 15 Sep 2009 01:46:13 -0700

http://weblogs.asp.net/scottgu/archive/2009/09/15/auto-start-asp-net-applications-vs-2010-and-net-4-0-series.aspx

This is the seventh in a series of blog posts I’m doing on the upcoming VS 2010 and .NET 4 release.

I’m going to switch from discussing new VS 2010 tooling features and instead do a few posts covering a few new runtime features (don’t worry – I’ll come back to a lot more VS features, I’m just trying to mix things up a bit).

Today’s post covers a small, but nice, new feature that you can now optionally take advantage of with ASP.NET 4 - the ability to automatically startup and proactively initialize a web application without having to wait for an external client to hit the web server. This can help you provide a faster response experience for the first user who hits the server, and avoids you having to write custom scripts to “warm up” the server and get any data caches ready. It works with all types of ASP.NET applications – including both ASP.NET Web Forms and ASP.NET MVC based applications.

Auto-Start Web Applications with ASP.NET 4

Some web applications need to load large amounts of data, or perform expensive initialization processing, before they are ready to process requests. Developers using ASP.NET today often do this work using the “Application_Start” event handler within the Global.asax file of an application (which fires the first time a request executes). They then either devise custom scripts to send fake requests to the application to periodically “wake it up” and execute this code before a customer hits it, or simply cause the unfortunate first customer that accesses the application to wait while this logic finishes before processing the request (which can lead to a long delay for them).

ASP.NET 4 ships with a new feature called “auto-start” that better addresses this scenario, and is available when ASP.NET 4 runs on IIS 7.5 (which ships with Windows 7 and Windows Server 2008 R2). The auto-start feature provides a controlled approach for starting up an application worker process, initializing an ASP.NET application, and then accepting HTTP requests.

Configuring an ASP.NET 4 Application to Auto-Start

To use the ASP.NET 4 auto-start feature, you first configure the IIS “application pool” worker process that the application runs within to automatically startup when the web-server first loads. You can do this by opening up the IIS 7.5 applicationHost.config file (C:\Windows\System32\inetsrv\config\applicationHost.config) and by adding a startMode=”AlwaysRunning” attribute to the appropriate <applicationPools> entry:

<applicationPools>

<add name="MyAppWorkerProcess" managedRuntimeVersion="v4.0" startMode="AlwaysRunning" />

</applicationPools>

If you load up the Windows task manager, click the “show processes from all users” checkbox, and then hit save on a startMode attribute change to the applicationHost.config file, you’ll see a new “w3wp.exe” worker process immediately startup as soon as the file is saved.

A single IIS application pool worker process can host multiple ASP.NET applications. You can specify which applications you want to have automatically start when the worker process loads by adding a serviceAutoStartEnabled="true" attribute on their <application> configuration entry:

<sites>

     <site name="MySite" id="1">

          <application path="/" serviceAutoStartEnabled="true" serviceAutoStartProvider="PreWarmMyCache" />

     </site>

</sites>

<serviceAutoStartProviders>

     <add name="PreWarmMyCache" type="PreWarmCache, MyAssembly" />

</serviceAutoStartProviders>

The serviceAutoProvider="PreWarmMyCache" attribute above references a provider entry within the config file that enables you to configure a custom class that can be used to encapsulate any "warming up" logic for the application. This class will be automatically invoked as soon as the worker process and application are preloaded (before any external web requests are received), and can be used to execute any initialization or cache loading logic you want to run before requests are received and processed:

public class PreWarmCache : System.Web.Hosting.IProcessHostPreloadClient {

    public void Preload(string[] parameters) {

        // Perform initialization and cache loading logic here...

    }

}

IIS will start the application in a state during which it will not accept requests until your "warming up" logic has completed. After your initialization code runs in the Preload method and the method returns, the ASP.NET application will be marked as ready to process requests.

You can optionally combine the new auto-start "warming up" feature with the load-balancing capabilities of the IIS7 Application Request Routing (ARR) extension, and use it to signal to a load-balancer once the application is initialized and ready to accept HTTP traffic – at which point the server can be brought into the web farm to process requests.

Summary

The new "auto start" feature of ASP.NET 4 and IIS 7.5 provides a well-defined approach that allows you to perform expensive application startup and pre-cache logic that can run before any end-users hit your application. This enables you to have your application "warmed up" and ready from the very beginning, and deliver a consistent high performance experience.

Hope this helps,

Scott

P.S. In addition to blogging, I have been using Twitter more recently to-do quick posts and share links. You can follow me on Twitter at: http://www.twitter.com/scottgu (@scottgu is my twitter name)

Why Guitar Hero is dead to me(Bertrand Le Roy)

Tue, 15 Sep 2009 00:14:38 -0700

http://weblogs.asp.net/bleroy/archive/2009/09/15/why-guitar-hero-is-dead-to-me.aspx

I bought the new Guitar Hero 5 because I needed a new fake plastic guitar and Activision’s guitars are the best that are not outrageously expensive. The Rock Band guitars I just can’t stand. So as I was going to buy a guitar from them, I thought I might as well get a (couple of) cheap game(s) with it.

At first, I really liked what they did with GH5, especially when compared to the mediocre World Tour. The party mode, for example, is a very nice idea: the game acts as a media player and plays songs on its own; but you can jump in at any time and start to play any instrument. Being able to play any instrument in any number is also a nice touch, seeing as few people like to sing in public, but most are not afraid of the guitar or drum set.

I also liked the tapping sections and the bass’ sixth note.

Problem is, that’s about it. The game has 85 songs but they’re not good. Going through the career mode feels like you’re grinding through mediocre song after horrible song. And when there’s one good song (there are a few), it is usually spoiled by an absurd, deliberately “challenging” partition. “Challenging”, in Activision’s mind of course means they have to make extra-sure you’ll have no fun playing the song.

After passing most songs, I heard myself thinking “this is a song I’m never going to play ever again”.

And the design… Will somebody please do something about the ugliness and get out of that uncanny valley? The rest of the industry has, one way or another. Guitar Hero is generally very consistent about the bad taste.

Contrast that with the elegant and subdued design of Rock Band, their well-balanced, well-designed, fun partitions that have the appropriate difficulty (no song is harder in medium than another in expert for example).

And of course, until EA and Activision realize the consumer’s interest is theirs and it’s absurd to limit the songs you sell to only one media player, there can be only one. Nobody wants to switch games in the middle of a party. But that is unlikely to happen as Activision can’t even manage to be compatible with their own games: 35 songs out of World Tour’s 85? WTF? It’s as if Apple was selling iTunes 2008 and iTunes 2009 but you couldn’t play on 2009 all the songs you bought on 2008. And you had to pay again to play those few “old” songs that you bought only a year earlier.

Don’t even get me started on how they milk the franchise, from inane band-specific titles to ridiculous toy-versions.

There can be only one in each home, and for me that one is going to be, for now and I suspect for a long time, Rock Band.

Building a class browser with Microsoft Ajax 4.0 Preview 5(Bertrand Le Roy)

Mon, 14 Sep 2009 00:29:37 -0700

http://weblogs.asp.net/bleroy/archive/2009/09/14/building-a-class-browser-with-microsoft-ajax-4-0-preview-5.aspx

The Microsoft Ajax Library 4.0 Preview 5 is the first release of Microsoft Ajax that I didn’t participate in: I left the team a few months ago. But that doesn’t mean I don’t love what’s in there, and I really do. And by the way I’ve also seen what’s in Preview 6 too and man that will seriously rock.

So I thought I’d write a little something to celebrate the new preview. The new features include recursive templates, which is pretty much begging us to implement a treeview with it, and we’ll do just that in this post.

There is also an intriguing capability, which enables you to dynamically set what template to render for each data item, and where to render it. At first, this doesn’t look like the most useful thing in the world, but it actually opens up some very interesting possibilities, which we’ll also show in this post.

The sample code that I’m going to write for this post is a rudimentary class browser. It will render a treeview representing the hierarchical structure of namespaces and classes in Microsoft Ajax, and clicking one of the tree nodes will render a details view for it: a list of classes and subnamespaces for namespaces, and a grouped list of members for classes.

Let’s start with the tree. It will be rendered as nested unordered lists by a simple recursive DataView:

<ul id="tree" class="tree" sys:attach="dataview" dataview:data="{{ Type.getRootNamespaces() }}" dataview:itemtemplate="nodeTemplate" dataview:oncommand="{{ onCommand }}">
</ul> <ul id="nodeTemplate" class="sys-template"> <li>
 <a href="#" onclick="return false;" sys:command="select"> {{ getSimpleName($dataItem.getName()) }} </a> <ul sys:attach="dataview" dataview:data="{{ getChildren($dataItem) }}" dataview:itemtemplate="nodeTemplate" dataview:oncommand="{{ onCommand }}"></ul> </li>
</ul>

On the first UL, which is the outer DataView for the tree, you can see that we set the data property to Type.getRootNamespaces(), which returns the set of root namespaces currently defined.

We also set the template to point to the “nodeTemplate” element, which has to be outside the DataView itself when doing recursive templates. Note that the outer node of the template, the UL, won’t actually get rendered into the target ul (tree). It is only a container.

The command event of the DataView is hooked to the onCommand function, and we’ll get back to that when we couple the tree with the detail view.

In the template itself, you can see we have a link with the select command so that clicking it will trigger the nearest onCommand event up the DOM.

The text of that link is the results of a call to getSimpleName, which will extract the last part of the fully-qualified name of the namespace or class.

After that link, we find another DataView control. The data property of that control points to an array of namespaces and classes under the current object. But the nice part here is that the template property points to “nodeTemplate”, its own parent, enabling the recursive nature of the tree.

In other words, we’ve morphed a simple DataView control into a tree, with minimal effort and code.

There is just one thing missing to the tree, and that is the +/- buttons that will collapse and expand the tree nodes. This is actually very easy to set-up using CSS and some simple script. First, let’s collapse the tree by default. This is done by defining the style of the tree as follows in our stylesheet:

.tree ul { padding: 0; display:none;
}

This has the effect of collapsing all unordered list nodes under the tree.

The +/- button is created by adding the following to the template, right before the existing link:

<a class="toggleButton" href="#" sys:if="Type.isNamespace($dataItem)" onclick="return toggleVisibility(this);">+</a>

The button is a simple link whose rendering is conditioned by whether the current data item is a namespace: only namespaces can be expanded, classes are leaf nodes.

The toggling function itself is fairly simple:

function toggleVisibility(element) { var childList = element.parentNode
 .getElementsByTagName("ul")[0], isClosed = element.innerHTML === "+"; childList.style.display =
 isClosed ? "block" : "none"; element.innerHTML = isClosed ? "-" : "+"; return false;
}

This just toggles the display style of the first child UL between none and block, and the text of the link between + and –.

So there it is, we have built a simple tree by simply making use of the recursive capabilities of DataView and some very simple script.

Before we look at the details view, let’s look at the code that gets called when the user selects a node in the tree:

function onCommand(sender, args) { var dataItem = sender.findContext(
 args.get_commandSource()).dataItem; $find("details").set_data(dataItem);
}

That code gets a reference to the data item for the selected node from the template context that we can get from the sender of the event (the inner DataView that contains the selected node) using the command source as provided by the event arguments (that source is the element that triggered the command). We can then set the data of the details DataView to that data item, which will trigger that view to re-render.

Now let’s build the details view. The details view will display the child namespaces and classes if a namespace is selected in the tree, and the properties, events and methods (instance and static) in the case of a class.

For each case, we’ll use a different template: “namespaceTemplate” for namespaces, and “classTemplate” for classes, but we’ll do so from the same DataView. This dynamic template switching is done by handling the onItemRendering event of the DataView:

function onDetailsRendering(sender, args) { var dataItem = args.get_dataItem(); args.set_itemTemplate(Type.isNamespace(dataItem) ? "namespaceTemplate" : "classTemplate");
}

This code gets the data item from the event arguments and sets the itemTemplate property depending on its type.

Each of these two templates will have to display the contents of the selected object. But, and that will be the tricky part, we want all those to be neatly grouped into separated lists.

One way to do that would be to have one DataView per list but where would the fun be in that? Here, we are going to enumerate only once through the data items to display and dispatch them dynamically to this or that placeholder depending on their nature.

Once more, the key to doing that will be handling the onItemRendering event:

function onNamespaceChildRendering(sender, args) { if (Type.isClass(args.get_dataItem())) { args.set_itemPlaceholder("classPlaceHolder"); }
}

This code is simply changing the rendering place holder for the curent item from the default (the DataView’s element) to “classPlaceHolder” if the current data item is a class (instead of a namespace). The template itself looks like this:

<div id="namespaceTemplate" class="sys-template"> <h1>{{ $dataItem.getName() }}</h1> <div class="column"> <h2>Namespaces:</h2> <ul sys:id="namespacePlaceHolder" sys:attach="dataview" dataview:data="{{ getChildren($dataItem) }}" dataview:itemtemplate="namespaceChildTemplate" dataview:onitemrendering=
 "{{ onNamespaceChildRendering }}"> </ul> </div> <div class="column"> <h2>Classes:</h2> <ul><li sys:id="classPlaceHolder"></li></ul> </div>
</div> <ul id="namespaceChildTemplate" class="sys-template"> <li>{{ $dataItem.getName() }}</li>
</ul>

As you can see, there really is only one DataView in there, and thanks to the code above, it can dispatch its rendering to different places if necessary. The template for the items of that DataView happens to be the same in all cases (namespaceChildTemplate) but it could be easily different, as it was for the parent details view.

The template for displaying classes is essentially the same thing, but with four placeholders instead of two.

So here’s what it looks like in the end:

Key takeaways of this post are that it’s now super-easy to render hierarchical data structures with DataView, and that you can do some interesting grouping of data on the fly by handling the item rendering event.

You can play with the class browser live here:
http://boudin.vndv.com/AjaxPreview5Tree/default.htm

And you can download the code here:
http://weblogs.asp.net/blogs/bleroy/Samples/AjaxPreview5Tree.zip

Microsoft Ajax 4.0 Preview 5:
http://aspnet.codeplex.com/Release/ProjectReleases.aspx?ReleaseId=32770

Jim and Dave’s posts on Preview 5:
http://weblogs.asp.net/jimwang/archive/2009/09/11/asp-net-ajax-preview-5-and-updatepanel.aspx
http://weblogs.asp.net/infinitiesloop/archive/2009/09/10/microsoft-ajax-4-preview-5-the-dataview-control.aspx

Dialogs and ViewModel - Using Tasks as a Pattern()

Fri, 11 Sep 2009 09:37:28 -0700

http://www.nikhilk.net/ViewModel-Dialogs-Task-Pattern.aspx

The ViewModel/MVVM pattern continues to gain popularity, with a blog post showing up every so often, and with tweets and retweets popping up even more often :-). At the same time, there are some interesting topics beyond the core pattern that continue to fuel experimentation. A big one amongst those is how should applications use dialogs when using the view model pattern.

The crux of the problem is the desire to keep the view model independent of UI concerns, and ensure it can be tested in a standalone manner, but that often comes to odds when you want the view model to launch a dialog, and/or do some work after the dialog is closed.

The most recent version of Silverlight.FX (v3.2) that I published earlier this week, addresses this scenario using a Task pattern. This blog post discusses that pattern, and opens it up for your thoughts.

The screenshot on the right represents my updated TaskList sample application (Click to run and create a task item, and double click on it to launch an edit dialog). All of the sample code is available along with Silverlight.FX for running on your end, and using the same pattern in your own applications of course.

Silverlight.FX provides a concrete notion of a view model representing a task with commit and cancel semantics in the form of a TaskViewModel base class. This serves as the base class for view models associated with dialogs. The view model associated with the main/parent window creates and initializes an instance of a TaskViewModel-derived class to represent the task as hand (when the view decides it needs to launch the dialog). The TaskViewModel raises completion notifications that can be used to do additional work in the parent view model. The main/parent window then creates a Form and assigns the resulting TaskViewModel as Form's view model, and finally shows the dialog. The user interacts with the dialog. The Form implements OK and Cancel commands that the OK/Cancel buttons invoke, and these commands are wired up to call into the TaskViewModel to commit it or cancel it.

I'll use some actual sample code to hopefully make this more concrete.

[Full post continued here...]

Guidelines for add-on developers(ieblog)

Wed, 09 Sep 2009 14:34:00 -0700

http://blogs.msdn.com/ie/archive/2009/09/09/guidelines-for-add-on-developers.aspx

It’s well understood that the typical computer users today spend much of their time in their web browser, making it the most important software on their computer. Users expect their browsers to be easy to use, fast, stable and secure.

Over the past few months, users have downloaded thousands of great browser add-ons from www.ieaddons.com and other web sites. Users want to use browser add-ons to enhance their browsing experience, not hinder it or make it more confusing.

We have published a full list of guidelines to help add-on developers create quality add-ons. We created these guidelines to respond to demand from the developer community and to help share the thinking of the IE team, gathered from years of providing support to users and developers. We strongly recommend that developers follow these guidelines when developing add-ons for IE users. We occasionally come across add-ons that violate these guidelines so egregiously that we treat them as malware; on the other hand, we frequently see really helpful and creative add-ons that put the “user in control” and enhance the browsing experience. Here are the core aspects of our guidelines:

Do not limit the user’s ability to access Internet Explorer features

Users require access to the entire set of Internet Explorer features, including but not limited to: the address bar, search box and new tab page to navigate and search the Internet easily and safely. Users expect these features to be available to them at all times and our support data shows that users are confused and unhappy when these features are obscured or changed. Please don’t write add-ons that hide, obscure or limit access to Internet Explorer features.

Do not limit the user’s ability to control Internet Explorer settings

It’s important that users be able to control their browsing experience. We’ve provided many configuration options for IE users to help them set up their browser exactly how they want it and protect themselves from potentially harmful malware. (See previous my previous post on toolbars and search defaults)

To support this guideline, add-on software should not remove or limit the user’s ability to view and modify IE settings.

Only use supported APIs

Add-ons should only use supported Internet Explorer and Windows application programming interfaces (APIs), detailed on MSDN. Using an unsupported method of extending Internet Explorer or relying on implementation details in a specific version of IE may cause browser stability problems when Internet Explorer is updated. Also, when two add-ons try to use the same unsupported method of extending Internet Explorer they might crash the browser – our APIs are specifically designed to prevent this kind of problem.

Microsoft is committed to working with all add-on software developers to ensure that our mutual customers – you, the user – have a great experience when using Internet Explorer with add-ons. If you are developing or maintaining an Internet Explorer add-on, please review our guidelines and ensure that your add-ons deliver a good long-term experience for users.

Thank you,
Frank Olivier and Herman Ng
Internet Explorer Program Management

ASP.NET, HTML, JavaScript Snippet Support (VS 2010 and .NET 4.0 Series)(ScottGu)

Fri, 04 Sep 2009 02:12:15 -0700

http://weblogs.asp.net/scottgu/archive/2009/09/04/asp-net-html-javascript-snippet-support-vs-2010-and-net-4-0-series.aspx

This is the sixth in a series of blog posts I’m doing on the upcoming VS 2010 and .NET 4 release.

Today’s post covers another useful improvement in VS 2010 – HTML/ASP.NET/JavaScript snippet support. Snippets allow you to be more productive within source view by allowing you to create chunks of code and markup that you can quickly apply and use in your application with a minimum of character typing.

Visual Studio has supported the concept of “snippets” for VB and C# in previous releases – but not for HTML, ASP.NET markup and JavaScript. With VS 2010 we now support snippets for these content types as well.

Using ASP.NET Snippets

Let’s walkthrough how we can use snippets to quickly implement a common security scenario. Specifically, we’ll implement the functionality necessary to display either a “[ Login ]” link or a “[ Welcome UserName ]” message at the the top right of a site depending on whether or not the user is logged in:

The above functionality is automatically added for you when you create a project using the new ASP.NET Project Starter Template in VS 2010. For the purpose of this walkthrough, though, we’ll assume we are starting with a blank master page and will build it entirely from scratch.

We’ll start by adding a standard <div> element to a master page, and then position our cursor within it:

We are going to use the built-in <asp:loginview> control to help implement our scenario. The <asp:loginview> control is a templated control (first introduced with ASP.NET 2.0) that allows us to easily switch between “Anonymous” and “LoggedIn” templates that automatically display depending on whether the user is authenticated. Rather than type the <asp:loginview> markup manually, we’ll instead use the new snippet support in VS 2010.

Typing in “<log” in the editor will bring up intellisense and display available elements, controls and code snippets that start with those characters.

We’ll select the built-in “loginview” code snippet from the above list and hit the “tab” key to complete it:

Now that we’ve selected the snippet we want to use, we can hit the “tab” key again to execute the snippet – which will cause it to immediately replace the snippet name with the markup below. Notice below the snippet added a new <asp:loginview> control for us and automatically defined the two most commonly used templates on it. We were able to implement that all with just 6 keystrokes (4 keystrokes to type “<log”, and then 2 tab keystrokes).

We’ll now implement the “AnonymousTemplate”.

Typing in “<a” in the editor will being up intellisense and display available elements and code-snippets we can use:

We’ll select the built-in “a” code snippet from the above list and hit the “tab” key to complete it. When we hit tab again it will execute the snippet – which will cause it to replace the snippet name with the markup below:

The “href” attribute attribute value and the inner content of the <a> element above are highlighted with a green background color. This indicates that these values are replaceable parameters and that we can automatically tab between them when filling them out – avoiding the need to use the cursor keys or touch the mouse (making things much faster).

Without having to move our cursor or mouse, we can begin typing the login page URL we want to send users to if they are not authenticated on the site:

When done, we can hit the “tab” key and VS will automatically highlight the second content parameter in the editor for us (no manual cursor movement or mouse action required):

We can then type the text we want displayed (again without having to move the mouse or touch a cursor key):

Once done with the “<AnonymousTemplate>” we can move onto the "<LoggedInTemplate>”. We’ll type “<log” in the editor to bring up intellisense – and select the built-in “loginname” snippet:

When we hit tab it will execute the snippet – which will cause it to replace the snippet with the markup below:

The “FormatString” property value above was automatically populated for us with a default welcome text message. The value is also automatically highlighted in case we want to change it (without having to move the mouse or cursor keys). For this sample we’ll just keep the default text.

Our final markup then looks like below:

When we run our application the above markup will display a “[Login]” link when we aren’t authenticated:

When we are logged in we’ll see a welcome string like below:

The total number of key strokes to implement this entire scenario is less than 15% of what we would previously have had to type. Typing fast, I found I could implement the entire scenario in less than 15 seconds :-)

ASP.NET MVC Snippets

Built-in snippets are available for all ASP.NET controls and HTML markup elements.

Built-in snippets are also available for common ASP.NET MVC view scenarios, and for the built-in ASP.NET MVC HTML helpers.

For example, we can type “<act” within a ASP.NET MVC view and select the “actionlink” snippet:

When we complete it and hit the “tab” key the snippet will execute – which will cause it to replace the snippet name with the markup below:

Notice that the “linktext” and “actionname” values are marked as snippet parameters – which means we can easily replace them without having to use the cursor keys or touch the mouse. The first linktext parameter value is selected by default – which means we can just type to immediately replace the value, then hit tab to immediately select and replace the second actionname parameter:

Custom Snippets

Visual Studio 2010 will include more than 200 built-in snippets that you can immediately use when you install the product.

What is really nice is that you are not limited to only using the built-in snippets. You can also easily create your own snippets (complete with replaceable parameters) and both import them into VS 2010, as well as easily share them with other developers. This makes it easy for you to quickly automate your own common tasks.

This article describes the snippet support that already exists in VS 2008, and provides a little more context on how to create and manage custom snippets.

Summary

Snippets are a useful feature that enable you to reduce keystrokes within the editor, and allow you to complete scenarios and tasks much faster. Having snippets now enabled in not just VB and C#, but also in HTML, ASP.NET and JavaScript files, makes this capability even more useful – and can make you even more productive.

Hope this helps,

Scott

P.S. In addition to blogging, I have been using Twitter more recently to-do quick posts and share links. You can follow me on Twitter at: http://www.twitter.com/scottgu (@scottgu is my twitter name)

Preventing Operation Aborted Scenarios(ieblog)

Fri, 04 Sep 2009 01:48:00 -0700

http://blogs.msdn.com/ie/archive/2009/09/03/preventing-operation-aborted-scenarios.aspx

This post follows up on my original Operation Aborted post to provide some additional information and assistance for web site owners or 3^rd party script libraries.

Recap

Nearly a year-and-a-half ago, I blogged about an error that can occur on some websites that generate content via script. This content can cause Internet Explorer’s HTML parser to get into an unrecoverable state, which makes it doubly-hard to find and diagnose why this error is happening. When this state occurs, the HTML parser cannot continue, and simply throws up its hands and admits: “Operation aborted!”

Early in IE8’s development, we put in a mitigation that alleviated the worst side-effects of this problem. Rather than show a modal dialog and then navigate away from the page after you press OK, instead we removed the dialog and transferred the error notification into the status bar (to the script error notification area). As a result, you are not interrupted by a dialog and you can continue to view the current web page. You may not have even noticed that this error occurred; yet the HTML parser does come to a grinding halt (for that tab only) and any additional content will never be processed.

Not too long after IE8 was released, we began hearing reports of IE8 customers continuing to see the old operation aborted dialog! While we knew that we hadn’t fixed every possible scenario that could cause the dialog to appear (it’s triggered as a catch-all for many subsystems such as the navigation stack and networking), we believed that we had mitigated the worst-cases. With recent reports of users seeing the Operation Aborted dialog in IE8 we investigated further to find any additional scenarios that could be triggering the dialog to appear (rather than the script error mitigation).

In the following two scenarios, the root cause of the Operation Aborted issue is the same (for details, please read my previous post), but the way in which it happens in these scenarios causes IE to bypass the mitigation that we put in place for IE8.

Scenario 1: Nested Parsing after Operation Aborted

<html> <body> <div> <script type="text/javascript"> document.body.appendChild(document.createElement('div')); document.write("Testing"); </script> </div> </body>
</html>

In the HTML above, the effect of the first line of the script is to trigger the Operation Aborted problem. In IE8 this is mitigated as previously mentioned. However, if sometime later a document.write API call is issued as shown in the second line of script, all versions of Internet Explorer, including 8, will present you with the old operation aborted dialog.

Scenario 2: Operation Aborted in error handlers

<html> <body> <script type="text/javascript"> window.onerror = function() { var el = document.getElementById("div2"); el.appendChild(document.createElement("div")); } </script> <div id="div1"></div> <div id="div2" onclick="alert('hi';"></div> </body>
</html>

In this HTML file, a script error (in the onclick event handler) has a run-time error, which causes the window object's onerror handler to be invoked. In this scenario, if Operation Aborted is triggered in the error handler, the dialog will also show in IE8.

Programmatically Detecting Operation Aborted

When this error dialog occurs, it is very hard for web developers to find the problem and fix it. Often (and in most cases we’ve seen) the problem is introduced in third-party scripts that are referenced by the affected page. To help web developers quickly find and fix the problem, we’ve written a little script that should help.

This script must be run as the first script in the page that is experiencing the Operation Aborted error. It overrides the usage of innerHTML and appendChild by first checking the parsing frontier before allowing the action. AppendChild is by far the most common DOM entry point that can trigger Operation Aborted, followed by innerHTML. The script may flag false positives, but we wanted to err on the side of being overly cautious.

This script relies on a feature enabled in IE8 standards mode only—Mutable DOM Prototypes. Thus, it will only work for pages that use IE's most standards-compliant mode. See this post on compatibility view for more details on the mode that IE is interpreting your page in. However, the operation aborted problems that this script identifies (in IE8 standards mode) also apply to IE7 and IE6 thereby helping you diagnose and fix this issue in any version of IE.

To use the following script follow these steps:

Add a script element to the head of the page in question. This script element should be before any other script element on the page.
Place the following script text within that script element (or reference a file containing it from the src attribute)
Set the "f1" and "f2" feature values
1. Setting "f1" to true will skip DOM calls that could potentially cause the Operation Aborted error. However, this will also result in a change in program flow, and other script errors could result.
2. Setting "f2" to true stops program flow at the point of a potential Operation Aborted error and breaks into the debugger (external or built-in JavaScript debugger). This is where you can analyze each occurrence to see what assumptions were being made and how the program flow can be altered to prevent the problem.
In IE, navigate to the page in question.
Start the JavaScript debugger by pressing "F12" and then selecting the "Script" tab in the Developer Tools, and press the button "Start Debugging".

(function() { // Feature switches // WARNING: 'true' may cause alternate program flow. var f1 = PREVENT_POTENTIAL_OCCURANCES = false; var f2 = BREAK_INTO_DEBUGGER_AT_POTENTIAL_OCCURANCES = true; if (!window.console) { window.console = {}; window.console.warn = function() { }; } var frontierCheck = function(host) { // Is host on the frontier? while (host && (host != document.documentElement)) { if (host.parentNode && (host.parentNode.lastChild != host)) // This is not on the frontier return true; host = host.parentNode; } if (!host || (host != document.documentElement)) return true; // This node is not on the primary tree // This check is overly cautious, as appends to  // the parent of the running script element are  // OK, but the asynchronous case means that the  // append could be happening anywhere and intrinsice // knowledge of the hosting application is required console.warn("Potential case of operation aborted"); if (f2) debugger; // Step up two levels in the call stack  // to see the problem source!! if (f1) return false; else return true; } var nativeAC = Element.prototype.appendChild; Element.prototype.appendChild = function() { // call looks like this: // object.appendChild(object) // Go back one more level in the call stack!! if (frontierCheck(this)) return nativeAC.apply(this, arguments); } var nativeIH = Object.getOwnPropertyDescriptor(Element.prototype, "innerHTML").set; Object.defineProperty(Element.prototype, "innerHTML", { set: function() { if (frontierCheck(this)) nativeIH.apply(this, arguments); } });
})();

We recognize that the operation aborted dialog and its mitigated cousin in IE8 are still the source of significant web developer pain. We hope this information and prevention script help you to diagnose and fix issues related to Operation Aborted in IE8 (and older versions of IE).

-Travis Leithead
Program Manager

querySelectorAll on old IE versions: something that doesn’t work(Bertrand Le Roy)

Mon, 31 Aug 2009 18:03:13 -0700

http://weblogs.asp.net/bleroy/archive/2009/08/31/queryselectorall-on-old-ie-versions-something-that-doesn-t-work.aspx

In today’s post, I’m going to show an interesting technique to solve a problem and then I will tear it to pieces and explain why it is actually useless. I believe that negative results should also be published so that we can save other people from wasting time trying the same thing. So here goes…

A few days ago, a post on Ajaxian proposed a new version of a somewhat old technique to implement querySelectorAll on old versions of IE, using the browser’s native CSS engine. That sounds like a great idea at first, and the hack is quite clever. The idea is to dynamically add a CSS rule to the document that has the selector that you want to evaluate, and an expression that adds the matched elements to a global array.

When I read this, it reminded me of a similar approach that I had tried a few years ago. At the time, we were considering implementing our own selector engine (we had not yet decided to integrate jQuery to our Ajax offerings, which in the end made the whole effort moot) so we explored a number of approaches.

My idea was different in that it doesn’t use expressions at all. It does dynamically create a style rule, but instead of an expression, it just sets a non-existing “foo” style property to the equally arbitrary value of “bar”. It then scans the whole document (using the much decried and IE-specific but very fast document.all) and gets the computed style for each of the elements. We then look for the foo property on the resulting object and check whether it evaluates as “bar”. For each element that matches, we add to an array.

Here’s the code:

(function() { var style = document.styleSheets[0] ||
 document.createStyleSheet(); window.select = function(selector) { style.addRule(selector, "foo:bar"); var all = document.all, resultSet = []; for (var i = 0, l = all.length; i < l; i++) { if (all[i].currentStyle.foo === "bar") { resultSet[resultSet.length] = all[i]; } } style.removeRule(0); return resultSet; }
})();

or, in minimized form:

(function(){var d=document;var a=d.styleSheets[0]||
d.createStyleSheet();window.select=function(e){
a.addRule(e,"f:b");var l=d.all,c=[];
for(var b=0,f=l.length;b<f;b++)if(l[b].currentStyle.f)
c[c.length]=l[b];a.removeRule(0);return c}})()

That’s 235 characters, which is not too bad (although not quite #twitcode small).

The first problem with that approach though is that because it’s using the native CSS selection engine in IE, it has the same limitations and quirks. That means no fancy CSS 3 (or even 2) selectors. It also means any IE bug will surface into the result set.

In other words, if you want more selectors than that, you will need to parse the selector string and branch off the code to another, more complete engine whenever something not supported is used. It also means that you need to know what is supported and what isn’t. That could be done through some dynamic discovery but doing so, we are getting into much complexity.

So limited as it is, how does it perform?

I ran the code in a SlickSpeed test (where I removed the selectors that it couldn’t handle) on IE6 and the good news is that despite the document.all scan and the current style computation, it’s more than three times faster than Paul Young’s implementation that got featured on Ajaxian.

But the bad news is that it’s also six times slower than jQuery:

I’m afraid a hack to use the native CSS selection engine of the browser is always going to be slower than an optimized pure JavaScript implementation (to be clear, I’m not talking about native implementations of querySelectorAll, but about hacks such as this which try to surface the feature on older IE versions that don’t have querySelectorAll). Somewhat counter-intuitive, but true.

End of story. Just use jQuery. :)

Photos from Death Valley()

Sat, 29 Aug 2009 07:57:02 -0700

http://www.nikhilk.net/Death-Valley.aspx

A small set of photos from a trip to Death Valley National Park ... drove up there right after MIX '09 in Las Vegas.
[Full post continued here...]

How to install and configure Visual Studio Team Explorer(Bertrand Le Roy)

Fri, 28 Aug 2009 14:24:04 -0700

http://weblogs.asp.net/bleroy/archive/2009/08/28/how-to-install-and-configure-visual-studio-team-explorer.aspx

One of the challenging aspects of working with TFS as your source control system is very unfortunately the installation of the client software.

Over the past few years, I’ve been managing a number of small and large projects on CodePlex, and while the Subversion bridge has provided a much needed simple choice of client software, TFS remains its native protocol, which makes it still very much relevant to people who do a lot of work there.

But as I said, installing the client software may be challenging.

The first and main problem here is that Team Explorer, while free, comes in a very unfriendly format: an ISO image of the DVD. I asked the team why they made that weird and less than optimal choice, and apparently there are some technical reasons why a simple msi wouldn’t work. I wasn’t completely satisfied with the explanation (it’s still a bad customer experience) but at least there is hope as the plan is to make it a lot smoother with Visual Studio 2010.

So let’s download that thing. It can be found here:

http://www.microsoft.com/downloads/details.aspx?familyid=0ed12659-3d41-4420-bbb0-a46e51bfca86&displaylang=en

Just click on the “Download” button and store the file in a local temporary folder. At 387.4 MB it’s a pretty big download (especially when compared with this) but it does contain the Visual Studio shell, which explains it, kind of. So you probably have time for a cup of coffee or two, trip to Seattle’s Best included.

Oh, by the way, to be clear, you do *not* need a version of Visual Studio on the box to install Team Explorer, it is a standalone application, but if you do have one, it will integrate with it.

Now that you have the IMG file, we can extract it. There are several options to extract or burn an ISO, but I’ll use a free one here. We won’t burn the image to a DVD (the only reason I could see why you’d want to do that is if you want to make multiple installs, but you might as well extract the ISO to a network share).

The free option I’ve selected is ExtractNow, which you can download from here:

http://www.extractnow.com/

Click on the “Download ExtractNow!” link on the bottom of the page and run the installer. When it asks you if you want to run it, say yes. The UI is a little weird: what you need to do now is right click on the white surface on the ExtractNow window and select “Add archive”:Then, navigate to wherever you downloaded the VS2008TeamExplorer.iso file, select it and click the “Open” button. Now click the “Extract” button and wait for the extraction to complete. You should now have a VS2008TeamExplorer folder next to the iso file. You can close ExtractNow and maybe even uninstall it until the next time you need it…

Open that folder and double-click “Setup”. Follow the instructions (the default settings should be fine) and wait for the install to complete. Fortunately, it doesn’t take nearly as long as installing the full VS.

Once this is done, you should be up and running. Let’s launch the shell and connect to a CodePlex project. From the Team Explorer window, click the “Add existing team project button:

Click on the “Servers” button and then on the “Add” button to add the relevant CodePlex server. The data that you need to enter there can be found on the “Source Code” tab of your project’s site on CodePlex by clicking on Source Control Setup / Visual Studio Team Explorer (right side of the page).

You can copy the server, port and protocol information into the Team Explorer add server window:

You can now close that window by clicking OK. You will then get prompted for your username and password. CodePlex also gave you that (notice the “snd\” domain prefix and “_cp” postfix) but let’s make sure that we only have to do this once. To that effect, let’s cancel and go to the Windows user account control panel and click on “Manage your credentials”:

Then click on “Add a Windows Credential”. Copy there the server name, your username and your password:

Click OK, then switch back to Visual Studio and click OK again. This time, you shouldn’t be prompted for credentials unless you made a typo in the above dialog. You may now click close and then select any number of projects you want to work with:

The team explorer window now shows the available projects:

If you then double-click “Source Control” under any of the projects, you can explore the contents of the project and map them to a local folder. To do that, first create the target directory from Windows Explorer, then right click a project in the Visual Studio Source Control Explorer and select “Get Latest Version”:

You will then be prompted for a local directory to which you want to map the source-controlled remote directory. Select the directory that you just created and click OK.

And… that’s it, you’re all set. You can now open any file or project from the locally mapped folder, check out code, modify it and then check it back in using the Pending Changes window.

I hope this helps.

BouncingPlane Behavior for Silverlight()

Thu, 27 Aug 2009 16:15:22 -0700

http://www.nikhilk.net/BouncingPlane-Behavior.aspx

Time for a brief but fun post... some time back Tim Heuer posted the Silverlight 3 bouncing plane gratuitous demo. Click an element, and the nearest corner would bounce backwards and forwards as it comes back to rest.

Tim had the code to setup the storyboards, and handle the mouse interaction in code-behind. I look at it, and immediately see a reusable component (even if it is a gratuitous one), or more specifically a behavior, that encapsulates all the logic, and can be attached declaratively in XAML to one or more elements simply without needing any code-behind logic. So I created one such behavior. I used this behavior in my TwitterBug sample at TechEd recently, and thought it could use a dedicated blog post. :-)

Here is a screenshot, which really doesn’t do much justice to something interactive. So go ahead, and click it to run the sample live. Click around on the images. And if you’re wondering how its done, go ahead and download the code. You’ll see a BouncingPlane class that derives from Behavior.

[Full post continued here...]