AR Development Center

Daily Recap: 5/3/2012

jrandall — Thu, 03 May 2012 19:27:59 GMT

All sorts of SharePoint development has been happening for the last couple of days. SharePoint is an amazing product, and it is turning out to be a fantastic development platform. However, the support for versioning applications is sorely lacking. The current iteration of SharePoint (2012) doesn’t account well for what will happen to your existing templates and features when changes need to be made. As I wade through yet another difficult task that should be oh-so-simple, I present today’s topics:

Transition away from “Windows Live” has been mapped

In a Building Windows 8 blog post yesterday, a roadmap was posted (in the form of a chart) showing how the current Windows Live services will be branded.

http://blogs.msdn.com/b/b8/archive/2012/05/02/cloud-services-for-windows-8-and-windows-phone-windows-live-reimagined.aspx

Changes coming for Inside Xbox

Xbox media extraordinaire Larry Hyrb (Major Nelson) announced on his blog that there are changes a-coming for the Microsoft branded Inside Xbox. Those changes? Inside Xbox is canceled.

http://majornelson.com/2012/05/02/changes-for-inside-xbox-u-s/

Microsoft Research opens a NYC Lab

Microsoft Research New York City is now open for business. Integral in the opening are three founding members of the team. One interesting tidbit is that 14 scientists have been pulled from Yahoo to become involved with this project.

The NYC campus will be tasked with studying how people interact and share information online.

http://research.microsoft.com/en-us/news/features/msrnyc-050212.aspx

http://news.cnet.com/8301-1023_3-57426719-93/microsoft-snags-yahoo-scientists-for-new-research-lab/

Ubisoft Toronto is growing

The Ubisoft studio, based in Toronto, that has been working on the Splinter Cell titles will be infused with roughly $500 million. The headcount is expected to grow from the current 200 to 1000 staffers by 2022.

http://www.gamespot.com/news/ubisoft-investing-507m-in-splinter-cell-shop-6374908

Daily Recap: 5/2/2012

jrandall — Wed, 02 May 2012 17:54:47 GMT

It’s been fairly quite around here lately. I’ve been playing Gears of War 2 (yeah – I know, a little late to the party) and it is awesome so far. I’ve also been catching up on a couple of my favorite shows: Awake and The Finder. Both of which are likely to be canceled. So, I either have an awful sense of what makes for good T.V. or the rest of the country does (I’ll go with the latter).

On to what I’ve deemed as newsworthy for today:

Microsoft planning a subscription based Xbox 360

It looks like Microsoft may be toying with providing an Xbox console that will be subsidized by subscription fees. This plan follows the typical cell phone model. Sign up for a multi-year contract and you’ll get the hardware at a deeply discounted cost. In this case, the console will be $99 with a two year Xbox Live commitment of $15/month.

Microsoft definitely likes the subscription model (examples: Music Pass, SkyDrive, Xbox Live) so this is not really too much of a surprise. Companies love that recurring revenue and if this succeeds, it will bring in a boatload of it.

http://www.gamespot.com/news/microsoft-planning-99-xbox-360-with-subscription-report-6374682

Papa’s got a brand new Bing

My favorite search engine (I guess I am a Microsoft fanboy) received some attention today for its new look. Whether you’re on the “they made it look more like Google” or “they made it more Metro” side of the argument, it’s difficult to dismiss the results. They are fantastic. There are a few instantly noticeable changes, such as the typography, spacing etc. I find the subtle changes to be the best. For instance, I love the icons that appear in search results that let you know if one of your friends “likes” the page.

Bing is a formidable challenger in this marketplace. The competition has made it a lot of fun watching internet search evolve over the last couple of years.

http://www.bing.com/community/site_blogs/b/search/archive/2012/05/02/bing-gets-a-new-look.aspx

Windows 8 Tiles, Toasts and Badges tutorial

Gil Cleeren over at the Silverlight Show published a great tutorial on how to work with Tiles, Toasts and Badges within Windows 8. Check it out:

http://www.silverlightshow.net/items/Windows-8-and-the-future-of-XAML-Part-6-Tiles-toasts-and-badges.aspx

Daily Recap: 5/1/2012

jrandall — Tue, 01 May 2012 18:43:26 GMT

Happy May Day. According to Bing, the parties for this springtime event became so risqué that the Catholic Church banned celebrations. Well, if you have time after you’ve been dancing around the maypole, it may be worth checking out the following articles that have been popping up online.

Hulu may start requiring cable subscription

The rumor spreading through the Twitterverse is that Hulu is considering the requirement that its users have a cable subscription. I sincerely hope that this rumor turns out to be false. If it is true, this decision will likely rank right up there with the Netflix debacle awhile ago. The whole point of Hulu is to let folks (like myself) to become free of the outrageous fees that are associated with cable. If I’m going to have to have cable to have Hulu, then why in the hell would I also keep Hulu?

http://www.pcmag.com/article2/0,2817,2403773,00.asp

Great overview of RAW v JPEG

Most (all?) DLSRs come equipped with the ability to “shoot” in RAW. Many newbies (myself included) that bought a DLSR because we wanted more than a point-and-shoot have had the following conversation:

Photographer Friend: Nice camera, what made you decide on the Nikon/Canon?

Newbie trying to be cool: Uhhhh

Photographer Friend: Yeah, I get it. It’s tough to take sides. So, what do you shoot in?

Newbie: Uhhhhh

Photographer: I have a huge memory card, so I usually go the RAW+JPEG route.

Clueless Newbie: I’m going to go stand over here (pointing to anyplace other than where the conversation is taking place)

I remember where I was when this happened. RAW? That sounded like something that the person made up to make me feel ignorant. Well, the joke is on them. I’m ignorant all on my own! Save yourself the embarrassment and read the following article which does a fantastic job of explaining the difference between shooting in the two formats.

http://www.slrlounge.com/raw-vs-jpeg-jpg-the-ultimate-visual-guide

Supermoon of 2012 is coming

The biggest full moon of the year is due to arrive this weekend. Oh and its going to be Cinco De Mayo. Extra full moon lunacy is sure to be in store. Fantastic!

http://www.space.com/15474-supermoon-full-moon-2012.html

If you release an app in the woods will anybody hear it?

Microsoft is going to crack down on app submissions for Windows Phone. I applaud the decision, but maybe they should crack down on their marketing department and get the phones into more people’s hands.

http://www.webpronews.com/windows-phone-marketplace-gets-strict-with-submissions-2012-05

Daily Recap: 4/30/2012

jrandall — Mon, 30 Apr 2012 20:39:11 GMT

Here’s a little Public Service Announcement for all you Xbox 360 owners out there: Back up your save files. The hard drive on my 360 Slim acted up on my Friday evening. The only alternative I had to get the system up and running was to format the drive. All of my game saves are gone.

The symptoms of this failure were very strange. The system would power up as if it were working normally, but it would hang on the the initial animation sequence (where the Xbox orb is displayed). After a minute or two I was presented with the option to sign-in. When I tried my usual gamertag, I received an error that there was no storage found.

I took a look at the system menu and the drive was showing as “Unformatted”. I shut the thing off, pulled the drive, and it booted perfectly. Damn.

I put the drive in and went back to the system menu. The only option I had was to format the drive, which seemed to work. I know that I have a wonky drive, but I’m going to ride it out until it dies completely. In the meantime, I’ll take advantage of saving my game files to the cloud.

Onto the news:

LG is backing out of Windows Phone Development

Unsettling news from the Windows Phone device department: LG is going to cease production of phones aimed at Windows. It looks like LG will keep an eye on the Windows devices, but for the time being, they just don’t see it as a profitable environment.

http://www.theverge.com/2012/4/30/2988392/lg-no-immediate-plans-windows-phone-hardware?utm_source=twitterfeed&utm_medium=twitter&utm_campaign=Feed%3A+WinRumors+%28WinRumors%29

Microsoft + Nook = Newco

In an interesting development, Microsoft is getting into the e-book reader business by investing (to the tune of $300 million) with Barnes and Noble. With the release of Windows 8 around the corner, and the target device being some sort of tablet, this seems like a good match.

http://www.msnbc.msn.com/id/47228807/ns/business-us_business/

Halo 4 Live Action Miniseries

In one of the more awesome trends of recent times, Microsoft will be releasing a live action mini-series based on the Halo universe prior to the much anticipated release of Halo 4. Not only will this series market the game, but it will serve as a refresher to help to bring players up to speed on what’s going on with the Master Chief.

http://www.variety.com/article/VR1118053273

Daily Recap: 4/25/2012

jrandall — Wed, 25 Apr 2012 13:59:05 GMT

Windows Security Essentials 4.0 is available for Download

A new version of this free anti-virus software, available directly from Microsoft is now ready for download. Windows Security Essentials is easy to install and seamlessly runs on your Windows system.

http://windows.microsoft.com/en-US/windows/products/security-essentials

Microsoft SkyDrive now has published data plans

The time we all knew would be coming has finally arrived. Riding the 25GB free storage gravy train on SkyDrive has come to an end. New accounts will receive 7GB free storage with the option to purchase additional storage. The good news is that the rates for purchasing online storage are quite affordable. The better news is that if you log onto your SkyDrive account soon, you will be grandfathered into the 25GB free plan.

https://skydrive.live.com/

NASA Time Lapse from ISS Video is a MUST SEE

If you haven’t had a chance to watch the time-lapse video of the Earth taken from the International Space Station, then you must stop what you are doing and go watch it now.

Time Lapse Video from ISS

Microsoft to preview new music service at E3

The Zune replacement (codenamed “Woodstock”) will ship with Windows 8 later this fall. Highlights of the service from the article on The Verge are:

Cross platform support (Windows, iOS, Xbox and Andriod)
Tight integration into Facebook allowing friends to share tracks and playlists
No plug-in when used from a browser

http://www.theverge.com/2012/4/25/2973682/microsoft-xbox-live-music-service-codename-woodstock-e3-2012?utm_source=dlvr.it&utm_medium=twitter

Programmatically Create Discussion Thread

jrandall — Fri, 20 Apr 2012 20:48:07 GMT

This article will walk-through how to write an event receiver that will create a new Discussion Thread when a Calendar item in another list is added. In SharePoint 2010 it is possible, and quite easy, to programmatically create entries in Lists and and Libraries and this example should demonstrate this.

Setup the Project

The first thing I will do is to create a new 2010 Empty SharePoint Project.

When prompted, connect to an existing SharePoint site (one that has a Calendar and a Discussion Group). For this example, it shouldn’t matter if you choose a Sandbox solution or a Farm solution. I chose Sandbox. Once the solution is setup, you should see something similar to the following:

Next, add an event receiver by right-clicking on the SharePoint project and selecting Add > New Item.

You should get a dialog box indicating that Visual Studio is connecting to your SharePoint site. Once the connection has been established, you will see a list of event receiver types, sources and events. As shown below, I selected List Item Events for the event receiver type, Calendar for the event source and An item was added for the event.

Your solution should now look similar to the following. Note that the Feature and Packaging elements have automatically been created. This solution is technically ready to deploy to SharePoint (although we haven’t added the code for it do anything).

Writing the Code

Visual Studio will also have stubbed out the Event Receiver code and will have it open in the editor. The event that we selected will be ready for us to edit. This is where we are going to put our logic to add a Discussion Thread when a Calendar list item is created.

To create a discussion thread based on the new calendar item we will add the following logic to the ItemAdded event:

Get references to the added calendar item and the current discussion list
Add a new list item to the discussion list

The title of the discussion thread will be the same as the calendar item
Use the built-in command SPUtility.CreateNewDiscussion to create the discussion thread

Update the body of the discussion thread to be the same as the Description of the calendar item

Testing it out

Once this code is in place we can run the solution and add a new calendar entry

When Save is pressed, the ItemAdded code will be run and the new Discussion list item will be created. Note that this may take SharePoint a moment or two to create the list item.

When we look at the details of this new Discussion Thread we will see the attributes that were set in the ItemAdded event.

Review

This example demonstrated just how easy it is to connect to List events within the SharePoint development environment.

Assigning a different drive letter

jrandall — Tue, 24 Jan 2012 16:40:43 GMT

Sometimes you may need to assign a different drive letter to a drive that is on your Windows system.

In the following example, I need to re-assign the PDC2008 drive (an external USB) from drive letter F to E.

This task can be achieved by using the Disk Management feature in the Computer Management program. This program is accessed by right-clicking on the Computer tab in the Start Menu and selecting Manage.

Once in the Computer Management application, select Disk Management located in the Storage option. You will then see a list of the storage drives available on your computer.

From here, right-click on the name drive that you want to change. On the pop-up menu, select Change Drive Letter and Paths…

A Window similar to the following will appear. Select the Change button.

You will now be presented with the Change Drive Letter or Path dialog. Use the drive letter dropdown to select the new drive letter. Press OK and the drive will be remapped with the new letter.

New Stock Photos

jrandall — Fri, 30 Sep 2011 17:41:08 GMT

The following Stock Photos are now available through Dreamstime for your print and website needs.

Please contact me if you have specific image needs or suggestions.

Installing Skype on Windows 8

jrandall — Tue, 20 Sep 2011 14:19:26 GMT

Skype will work on Windows 8. However, if you install it directly from the Skype website, the software may throw an error when it tries to log you in. Here are the steps that I completed (these will need to be done on the Desktop):

Uninstall any previous versions of Skype
Remove all references to Skype from the following folders: ProgramData, ProgramFiles, Users/[username]/AppData/Roaming. These folders are hidden by default. To view them, enable the “Hidden items” checkbox in Windows Explorer. This option is found in the “View” tab (on the right hand side of the ribbon).
Download and install the latest (as of 9/20/2011) from http://download.skype.com/msi/SkypeSetup_5.5.0.117.msi. When downloading, I saved the file to my local folder and installed from there.
It seems like you need to launch Skype from the Start menu (the new Metro style interface). If may crash if you launch from the Desktop.

Notes

Windows Developer Preview Build 8102

Sources

http://community.skype.com/t5/Windows/Windows-8-Developer-Preview/td-p/156212

BUILD News

jrandall — Mon, 05 Sep 2011 15:36:06 GMT

Here are some of the latest contests/rumors/news surrounding BUILD

@coridrew is compiling an attendee list and it can be found at http://twitter.com/#!/coridrew/bldwin2011

How BUILD may change the world

jrandall — Mon, 05 Sep 2011 15:09:49 GMT

The heavily anticipated Microsoft BUILD conference is one week away and we still do not have many details. Microsoft has surrounded this event with secrecy and I really think that the strategy is working. All we basically have is a shell of an agenda. No details of the classes, no word on the swag, we don’t even know what the attendee party is.

So, the question is, by hyping this event up with the secrecy, will Microsoft be able to deliver? I believe so. Call me a MS fanboy but I have faith that their next OS, Windows 8, is going to be a game-changer. We are already seeing the move away from desktops to portable based computing and it will be extremely convenient to have all of our devices seamlessly work with each other and behave similarly.

This has been Microsoft’s plan all along. They got into the console business with the Xbox for a reason. They got into the music player with the Zune for a reason. Both of these devices were huge risks, however they are needed since Microsoft wants to be everywhere you are. Everything is coming together for them. They have devices that can be present wherever you need them and they have a storage system with Azure to feed the data. Want to show your pictures from the last family gathering on you phone, no problem. Want to play your home movies through your Xbox at the next party, no problem. With the devices sharing the same OS (and more importantly the same UX), MS products could become an integral part of the way you live.

Free Hand Drawn Icons

jrandall — Mon, 04 Apr 2011 14:26:14 GMT

177 Designs has a new and unique icon set available for download. These icons form a hand drawn representation of “classic” icons available on many platforms/websites. Best of all, the set of 247 icons is free.

Announcement: GamerCentral partner site

jrandall — Thu, 24 Mar 2011 20:16:02 GMT

I am pleased to announce that the GamerCentral partner site is now live. This website will contain postings about video gaming, movies, music and just about anything else that falls into the realm of geekdom.

I promise that the site will be heavy on opinions and light on walk-through reviews. This is also your site. Let us know how to improve it. What do you want for content. Is it geeky enough or is it too geeky (is that even possible?)

Resolving SCRIPT references in the HEAD

jrandall — Tue, 22 Mar 2011 15:57:17 GMT

I ran into an issue where I needed to resolve a javascript src attribute in the page’s head section. I figured the easiest way to do this would be with a line similar to the following:

Unfortunately, this line of code throws the following error:

The Controls collection cannot be modified because the control contains code blocks (i.e. <% ... %>).

The solution involves swapping out the “<%=” with “<%#” and adding a Page.Header.DataBind() call to the PageLoad event.

An excellent and more thorough explanation for why this occurs can be found on the leedumond.com website.

http://leedumond.com/blog/the-controls-collection-cannot-be-modified-because-the-control-contains-code-blocks/

SharePoint 2010 Developer Resources

jrandall — Tue, 22 Mar 2011 14:41:56 GMT

Here is a collection of developer resources that I have come across for SharePoint 2010. (Last updated 3/22/2011)

Channel 9: SharePoint 2010 Developer Training Course	Microsoft’s version of public access TV has a collection of videos geared to SharePoint 2010 developers. Pretty much all topics are covered in this collection of videos.
SharePoint Product Site	Microsoft’s product site for SharePoint. Not as focused on developers as the other sites, but still contains valuable information.
Microsoft: SharePoint Developer Center	Microsoft’s homepage for SharePoint as a development platform.
Paul Stubbs blog	Paul Stubbs is a Microsoft SharePoint developer “evangelist”. Tons of useful information found here.
Microsoft: Build a Better App	Developer-centric website focused on building SharePoint applications with Visual Studio.

Single Click DataGrid Checkbox in Silverlight

jrandall — Wed, 16 Feb 2011 19:02:00 GMT

When using a DataGrid in Silverlight available from the Toolkit, the DataGridCheckBoxColumn requires at least two clicks to change the state of the check box. One click to select the row and another click to change the value of the row.

The definition of your column may look similar to the following:

To change the behavior, you will need to define a check box within a DataGridTemplateColumn. This can be done by using code similar to the following:

Now the state of the check box can be changed with a single click.

Are you using Extension Methods

jrandall — Thu, 11 Nov 2010 18:47:53 GMT

Extension methods are a valuable resource in your developer toolbox. With them you can construct methods that will appear to be a part of a given type (which you may not have direct control over). According to the MSDN documentation they:

Enable you to "add" methods to existing types without creating a new derived type, recompiling, or otherwise modifying the original type.

At first glance this may not seem to be anything that is overly useful, and reading through the documentation does little to counter this opinion. However, extension methods do have a place in building robust frameworks. A practical example may better illustrate just how useful they can be.

Sample code for this article is available for download at: http://uploadmanager.auburnrandall.com/uploadmanager/DownloadForm.aspx?file=q-2whW6XjkGApIsz5bjHKg&key=Ow%2boRgN5c7TAGhZEb%2fvV%2fw

Short, URL Friendly GUID

When building applications I will often use a GUID to uniquely identify an object instance. Furthermore, I will base64 encode the generated GUID which will both shorten the results and format it so that it can be passed within a query-string. The logic to do this is quite simple and a sample of it can be found in an article written by Mads Kristensen.

Before the introduction of extension methods, I would inevitably wind up with a helper class that would contain this logic. Classes of this nature usually require little thought (and effort) to implement but almost always have adverse downstream effects.

For a detailed no holds barred explanation of why this is, take a quick look at the Are Helper Classes Evil article found over on the Inside Architecture blog.

The method would appear similar to the following:

The implementation of the method would be along the lines of:

Code such as this, although technically accurate, always leaves a bad taste in my mouth. Whenever I revisit an implementation such as this, I have to pause to remember or research what exactly Utility is, and why ShortenGuid belonged there. This type of interruption disrupts my train of thought and makes a code-review process more difficult than it needs to be.

Refactored with Extension Methods

This same code can be refactored to use extension methods.

With the following implementation:

The immediate observation is that the Shorten method appears to the developer as a member of the Guid class. With extension methods, we’ve extended the Guid class with our own method without having to directly manipulate the original object. Very cool.

As a developer reviews this code, it is much easier to infer what the Shorten method does. Since it appears as a method of the Guid class, we also can safely assume that the Shorten method manipulates the Guid instance.

Conclusion

Getting to know extension methods may assist you with developing robust quality applications. It is worthwhile to spend some time familiarizing yourself with how they work and keeping your eyes open to areas where they will fit into your code stream.

Silverlight 4 Themes

jrandall — Wed, 25 Aug 2010 13:28:53 GMT

The Silverlight team has published a set of themes that can be used for your LOB applications. Microsoft’s Tsitsi Gora has a blog posting that contains an overview of these themes.

Briefly, the available themes are:

COSMOPOLITAN

ACCENT COLOR

WINDOWS 7 INSPIRED

ASP.NET Web Site Administration Tool

jrandall — Tue, 06 Apr 2010 18:39:59 GMT

Users and Roles for a website can be defined using the ASP.NET Web Site Administration Tool that is provided with Visual Studio. This guide is intended as a step-by-step introduction to the pages that are required to define users, roles and role membership.

To launch the tool, select the ASP.NET Configuration option within the Website menu option.

The Web Site Administration Tool will be launched for the selected website. Users and Roles are defined by selecting the Security tab.

Create User

To create a user, select the Create User link in the Users group. The following page will display.

Create Role

Roles are created by selecting the Create or Manage Roles in the Roles group on the main Security tab.

Once the Add Role button has been pressed, the newly defined role will be available to manage.

To add users to the role, select the Manage link. You will be prompted to select the users that are members of the Role.

Further information on this subject can be found at: http://msdn.microsoft.com/en-us/library/yy40ytx0.aspx

Catching Unhandled Exception in WPF Application

jrandall — Thu, 23 Jul 2009 13:29:49 GMT

Oftentimes for troubleshooting purposes it is necessary to trap and report unhandled exceptions. This article will demonstrate how to accomplish this within a WPF application.

The default behavior of a WPF application is to catch all unhandled exceptions, alert the user that the software has encountered a fatal error (shown below), and then shut the application down.

Note that in a fully featured production system, rather than display a custom error screen (or log exceptions to a data file) it is possible/desirable to use Windows Error Reporting to analyze errors within your application. When the user presses the “Send Error Report” button Microsoft captures the error report, which you can then view (using a secure account) to identify problem areas.

To display an error report directly within your WPF application, you can trap all unhandled exceptions using the Application.DispatcherUnhandledException event. This is done by modifying the App.xaml and App.xaml.cs files.

In App.xaml, the registration of the event handler is initialized (highlighted below).

A method is added to App.xaml.cs which will handle this event. This is where the exception handling logic will be added.

DispatcherUnhandledException will only handle exceptions thrown on the UI thread. In multithreading applications, you must ensure that exceptions thrown on secondary threads are caught and re-thrown (or handled) on the UI thread. Unfortunately, there is no built-in mechanism for this behavior.

The sample application (source here) displays a window containing a button which fires an exception. The DispatcherUnhandledException event handler is used to display an “Exception Viewer” window, which displays the details of the exception.

As a best practice, you typically do not want to show the end-user the technical details of an exception. A more robust system of error reporting could be implemented that would securely report exception details, while the end-user would only see a dialog that an error has been encountered.

Another alternative is that you could use Windows Error Reporting for deployed solutions, which could be disabled in favor of custom error reporting for internal or development (beta) systems.

Form Engine Announced

jrandall — Fri, 26 Jun 2009 20:06:10 GMT

I am pleased to announce that a new product, Form Engine, is now available. This application will automatically create HTML forms based on PDF documents containing form fields. The data posted to the HTML page will merge with the PDF document creating a new document populated with the data.

Creating a Flyout Panel in Silverlight

jrandall — Wed, 23 Jul 2008 14:26:50 GMT

This tutorial shows how to create a panel in Silverlight that provides a default thumbnail view which will fully appear on selection. The examples that follow were written using Siverlight 2 Beta 2 with Expression Blend 2.5 June 2008 Preview.

To start off, create a new project and open the default page in Expression Blend 2.5. On the Page, the first thing we'll do is create a row on the grid that will hold our thumbnail of the flyout panel. This is highlighted in the following image.

Add a Border to the Grid. Position the control so that a portion of it appears on the grid. This portion is the thumbnail that will be used to open the full panel. The rest of the control will appear off of the page.

Create new Interaction States to indicate the various visibility states for the panel. This is done by creating a new State Group and two new states (shown below as FlyoutStates, FlyoutVisible and FlyoutHidden).

With the FlyoutVisible state selected, make sure State Recording is on and move the panel to the desired location. At this point the panel is entirely visible.

Since the FlyoutHidden state will be the same as the Base state, there is nothing that needs to be done.

The last part of the task is to add a little code that will trigger the state animations. In this example, the flyout panel will become visible when the mouse pointer enters the thumbnail. It will become hidden when the mouse pointer leaves. To respond to these events, select the Event Properties of the Border and add event definitions for MouseEnter and MouseLeave.

In the code for these events, we simply need to switch to the desired event. This is done by using the VisualStateManager GoToState method.

private void border_MouseEnter(object sender, MouseEventArgs e)
{
    VisualStateManager.GoToState(this, "FlyoutVisible", true);
}

private void border_MouseLeave(object sender, MouseEventArgs e)
{
    VisualStateManager.GoToState(this, "FlyoutHidden", true);
}

When you run the program, the panel will animate in and out. However, the animation is very quick and not very smooth. To make the transition a little smoother we need to specify how long it will take to animate each of our States. This is done by giving the Default Transition Duration for the State Group a value (0.5 seconds in the following example).

Now when you run page, the animation used to display and hide the panel is much smoother.

Although this example is very simple without much pizzazz, I hope it sufficiently illustrates how it is relatively simple to add animation to a webpage.

Silverlight Web Services fail when VS Crashes

jrandall — Tue, 15 Jul 2008 15:00:45 GMT

When developing a Silverlight 2 Beta 2 in Visual Studio 2008 using the ASP.NET Development Server a random port is opened that is used to host the web application. When a web service reference is added, this port is part of the URL that points to the hosted web service. Usually, this specific port will be available for the lifetime of the application.

However, sometimes when Visual Studio crashes, the reference to this port seems to get corrupted and a new port is assigned. The issue is that when the port number changes the web reference is still pointing to the original port. The web service will attempt to open the original URL (with the original port). Since this URL is no longer valid, a ProtocolException will be thrown and you will receive the following dialog:

To remedy this, you need to change the web service reference to point to the new port. The first thing to do is to find what the new port has been assigned to. This will be available by examining the URL in the browser.

Once you have the new port, right-click on the web service reference and select Configure Service Reference.

In the Service Reference Settings dialog, change the port in the Address to the new port.

I'm sure that this is a temporary issue (this is a Beta version after all) that will be addressed fully in the released versions.

How to remove the border in Silverlight DataGrid

jrandall — Thu, 10 Jul 2008 14:49:43 GMT

In Silverlight 2 Beta 2 the generated DataGrid is surrounded by a border. Unfortunately, the removal of this border cannot be accomplished by simply setting a property on the DataGrid. To remove this, the definition of the DataGrid style or "skin" will need to be overridden.

The appearance for each Silverlight control (FrameworkElement) is defined within a ControlTemplate. Using Styles, this template can be overridden within your application with a set of customized XAML code. Default XAML definitions are found within the Silverlight Control Styles and Templates documentation. Specific to this topic, XAML definitions for the DataGrid are found in the DataGrid Styles and Templates documentation.

In the DataGrid XAML, look for the Template definition. Once this has been located, note that the RootElement of the the DataGrid is surrounded by three distinct Border elements.

These elements are likely the items that need to be removed. To start the customization, the style XAML for the DataGrid will need to be added as a new resource into our application. I'm going to add this directly to my UserControl, but it could also be added to the Application resources (in App.xaml).

To add the XAML to the UserControl create a new node named UserControl.Resources and copy the DataGrid XAML into it (use the handy "Copy Code" link on the documentation web page).

The namespace definitions for the DataGrid and the Resource must match. In the copied XAML the namespace is local:DataGrid. The default namespace generated by the Visual Studio tool is my:DataGrid. In the above example, I changed all references of local to my.

The next item to take care of is that the Style must have a Key. This is used to map a Framework element (our DataGrid) to a specific style definition. I've given the style a key of TestGrid which is used in the following DataGrid definition.

At this point, when you run the application the DataGrid should appear exactly as it did before (we haven't changed anything yet).

Before I start removing the definitions for the Border elements, I want to make sure that these are the culprits. To do this, I'm going to change their colors to something a little more obvious.

Running the application, I get the following:

Zooming in, it's obvious how these elements take part in the display of the DataGrid.

Removing the Border elements from the XAML generates the desired results.

Hopefully, this not only provides a reference for how to remove the border from a DataGrid, but also provides a quick introduction to the possibilities available for customizing Silverlight controls.

Rock Band customer service Rocks

jrandall — Mon, 07 Jul 2008 18:13:23 GMT

The other day I went to play Rock Band on my XBox 360. It booted to the main menu and then gave me an error message that the disk was unreadable. I took the disk out and looked at it closely and noticed that there were a couple of circular scratches on it. It looked like the console had somehow scratched the disk.

When I called EA support, I was completely prepared to have to send in my disk and then wait for a new disk to be sent back. I figured that not only would I not be able to play my game for about a month, I'd also have to deal with the hassle of shipping the disk.

To my surprise, I didn't have to do any of that. After answering some basic questions from the support technician, he told me that a new copy should be arriving within the next couple of weeks.

How awesome is that? EA far exceeded my expectations by resolving the issue in as quickly and as simply as possible. For the pittance that it will cost them to send a new disk, they went a long way to establishing brand loyalty.

Now, all I have to do is watch the mail for that new disk!

Adding validation to a custom Control

jrandall — Tue, 13 May 2008 17:50:46 GMT

ASP.NET Pages contain an infrastructure to help simplify User Input Validation. Typically, validation is accomplished by using one of the several built-in Validator controls. The interaction between the Page and the Validator control is performed through the implementation of the IValidator interface. Using the derived methods of this interface, the Page can query each of the Validator controls to determine if the User Input meets the predetermined criteria.

Implement IValidator in your Control

Sometimes a custom Control author may not need (or want) to use a Validator to determine user input validity but will still want their control to participate in page validation. This is accomplished by having the control implement the IValidator interface. The member implementation of this interface can be summarized as below:

ErrorMessage	When the validation fails this is the text that will be used by the ValidationSummary control.
IsValid	Used by the validation infrastructure to determine if the User Input is valid.
Validate	This method will be called during page validation(When Page.Validate()) is called). Implementation of this method needs to check the user input validity and set the IsValid property.

Register the Control as a Validator

Once the above members have been implemented within your control, it will need to be registered as a Validation control for the Page. This is done by adding the control to the Page.Validators collection as shown in the following example.

protected override void OnInit(EventArgs e)
{
    base.OnInit(e);

    this.Page.Validators.Add(this);
}

Conclusion

Validation of User Input can easily be handled directly within a custom control. This is especially useful when complex validation logic must take place that cannot be handled by one of the bundled Validator controls.

MSN's hating on ethanol today

jrandall — Tue, 08 Apr 2008 14:26:27 GMT

If you take a look at the MSN site today, there are two articles that address using ethanol as an alternative to gasoline:

Bad ideas in 'green tech' (from Newsweek)

Does it make sense to fill your gas tank with corn? (from MSN Money)

Both of these articles pose several arguments why corn ethanol is a poor choice as an alternative fuel. Chiefly:

Production and delivery of corn ethanol is double the carbon footprint as gasoline.
Should we be burning our food when there are people starving? Corn is a major product in packaged food.
The current goal of increased corn production would require additional crops equivalent to the size of Kansas and Iowa combined.

While Begley's "Sounds Good But..." article takes an extremely negative tone toward ethanol, she discounts much of all of the currently available alternatives. She doesn't offset her doomsday scenarios with any real suggestions of what a typical consumer can do to help reduce greenhouse gases. When you finish reading the article, your left feeling helpless and hopeless. This is not exactly an rally call for change.

Monroe's article "Ethanol reality check" takes a more reasonable approach. She points out the numerous flaws inherit with corn based ethanol. She also does a good service to spelling out the counter arguments to these flaws. The single most intriguing question that she leaves us with is: Is corn based ethanol a stepping stone to producing ethanol from a non-food source?

For all of the problems related with corn-based ethanol, it is a technology that is available today. If we can harness this in the short term and start building the necessary delivery infrastructure, will we be better off tomorrow when we're able to produce ethanol using other methods?

ITemplate - Referencing Nested Controls

jrandall — Mon, 24 Mar 2008 18:52:42 GMT

When authoring templated controls the default behavior is that you cannot directly reference child controls. For example, say we have the following ASPX code defining the layout of the templated control.

<mc:MyTemplateControl runat="server">
    <TestTemplate>
        <asp:Label runat="server" ID="TestLabel" />
    </TestTemplate>
</mc:MyTemplateControl>

Furthermore, the following snippet is used to attempt to reference the nested Label.

protected void Page_Load(object sender, EventArgs e)
{
    TestLabel.Text = "hello";
}

When we attempt to build this page, the following error occurs:

The name 'TestLabel' does not exist in the current context

If you do not have the ability to change the source of the templated control, the only alternative is to use the FindControl method. Unfortunately this syntax requires having the ID of the control hard-coded into the code-behind of the page. When the location or ID of the control changes, a subsequent change will need to be made to this hard-coded value. If this change is not made, the compiler will not pick up the oversight. The only notification of this error will be made at runtime, which leads to a situation that may be very difficult to diagnose.

If you do have access to the source of the templated control you can simply modify the property that implements ITemplate with the TemplateInstance attribute.

[TemplateContainer(typeof(MyTemplateContainer))]
[TemplateInstance(TemplateInstance.Single)]
[PersistenceMode(PersistenceMode.InnerProperty)]
public ITemplate TestTemplate
{
    get { return _testTemplate; }
    set { _testTemplate = value; }
}

With a value of TemplateInstance.Single, you will now be able to directly reference the children controls.

Complex Object data binding

jrandall — Wed, 05 Mar 2008 21:03:19 GMT

There are times when we want to databind to a value that is derived from a complex property. For example, we may want to bind to a field in a GridView similar to the following:

In this example the property StandardEngine is an instance of the Engine class. In the GridView we want to display the number of cylinders for the car. We get this by referencing the StandardEngine.Cylinders value.

On the surface, this seems like a legitimate way to bind to this property. Unfortunately when this is executed the following exception is raised.

Since the default behavior of the BoundField control does not support nested references, the first thing that we must do is to convert the BoundField into a TemplateField. This provides us with more control on how the data will be displayed and its evaluation during the data binding process.

You'll notice that the Text attribute has been left blank. Two approaches, explained below, are available that can be used that will be used to populate this value.

Use Casting

One method that can be used is to cast the instance variable to its native type and then retrieve the value through a property reference.

This approach requires little additional code and works well when the instance property is not null. However, this method should not be used if there is a possibility that this property will be null.

Use a Method

Anther option is to define a method (most likely on the page) that will return the property value based on an instance of our data bound class. Using this pattern, our ASPX code will appear as follows:

The supporting method will appear as below:

Although this solution requires more code it is much more robust as far trapping for invalid data conditions is concerned.

Horizontal Menu with CSS

jrandall — Fri, 22 Feb 2008 15:40:23 GMT

One method that is commonly used to display a menu is to use CSS along with an Unordered List (UL). There are many articles that already discuss this technique in-depth, but the basic idea is that you define your menu such as:

<div id="nav">
    <ul>
        <li><a href="#">Menu 1</a></li>
        <li><a href="#">Menu 2</a></li>
        <li><a href="#">Menu 3</a></li>
    </ul>
</div>

This renders as following (not that the background color for the "nav" element has been set to a light blue):

From here you can define a style to control how to display the list item elements. For this example, the menu will display horizontally on the page.

#nav li
{
    display: inline;
}

This renders as:

For the most part, this is exactly what we want. However, there is some unaccounted for space before "Menu 1". Using the Internet Explorer Developer Toolbar and selecting the "UL" element, it is evident that there is a default value for the margin-left property of 30pt.

We'll need to override this to push the menu all the way to the left. This is done with the following style definitions. Although only the margin-left property was showing with a default, I've also set the padding-left property for good measure.

#nav ul
{
    margin-left: 0;
    padding-left: 0;
}

Now the menu will correctly render as:

Sorting using IComparer(T)

jeremy — Thu, 24 Jan 2008 18:57:28 GMT

When working with a collection, such as List<T>, there are many available methods that can be implemented to perform the object comparison that determines the sort order. One of the comparison options is to provide a class that implements IComparer<T>.

According to the MSDN documentation, this interface is used to "define a method that a type implements to compare two objects". Classes that implement this interface must define a Compare method. Within this method, you provide the logic that is used to determine how two type instances match up.

To illustrate this we'll use the Car class (shown below), and build a IComparer class that the Sort routine will use.

public class SimpleComparer : IComparer<Car>
{
    #region IComparer<Car> Members

    public int Compare(Car x, Car y)
    {
        return x.Make.CompareTo(y.Make);
    }

    #endregion
}

This class would be used by the Sort method as follows:

// build list from data layer
List<Car> cars = Car.GetCars();

cars.Sort(new SimpleComparer());

Since the only property that is compared is the Make property, this implementation assumes that a Car collection will always be sorted by Make. This is fairly restrictive. What if we want to sort by other properties? Fortunately a decent pattern has evolved within the .NET community that simplifies this.

Essentially, the pattern implements a Comparer class that provides a set of sorting options for a specific type. The consumer will determine which option to use and create a new instance of the Comparer class targeting the selected option.

This pattern can be summarized, and implemented, with the following steps.

Define an enumeration of the available sorting options.
Create a private field that is used to indicate the current sorting method.
Limit the scope of the default constructor in the Comparer class to protected.
Create a public constructor that parameterizes, and assigns, the sorting method.
In the Compare method, use the sorting method to conditionally determine which property (or properties) to sort by.

By following these five simple steps, we now have a robust Comparer class that can be used to sort a collection based on a number of pre-determined sorting options.

public class CarComparer : IComparer<Car>
{
    // Enumerate the available sorting methods
    public enum CarSortOptions
    {
        Make,
        Model
    }

    // Create a field for the desired sort option
    private CarSortOptions _sortOption = CarSortOptions.Make;

    // Restrict the scope of the default constructor
    protected CarComparer()
    {
    }

    // Create a constructor that specifies the desired sort option
    public CarComparer(CarSortOptions sortOption)
    {
        _sortOption = sortOption;
    }

    #region IComparer<Car> Members

    public int Compare(Car x, Car y)
    {
        // Use the Sort Option to determine the property to Compare
        switch (_sortOption)
        {
            case CarSortOptions.Model:
                return x.Model.CompareTo(y.Model);

            default:
                return x.Make.CompareTo(y.Make);
        }
    }

    #endregion
}

Note that although simple examples of property sorting was used (using the CompareTo method), more complex data based algorithms could be substituted.

The following lines illustrate how this Comparer may be used to sort a collection.

// Build list from data layer
List<Car> cars = Car.GetCars();

// Sort by "Make"
cars.Sort(new CarComparer(CarComparer.CarSortOptions.Make));

// Sort by "Model"
cars.Sort(new CarComparer(CarComparer.CarSortOptions.Model));

If you find yourself needing to expose a powerful, and possibly complex, set of sorting options for a class, implementing IComparer<T> along with the above pattern could prove to be a useful tool.

Check in Policies and Trust

jeremy — Mon, 21 Jan 2008 20:44:26 GMT

I recently came across a post which summarizes that the presence of check-in policies implies a lack of trust of the contributing developers. His assertion is that when such policies are put into place they mask fundamental issues in the development process within an organization.

It's about Standardization

Why do we want developers to meet a certain set of criteria before they check code in? It basically boils down to having a set of code that meets some form of local standards. Organizational standards increase the overall familiarity, quality and maintainability of the established code base. Implemented standards can take on a number of forms and will likely differ from organization to organization. Some general examples follow.

Does the structure (layout) of the code meet established guidelines?
Is the changeset associated with a work item?
Has the code been properly tested with a set of unit tests?
Does the change break the overall build of the product?

If you buy into the fact (as I do) that an issue is more expensive to address the further "downstream" it appears, then you'll want to address as many of these as possible as early as possible. To that end, standards can be thought of as the first line of Quality Assurance. In this case, we're trying to weed out issues that can easily be remedied early in the development process.

Is it about Trust?

With that in mind, is the enforcement of standards during the check-in an issue of trust? While I do agree that in an ideal world, contributing developers would have the knowledge, experience and discipline to virtually render check-in policies useless. But as is often the case, there are things that happen that will disrupt this development utopia. Programmers come on board that are not completely familiar with the local policies, or a harried developer will try to get the latest hot-fix in as quickly as possible, and so on.

In these circumstances it's not that the developers should be mistrusted but rather a mechanism is needed to ensure that checked-in code meets the set of standards. This mechanism, the check-in policy, becomes a sanity check that provides a level of comfort that the checked-in code is complete.

What it comes down to is that Programmers are human and that, however talented and "trustworthy" they may be, they may simply overlook a fundamental step in the process. This will lead to unqualified code that will have been mistakenly checked-in.

Summary

Well implemented check-in policies should not interfere with a good developer's day-in and out activity. In fact, if a developer completes their task as assigned, the policies should be completely transparent from their check-in. For the developer that overlooks a critical step, the policy is in place to ensure that they complete their task before check-in.

Convert a .NET Color to a Hex value

jeremy — Thu, 17 Jan 2008 19:34:00 GMT

The following method uses an option of ToString() to convert a Color to its Hex representation.

/// <summary>
/// Converts a Color to a Hex representation RRGGBBAA. Alpha (opacity) 
/// channel is included at end of returned value. 
/// </summary>
/// <param name="c">Color</param>
/// <returns>Hex representation</returns>
private string GetHex(Color c)
{
    string rx = c.R.ToString("X2");
    string gx = c.G.ToString("X2");
    string bx = c.B.ToString("X2");
    string ax = c.A.ToString("X2");

    return rx + gx + bx + ax;
}

Casting and State Variables

jeremy — Thu, 10 Jan 2008 19:24:02 GMT

When working with ViewState and SessionState variables, you must use casting operations to convert the value from the state data type into the instance data type. In C#, there are two methods that you can use to perform this operation.

// Method 1
Car c = ViewState["MyCar"] as Car;

// Method 2
Car c = (Car)ViewState["MyCar"];

In normal circumstances, either method will perform the desired task of getting an object from ViewState into a Car instance. However in certain situations both methods have their drawbacks.

Casting using the "as" keyword

When performing a casting operation using the "as" keyword, the instance variable will be assigned to null when the cast cannot be performed. This will happen when either the object instance is null or is of the wrong type.

ViewState["MyCar"] = null;
ViewState["MyCar"] = new Person();

When using the "as" keyword, either of the above statements will result in a null value when trying to cast to a Car instance. This may be desired in the first example. In the second example, where the ViewState instance has been assigned to the wrong type, we clearly have a bug. Unfortunately when this code is run, the car instance will be null and the fact that we're converting from the wrong type will not be caught. This can be a tricky bug to troubleshoot.

Casting using the "C" style

The second form of casting, using the C style casting, exceptions will be thrown when the cast operation cannot be performed. Either of the previous examples will result in an InvalidCastException being thrown. This is not necessarily what we want in the first case, so we'll have to check for null. In the second case, this is exactly what we would want.

Casting with State variables

When dealing with State variables, I prefer to use the C style casting. Although I have to explicitly check for null before every cast, I am assured that the instance that I am casting from will be of the correct type (otherwise an exception will be thrown).

I find that when working with anything that needs to use constant strings as keys (as is the case with State variables), it is very easy to type in the wrong key in the wrong place. This sequence could easily lead to the State variable containing the wrong type. When this wrong type is referenced later in the code I want an exception to be thrown. I want to know that I have a bug in my code and having the exception will force the issue.

If I cast using "as" I will not get the exception and the program will run uninterrupted. When I finally get a problem, it will initially be seen to be unrelated to the real problem - that the wrong value was read from State.

Printer Troubleshooting

jeremy — Thu, 20 Dec 2007 14:53:47 GMT

Last night I received a call from a friend that was having troubles printing a document. The document was queuing up fine, it just would not print. He explained the steps that he went through before calling me. Namely, he:

Rebooted the entire system (and turned the printer off).
Uninstalled and reinstalled the printer.
Checked all of the connections from the printer to the computer.
Tried hooking the computer up to a different USB port.
Went online to the manufacturer's web site for any other troubleshooting hints (there were none)

Since he had pretty much done everything that I would have suggested, I was a bit at a loss of what to do next. The one thing that kind of struck me was that the printer needed to be completely removed from the OS and re-added. I suggested he try the following:

Delete the printer from the "Printer and Faxes" option on the Start menu
Disconnect the printer from the computer (unplugging it from the USB port)
Reboot the computer.
Once the OS is back, plug the printer back in.
At this point the "Plug and Play" dialog will take over prompting for the install of the printer.
Try printing the document.

This worked.

Close those SCRIPT tags

jrandall — Mon, 17 Dec 2007 20:38:17 GMT

When declaring SCRIPT elements in the HEAD section of your web page, as highlighted below, there are two methods available for closing the tag.

Since I feel that the first option creates "cleaner" looking code, I tend to prefer closing HTML tags that do not contain any content in this manner. However, there is a nifty little bug in Internet Explorer. If you close a SCRIPT element as shown in the first example, the browser will not execute javascript as expected.

To illustrate this, create two files. The first will be a javascript file name MyScript.js and it will contain the following line:

alert("HERE");

The second file will be the HTML page that references the javascript file.

<html>
<head>
    <title>Untitled Page</title>
    <script type="text/javascript" src="MyScript.js" />
</head>
<body>
    <script type="text/javascript">
        alert("In Body");
    </script>

</body>
</html>

When viewing this page in Internet Explorer, the "In Body" alert will not show. IE is crashing on the closing of the SCRIPT element defined in the HEAD section. When you reformat this element to use the fully closed syntax (option 2 shown above), the "In Body" alert will show.

Specifying a new DEFAULT in Access SQL

jeremy — Fri, 14 Dec 2007 19:34:05 GMT

I have been trying to change the default value of a column using an SQL statement for one of my Access databases. Like the hundreds of other times that I've done this, I fired up Access to test my Query using SQL View. In the SQL window I entered:

ALTER TABLE MyTable 
    ALTER COLUMN MyColumn BIT DEFAULT 0;

This being a very straightforward operation, I figured I was all set. Unfortunately, when I attempted to run this query I received the following error:

Thinking that I may have somehow run into some Access SQL inconsistency, I started to search through MSDN. After a bit of digging, I ran into this post on Intermediate Microsoft Jet SQL. In particular, there was the following entry:

"The DEFAULT statement can be executed only through the Jet OLE DB provider and ADO. It will return an error message if used through the Access SQL View user interface."

Nice.

I put the above SQL statement into my application, and the ALTER performed properly.

Dynamically adding links to Header

jeremy — Tue, 11 Dec 2007 20:35:46 GMT

When developing an ASP.NET page, one common requirement is programmatically add links to the HTML Header section. An example of this is to conditionally reference a CSS stylesheet. Fortunately, there is a simple solution by creating an instance of the HtmlLink control and then adding it the the Page.Header.Controls collection.

protected void Page_Load(object sender, EventArgs e)
{
    HtmlLink link = new HtmlLink();
    link.Attributes["rel"] = "stylesheet";
    link.Attributes["type"] = "text/css";
    link.Attributes["href"] = "~/DynStyleSheet.css";
    Page.Header.Controls.Add(link);
}

Note that this technique is not limited to stylesheets. Any type of link can be added.

Calling one constructor from another in C#

jeremy — Thu, 06 Dec 2007 19:19:42 GMT

When developing classes that have multiple overloaded constructors, it is possible to call one constructor from another using the this keyword. In the following example, the constructor that accepts the name parameter will call the parameter-less constructor.

public class Person
{
    private string _name;

    public Person()
    {
        // This code executes first
    }

    public Person(string name) : this()
    {
        // This executes after Person() is complete
        _name = name;
    }
}

When one constructor calls another in this fashion, the constructor referenced by the this keyword will execute first.

Handling empty data in a Repeater

jeremy — Wed, 05 Dec 2007 21:45:40 GMT

As powerful and elegant as the Repeater control is, there is no built mechanism for handling how an empty data condition will be displayed. Other controls, for example the GridView, provide properties and templates that will be rendered when the DataSource is void of data. Unfortunately no such behavior is built into the Repeater control. Fortunately, due to the inherent flexibility of the Repeater, it is fairly easy to add this functionality. Within this article, we'll explore using an existing Repeater to display a message when the data collection bound to the repeater is empty.

In the following code example, a Repeater is used to generate a table based on a databound Collection.

<asp:Repeater runat="server" ID="Repeater1">

     <HeaderTemplate>

         <table width="80%">

     </HeaderTemplate>

     <ItemTemplate>

         <tr>

             <td><asp:Label runat="server" Text='<%# Eval("Model") %>' /></td>

         </tr>

     </ItemTemplate>

       <FooterTemplate>

         </table>

     </FooterTemplate>

  </asp:Repeater>

if (!IsPostBack)

  {

       List<Car> cars = new List<Car>();

       Repeater1.DataSource = cars;

       Repeater1.DataBind();

  }

Since there haven't been any items added to the "cars" collection, the ItemTemplate will not be used and the Repeater will generate an empty table. Note that the behavior is to render the HeaderTemplate and FooterTemplate even though an empty collection has been bound to the Repeater. The following shows the resulting HTML.

<table width="80%">

  </table>

Since the Header will render regardless of if there is are any items in the collection, this is a good place to put the HTML (or ASP.NET controls) that will display when there is no data to display. We will also set the Visible property based on the data count of the Repeater's DataSource.

Building on the previous example, the HeaderTemplate will now contain:

<table width="80%">

     <tr runat="server"

         visible='<%# ((ICollection)Repeater1.DataSource).Count == 0 ? true : false %>'>

         <td>

             There is no data to display

           </td>

     </tr>

There are a couple of items that should be noted in the above example.

The Repeater has been referenced by it's ID.
The DataSource property of the Repeater has been cast to an ICollection object. DataSource is defined as type object, but when data is bound to it, it must be of type ICollection. We are using the Count property from this interface to determine if the "Empty Data" message should display.

When there are several controls where the Visible property needs to be set, the logic can be moved to the code-behind for the page. This is shown in the following IsDataEmpty property.

protected bool IsDataEmpty 

  {

       get

       {

           ICollection list = Repeater1.DataSource as ICollection;

           return list.Count == 0 ? true : false;

       }

  }

The ASPX will change to reference this property as follows:

<table width="80%">



     <tr runat="server"

         visible='<%# IsDataEmpty %>'>

         <td>

             There is no data to display

           </td>

     </tr>

Regardless of which approach you use, the resulting HTML will now look like:

<table width="80%">

     <tr>

         <td>

             There is no data to display

           </td>

     </tr>

  </table>

As shown in the above examples, it is fairly simple to add HTML that will conditionally render based on the presence (or lack) of data bound to a Repeater.

Using Session State to pass page variables

jeremy — Thu, 29 Nov 2007 19:13:02 GMT

When one page redirects to another, the destination page may rely on information that was gathered on the calling page. A popular form of passing this information is to use Session State variables.

On the first page, logic similar to the following would appear:

// myObject will be filled with values that are needed on PageTwo
Session["MyData"] = myObject;

Page.Redirect("~/PageTwo.aspx");

PageTwo.aspx can now reference the Session variable "MyData" to retrieve and process the information.

MyObject instance = Session["MyData"] as MyObject;

This technique can be used to effectively pass the instance of an object from one page to another. A caveat to this approach is that you must be aware of how long the session information will stay "alive". If not properly cleaned up, this information will continue to tie up resources on the web server until the session ends. This happens when the user either logs out of the application or closes the browser.

One method of cleaning up session data is to do so when the user completes the process they are currently engaged in. For example, I could hold information in Session until the user presses the "Submit" or "Cancel" button. This works fine if the user is guaranteed to press either of these buttons. What happens if they don't ? What if they decide to just navigate away from the page instead of pressing "Cancel"?

The information will remain in Session until the user's session ends.

Or, to put it another way, the information will tie up resources on the web server for no good purpose (assuming that the other pages in the web-site have no interest in this data) until the user's session ends.

When developing pages, I like to dispose of my Session variables as soon as I can. One method that can be used is to consume the relevant information in the calling page and then immediately remove the session instance.

if (!Page.IsPostback)
{
    MyObject instance = Session["MyData"] as MyObject;
    
    // ... (do work based on instance data)

    Session["MyData"] = null;
}

Granted, it isn't always as cut and dry as this, but bear in mind how and when you're using session resources. Where possible, ensure that invalid session information is removed from these resources.

An Introduction to ASP.NET Web Applications

jeremy — Thu, 15 Nov 2007 19:16:41 GMT

One of the traditional obstacles in developing client-rich web applications within ASP.NET has been the fact that pages must fully refresh on every postback. During the postback, the browser will display a brief "flash" as the page information is sent and received to and from the web server. This "flash" is a main item that differentiates the usability of a rich-client application from that of a web application.

To address this, the notion of a "partial postback" has been introduced. The idea here is that only the portion of a page that need to be updated will be sent to the browser. Once the browser receives the new information, it will only update the section on the page that has changed. This partial update eliminates the need for a full page refresh to occur, thus eliminating the dreaded "flash".

To implement this approach, both ends of the browser-webserver communication will need to have infrastructure elements, or Managers, put into place to handle the transactions. The Server Side Manager will deal with identifying and packaging the updated content that will be sent to the client. The Client Side Manager will deal with parsing the package and displaying the updated information into the browser.

Using the ASP.NET AJAX extensions, the server side transactions are handled using the ScriptManager control. Areas on a page that can participate in partial page rendering are identified using the UpdatePanel control. Essentially, when a partial postback is encountered, the ScriptManager will interact with any UpdatePanel controls to determine what HTML needs to be sent to the client.

The client side is implemented using the PageRequestManager. This receives the content from the ScriptManager and uses javascript to "inject" the newly rendered HTML markup into the existing web page.

These tools provide a great starting point for transitioning your web site into a web application. Examples of how to use the ScriptManager and the UpdatePanel can be found in the ASP.NET AJAX documentation.

Binding data to a nested Repeater

jeremy — Thu, 08 Nov 2007 21:17:43 GMT

When building a page in ASP.NET, it is sometimes helpful to use repeaters nested within a main repeater to display hierarchal data. This concept is shown using the following pseudo-code.

<asp:Repeater runat="server" ID="MainDataRepeater">
    <ItemTemplate>
        <%-- Databound instance data will appear here --%>
        <asp:Repeater runat="server" ID="SecondaryDataRepeater">
            <ItemTemplate>
                <%-- Repeating subset data will appear here --%>
            </ItemTemplate>
        </asp:Repeater>
    </ItemTemplate>
</asp:Repeater>

When following a pattern such as this, the main technical hurdle is determining how to get the data in the nested repeaters to bind properly. Fortunately, ASP.NET provides a couple of options that greatly simplify this task.

Setup the Object Model

The following examples will build on the infrastructure that was started in a previous post. In addition to the previously defined Car class, another class will be defined that represents information about the car for each model year.

In this simple example, the resulting page will show the model years for each car instance. This is shown highlighted in the following image.

Now that the objects have been setup, and the desired page has been laid out, the options used to reach this conclusion will be explored.

Databind to the Property

The easiest way to have the nested repeater access its data is to have it bind to a property of each instance. In our example, this implies that the nested repeater will bind to the ModelYears property.

<asp:Repeater runat="server" ID="CarListRepeater">
    <ItemTemplate>
        <%# Eval("Make") %> <%# Eval("Model") %> 
        <strong><%# CheckAvailable(Container.DataItem) %></strong>
        
        <asp:Repeater runat="server" ID="ModelYearRepeater" 
            DataSource='<%# Eval("ModelYears") %>'>
            
            <ItemTemplate>
                <%# Eval("Year") %>&nbsp;
            </ItemTemplate>
        </asp:Repeater>
        
        <br />
    </ItemTemplate>
</asp:Repeater>

In this code snippet, ModelYearRepeater is bound to the ModelYears property by assigning the DataSource property. Each databound instance of this Repeater will be a ModelYear type, which satisfies the Eval("Year") statement.

Databind to a Method

Although databinding to a property is convenient and should be used whenever possible, a property containing the subset data is not always available. In these situations, the data will need to be built as each of the main data items are bound. To do this, build the subset data in a page source method, and bind the secondary repeater to that method.

In our example, the method that will gather the data is defined as such:

protected List<ModelYear> GetModelYears(object dataitem)
{
    Car car = dataitem as Car;

    return car.ModelYears;
}

Note that this is returning the property of the dataitem. In real world examples, much more code will be written here. Once this method has been written, the secondary repeater will use it as its datasource (sending the current dataitem as the input parameter).

<asp:Repeater runat="server" ID="CarListRepeater">
    <ItemTemplate>
        <%# Eval("Make") %> <%# Eval("Model") %> <%# CheckAvailable(Container.DataItem)%>
        
        <asp:Repeater runat="server" ID="ModelYearRepeater" 
            DataSource='<%# GetModelYears(Container.DataItem) %>'>
            
            <ItemTemplate>
                <%# Eval("Year") %>&nbsp;
            </ItemTemplate>
        </asp:Repeater>
        
        <br />
    </ItemTemplate>
</asp:Repeater>

Binding complex logic in a Repeater Control

jeremy — Wed, 07 Nov 2007 20:28:27 GMT

When using an ASP.NET Repeater (or other databound controls for that matter), it is often desirable to display complex information that is calculated based on properties of the originating datasource. Using databinding syntax it is fairly easy to display the information that is defined in the data bound object. However, to display additional information, there are a few patterns that could be followed.

Databinding syntax could be added on the page to calculate what to display. This is useful for trivial scenarios, but will quickly become unreadable for complex calculations and will fragment you page source.
Override the ItemDataBound event for the Repeater and use FindControl to do the update. The drawback to this technique is that the control ID must remain in sync between the page definition and the code behind. Code that contains a number of FindControl statements quickly becomes difficult to read.
Create a method in the page behind that performs the calculation for the databound instance. This will be the approach that will be followed.

In the following example a repeater will be bound to a list of car objects. For each item in this list an optional message will display indicating if the car is available.

To represent the Car, the following class will be used.

The collection that is bound to the repeater will be defined in the Page_Load event.

protected void Page_Load(object sender, EventArgs e)
{
    List<Car> cars = new List<Car>();

    cars.Add(new Car("Toyota", "Camry"));
    cars.Add(new Car("Nissan", "Altima"));
    cars.Add(new Car("Ford", "Mustang"));

    CarListRepeater.DataSource = cars;
    CarListRepeater.DataBind();
}

For the complex calculation, a method will need to be defined in the code-behind for the page. This method will accept the current databound instance as input. In our example, the method will perform a calculation that will determine if the Car instance is available.

protected string CheckAvailable(object dataitem)
{
    Car car = dataitem as Car;

    if (car.Model == "Altima")
    {
        return "This is available";
    }

    return "";
}

This method can be accessed within the Repeater using the data binding syntax. The current databound instance will be accessed through the Container.DataItem property available from the Repeater.

<asp:Repeater runat="server" ID="CarListRepeater">
    <ItemTemplate>
        <%# Eval("Make") %> <%# Eval("Model") %> 
        <strong><%# CheckAvailable(Container.DataItem) %></strong><br />
    </ItemTemplate>
</asp:Repeater>

Using this form of data access is a useful item to be aware of when dealing with databound list controls. With it, the logic is kept off of the page source, the page source control definitions are kept out of the page-behind and the logic remains centralized. This all leads to much more manageable code.

The Design in Software Development

jeremy — Thu, 01 Nov 2007 17:36:20 GMT

When developing software, we go through many iterations of how to get the "Design" just right. We start with an idea and break this down into consumable units that we can easily develop. From this point, we may have a full fledged specification complete with UML diagrams and class definitions or we may have a hand written note that sketches out the overall goal of the system.

Regardless, we start out with some semblance of a Design through these supporting documents. It's important to realize that these documents, although a good start, will not comprise the actual design. The Design of the software is the source code. Since our specification documents can (and will) become outdated, the source code is the only reliable snapshot of the system that will be built.

To that end, we need to make sure that our source code is readable and discoverable enough to easily infer the purpose of the software. We cannot have elements of the system scattered haphazardly across several logical layers or partitions. We must make sure that the participants of the design (classes, pages, objects...) are grouped and named in such a manner that it is evident how they fit into the overall scheme.

We also must discipline ourselves to put sufficient thought into what goes into the design. In this role we become visionaries of how the system will be used in the future. We also must make sure that we can come back at a later point and redo elements of the system without causing massive disruption.

Quality software and quality design go hand in hand. When approached with the task of developing a system, take the time up front to at least think about how the pieces will fit together. I'm not advocating over-analyzing things, as this leads to other problems, but make sure that you are positioning yourself in a situation where you'll be able to easily adapt to new constraints.

When errors lose their value

jeremy — Tue, 30 Oct 2007 17:32:59 GMT

I have a 2006 Toyota 4Runner that I absolutely love to drive. Unfortunately, the other day an indicator started to show on my dashboard. After digging through the manual for a few minutes, I found out that this was an alert for low tire pressure. Since this error light is generic for any of my four tires, I promptly checked the pressure in all four tires. What do you know - everything was fine. After a bit of research I found out that even the spare can trigger this indicator. It's probably that tire that's giving me the problem.

Since I really don't have the ability currently to drop the spare and check the pressure, I've been riding around with the warning light on. Essentially, this alert system has been rendered useless because I cannot pinpoint where the problem is occurring. This system would have been much more useful if:

I had known immediately what the error was. I should not have had to spend any time looking through the manual to match the light to an error.
I should have been able to know exactly which tire was low and by how much.

In other words, the system should have told me what the error was, and how to fix it.

How does this relate to programming?

This experience has provided me with some insight into how we, as software developers, need to keep in mind our end-users when they encounter invalid conditions in our programs. If we give them too much information that is too technical, they will likely ignore the error or worse, ignore our application. If we give them too little information, we are not enabling them to fix, or take part in fixing, the issue.

When developing applications, error reporting should not be an afterthought. How our applications behave during error conditions, and the presentation to the user is critical to software usability.

When we do report errors, and where it is appropriate, give the user the ability to fix the condition. Don't leave them in the dark. Don't force them to do research on where to go for resolution. Provide it to them in an easy to access format.

Be wary of the Drop Down List

jeremy — Wed, 24 Oct 2007 15:09:17 GMT

Within ASP.NET, the DropDownList control is used to prompt a user to select an item from a list of choices. When used properly, it can be an effective tool to retrieve a user's selection. When used improperly by having too many items in the list, they will hinder the user from making a selection, while unnecessarily bloating the page source.

To demonstrate the impact of page size, we'll implement a page that has 2000 items within the list. The rendered portion of the page is shown in the following example. The page is fairly responsive when communicating with the server.

However, when we view the page statistics within Fiddler, we see that the size of the web page is quite large. On further examination, a major contributor to the page size is View State.

It's important to realize when working with controls what the impact to View State will be. In this case, all of the data that is bound to the drop down list is added to view state. If View State is disabled for this control, the size of the page decreases substantially, but we still have a fairly hefty page.

On further examination of the page, there is quite a bit of data written to handle Page Event Validation. A snippet of this code follows.

If we disable Page Event Validation - and I'm not saying to do this - the page size is reduced to a more manageable (but still fairly large) size.

So, by writing essentially pure HTML (and forgoing any ASP.NET features), we have reduced the page to just under 100K. This page size may be fine for some scenarios, but we really haven't addressed the final (and potentially largest) question. How usable is a large drop down list? There seems to be a consensus that a drop down list that exceeds 20-30 items quickly starts to become unusable.

So, with that criteria what is the size of the page with all the features enabled?

The Conclusion? When used properly, and by that I mean a selection of 20-30 items, the Drop Down List is a perfectly constructed control. When abused, your page will start to suffer performance penalties.

The coolest .NET method name is...

jeremy — Mon, 17 Sep 2007 19:30:31 GMT

RegisterExpandoAttribute

According to MSDN documentation, this ClientScriptManager method is used to "Register a name/value pair as a custom (expando) attribute of the specified control". Now, I don't know about you, but my eighth grade teacher would cringe at the above definition. I pretty much knew from the name of the method that this would "Register an Expando Attribute". What I really want to know is: What the heck is an Expando attribute, and why would I ever want to use one?

Why is this important?

There are often times when server-side information about a specific control must be conveyed client-side for consumption within javascript. An example may be that there is a list of Employee names where the first initial and last name are displayed. As each name is selected, an alert is shown that displays the complete name.

What is a custom attribute?

The trick with the above (admittedly contrived) example is that each linked name must be associated with the full name of the employee. This can be easily done by extending the standard HTML anchor tag with a custom (expando) attribute. In our example, the custom attribute fullname will contain the name of the employee.

<a onclick="ShowFullName(this);" id="Employee1" href="#" fullname="James Smith">J. Smith</a><br />
<a onclick="ShowFullName(this);" id="Employee2" href="#" fullname="Brenda Jones">B. Jones</a><br />
<a onclick="ShowFullName(this);" id="Employee3" href="#" fullname="Dana Sparks">D. Sparks</a>

Now that the full name of each employee has been associated with the anchor, javascript can be used to access this information. The ShowFullName function will simply access the custom attribute, and display an alert with the value.

function ShowFullName(button)
{
    alert(button.getAttribute("fullname"));
}

How does this work with ASP.NET?

At this point, we have successfully registered a name/value (fullname/fullnamevalue) pair as an expando (custom) attribute to an HTML control. A couple of issues remain with this approach.

The custom attribute has been added to a simple HTML control. We really need to it to be added to an ASP.NET control.
The rendered HTML contains non-standard attributes that is not XHTML compliant.

Fortunately, the RegisterExpandoAttribute method will take care of both of these issues. To address the first item, we'll rewrite our page to use an ASP.NET LinkButton.

<asp:LinkButton ID="Employee1" runat="server" Text="J. Smith" OnClientClick="ShowFullName(this)" /> <br />
<asp:LinkButton ID="Employee2" runat="server" Text="B. Jones" OnClientClick="ShowFullName(this)" /> <br />
<asp:LinkButton ID="Employee3" runat="server" Text="D. Sparks" OnClientClick="ShowFullName(this)" />

Trying to add the "fullname" attribute to each linkbutton's definition will result in a compile error. To remedy this, the fullname attribute and value will be added in the page's code-behind using the RegisterExpandoAttribute method.

protected void Page_Load(object sender, EventArgs e)
{
    ClientScript.RegisterExpandoAttribute("Employee1", "fullname", "James Smith");
    ClientScript.RegisterExpandoAttribute("Employee2", "fullname", "Brenda Jones");
    ClientScript.RegisterExpandoAttribute("Employee3", "fullname", "Dana Sparks");
}

When the page is displayed in the browser, the selection of each employee displays the alert box just as before. However, there is one crucial difference. In the rendered HTML, the custom attribute is not defined in the anchor tags.

<a onclick="ShowFullName(this);" id="Employee1" href="javascript:__doPostBack('Employee1','')">J. Smith</a> <br />
<a onclick="ShowFullName(this);" id="Employee2" href="javascript:__doPostBack('Employee2','')">B. Jones</a> <br />
<a onclick="ShowFullName(this);" id="Employee3" href="javascript:__doPostBack('Employee3','')">D. Sparks</a>

Rather, the value for the custom attribute is set using javascript that is automatically generated within ASP.NET.

var Employee1 = document.all ? document.all["Employee1"] : document.getElementById("Employee1");
Employee1.fullname = "James Smith";
var Employee2 = document.all ? document.all["Employee2"] : document.getElementById("Employee2");
Employee2.fullname = "Brenda Jones";
var Employee3 = document.all ? document.all["Employee3"] : document.getElementById("Employee3");
Employee3.fullname = "Dana Sparks";

Our page now takes full advantage of using the custom HTML attributes while remaining XHTML compliant.

Summary

When you find yourself in a situation where you need to use javascript on the client to process some server-side information related to a control, custom HTML attributes can be useful to pass the data to the client. To ensure that this information is passed in a standards compliant format, the RegisterExpandoAttribute method should be used.

Undesired SPAN in templated control container

jeremy — Fri, 07 Sep 2007 20:16:27 GMT

When developing a templated web control, the container that the template is instantiated may render a SPAN tag around the templated content.

In the following control, the Render method for the LayoutTemplate container has not been overridden.

<cc:DataLayoutControl runat="server" ID="DataLayoutControl1">
    <LayoutTemplate>
        ...This is the test...
    </LayoutTemplate>
</cc:DataLayoutControl>

This produces the following HTML

<div>
  <span>
  ...This is the test...
  </span>
<div>

Notice the SPAN tag (which seemingly came from nowhere) surrounding the templated text. This is due to default behavior of the WebControl TagKey property and the RenderBeginTag method.

TagKey

Paraphrasing from MSDN: "TagKey is used as the HTML tag that corresponds to the custom control." Typically in a custom control, this property is overridden and the specific HTML tag is provided. For example:

protected override HtmlTextWriterTag TagKey
{
    get
    {
        return HtmlTextWriterTag.P;
    }
}

When this property is not specifically set, a SPAN is used as the default when the WebControl instance is created using the parameter-less constructor.

RenderBeginTag

In some cases, it may not be desirable to have a tag surrounding the HTML rendered by the template container control. Since TagKey is a enumeration of HtmlTextWriterTag, there is really no built-in mechanism to avoid rendering the surrounding tags. When TagKey is set to HtmlTextWriterTag.Unknown, the default SPAN will be used. This is proven by examining the source for the .NET framework (thanks go to the fantastic Reflector tool). The following example shows the WebControl.RenderBeginTag method.

public virtual void RenderBeginTag(HtmlTextWriter writer)
{
    this.AddAttributesToRender(writer);
    HtmlTextWriterTag tagKey = this.TagKey;
    if (tagKey != HtmlTextWriterTag.Unknown)
    {
        writer.RenderBeginTag(tagKey);
    }
    else
    {
        writer.RenderBeginTag(this.TagName);
    }
}

Solution

To prevent the surrounding tag, the templated container control must override RenderBeginTag and RenderEndTag without any implementation for either of the methods.

public override void RenderBeginTag(HtmlTextWriter writer)
{
}

public override void RenderEndTag(HtmlTextWriter writer)
{
}

Draw border on selected row in a GridView

jeremy — Tue, 04 Sep 2007 20:31:04 GMT

When a GridView is rendered, an HTML table is created. Each row of the table contains information describing an instance of the data source. As each row is selected, we want to display a single pixel border around the selected row.

There is a property of the GridView: SelectedRowStyle that will be used to apply a specific style to the selected row. The CssClass property will be used to style the rendered TR element for the selected row.

It is important to know that the style will only be applied to the TR element representing the selected row. To correctly have a border around the row, we need to apply styles to the individual cells within the row. Since these cells are children of the row, it will be trivial to style them using CSS.

Knowing this, let's create a sample table that will be used to simulate how the GridView will be rendered in the browser. The following example contains a table with three rows and three columns per row. The second row will be the selected row.

HTML

<table class="exampletable" unselectable="on">
<tbody>
<tr>
   <td class="exampletableleft">Row 1 Col 1</td>
   <td>Row 1 Col 2</td>
   <td class="exampletableright">Row 1 Col 3</td>
</tr>
<tr class="selectedrow">
   <td class="exampletableleft">Row 2 Col 1</td>
   <td>Row 2 Col 2</td>
   <td class="exampletableright">Row 2 Col 3</td>
</tr>
<tr>
   <td class="exampletableleft">Row 3 Col 1</td>
   <td>Row 3 Col 2</td>
   <td class="exampletableright">Row 3 Col 3</td>
</tr>
</tbody>
</table>

CSS

.exampletable { border-collapse: collapse; }
.selectedrow td { border-top: solid 1px #5d9ccf; border-bottom: solid 1px #5d9ccf; }
.selectedrow td.exampletableleft { border-left: solid 1px #5d9ccf; }
.selectedrow td.exampletableright { border-right: solid 1px #5d9ccf; }

For the selected row, the TR element contains the class "selectedrow". Each child TD element within this row will have the border-top and border-bottom styles.

The leftmost and rightmost cells are marked with the "exampletableleft" and "exampletableright" classes which will translate to the appropriate border-left and border-right style. Because of the .selectedrow limitation within the style definition, these styles will only be applied when these TD elements fall within the selected TR.

Notice that "class" attributes are used rather than the "id" attribute. This has been done on purpose to closely match the HTML that would be rendered from a GridView. It is very simple to set the CSS class of rendered elements, but it is really not feasible to try to set the "id" of the rendered elements.

Rendered Table

Row 1 Col 1	Row 1 Col 2	Row 1 Col 3
Row 2 Col 1	Row 2 Col 2	Row 2 Col 3
Row 3 Col 1	Row 3 Col 2	Row 3 Col 3

Implementation

To accomplish this for a GridView:

Set CssClass for the GridView as "exampletable"
Set the SelectedRowStyle CssClass property as "selectedrow"
Set the ItemStyle-CssClass property on the leftmost and rightmost columns as "exampletableleft" and "exampletableright"

Create Games in Silverlight

jeremy — Thu, 30 Aug 2007 18:54:34 GMT

Bill Reiss is authoring a series of articles that provide instructions on how to build a game in Silverlight 1.1.

http://silverlightrocks.com/community/blogs/silverlight_games_101/default.aspx

Textbox size attribute

jeremy — Thu, 23 Aug 2007 13:30:07 GMT

To set the size attribute for an input field (textbox) in ASP.NET, set the Columns property of the TextBox.

Note that this will only show when the TextMode property is set to SingleLine. When this property is set to MultiLine, the Columns property will render as cols and the Rows property will render as rows.

This is a test post

jeremy — Fri, 22 Jun 2007 13:14:46 GMT

This is a test post to the Technology blog

AR Development Center

Daily Recap: 5/3/2012

Transition away from “Windows Live” has been mapped

Changes coming for Inside Xbox

Microsoft Research opens a NYC Lab

Ubisoft Toronto is growing

Daily Recap: 5/2/2012

Microsoft planning a subscription based Xbox 360

Papa’s got a brand new Bing

Windows 8 Tiles, Toasts and Badges tutorial

Daily Recap: 5/1/2012

Hulu may start requiring cable subscription

Great overview of RAW v JPEG

Supermoon of 2012 is coming

If you release an app in the woods will anybody hear it?

Daily Recap: 4/30/2012

LG is backing out of Windows Phone Development

Microsoft + Nook = Newco

Halo 4 Live Action Miniseries

Daily Recap: 4/25/2012

Windows Security Essentials 4.0 is available for Download

Microsoft SkyDrive now has published data plans

NASA Time Lapse from ISS Video is a MUST SEE

Microsoft to preview new music service at E3

Programmatically Create Discussion Thread

Setup the Project

Writing the Code

Testing it out

Review

Assigning a different drive letter

New Stock Photos

Installing Skype on Windows 8

BUILD News

Contests

Rumors

Twitter

How BUILD may change the world

Free Hand Drawn Icons

Announcement: GamerCentral partner site

Resolving SCRIPT references in the HEAD

SharePoint 2010 Developer Resources

Single Click DataGrid Checkbox in Silverlight

Are you using Extension Methods

Short, URL Friendly GUID

Refactored with Extension Methods

Conclusion

Silverlight 4 Themes

ASP.NET Web Site Administration Tool

Create User

Create Role

Catching Unhandled Exception in WPF Application

Form Engine Announced

Creating a Flyout Panel in Silverlight

Silverlight Web Services fail when VS Crashes

How to remove the border in Silverlight DataGrid

Rock Band customer service Rocks

Adding validation to a custom Control

Implement IValidator in your Control

Register the Control as a Validator

Conclusion

MSN's hating on ethanol today

ITemplate - Referencing Nested Controls

Complex Object data binding

Use Casting

Use a Method

Horizontal Menu with CSS

Sorting using IComparer(T)

Check in Policies and Trust

It's about Standardization

Is it about Trust?

Summary

Convert a .NET Color to a Hex value

Casting and State Variables

Casting using the "as" keyword

Casting using the "C" style

Casting with State variables

Printer Troubleshooting

Close those SCRIPT tags

Specifying a new DEFAULT in Access SQL

Dynamically adding links to Header