Wintellog

Debugger Canvas 1.1 is Released

jrobbins — Tue, 31 Jan 2012 20:48:19 GMT

There’s a lot of UI research going on focused around better debugging. Debugger Canvas is some that you can use today and the version 1.1 was just released. The speed increased in 1.1 are great and make Debugger Canvas much more usable. I’m in love with the toggle button where you can flip between Debugger Canvas and regular text file display. While I have a few feature requests that I’d love to see, using 1.1 made me wish for some more. My feedback’s been given to the Debugger Canvas team but I thought it might spark some discussion by mentioning my additional wishes to everyone:

When using Debugger Canvas on a multithreaded application, I’d love to see the thread ID and/or name in the display when it’s an active call stack. It’s a little to easy to get lost in a multithreaded canvas.
It would be nice to have a timestamp on a bubble. When one canvas is getting reused you can see at a glance which is the most recent chain.
It would be nice to have a way to remove a whole chain at once.

Please do let the team know your feedback at the DevLabs Debugger Canvas forum.

MVVM on MVC: HTML is not XAML

C#er : IMage — Wed, 25 Jan 2012 09:44:01 GMT

I have to admit that I may have rolled my eyes a bit when I first learned about the KnockoutJS library. It sounded too much like forcing a square peg into a round hole. Isn’t Model-View-Controller (MVC) already it’s own pattern ? Does it make sense to apply something like Model-View-ViewModel ( MVVM ) to HTML? I already had enough issues dealing with MVVM on the platform it was designed for, XAML and C# (WPF and Silverlight). Some people simply didn’t get the pattern, others were pushing it without...(read more)

We Are Hiring!

JeffreyR — Tue, 24 Jan 2012 13:59:40 GMT

Business is good and we need YOU! Wintellect is currently seeking senior level technical development resources for both contract and permanent employment for our current client projects. If you want the challenge of keeping up with co-workers like Jeffrey Richter, Jeff Prosise, Keith Rome, or Jeremy Likness, have we got the opportunity of a lifetime. Please have lots of hands on development experience in the following technologies: C#, ASP.NET MVC, WPF, WCF, Silverlight and SQL Server. Experience with HTML5 and jQuery would be ideal also. If you can't tell, it's all cutting edge here at Wintellect so if you like doing the latest technology we'd love to talk with you. Please forward your resume and availability to Barbara Keihm, Director of Human Resources,bkeihm@wintellect.com.

Wintellect is Hiring!!

jrobbins — Tue, 24 Jan 2012 06:33:18 GMT

Video: Getting Started with Jounce MVVM and MEF for Silverlight 5

C#er : IMage — Sun, 22 Jan 2012 11:52:03 GMT

I created a quick video to help you get started with using Jounce. The video starts with a blank slate, steps through installation of Jounce and the creation of a sample view model for a simple contact record that includes validation. You can access the video directly at http://vimeo.com/jeremylikness/jounce-getting-started , or view it below: Jounce: Getting Started from Jeremy Likness on Vimeo . (c) 2011-2012 Jeremy Likness....(read more)

Jounce 2.0 MVVM with MEF for Silverlight 5 Released

C#er : IMage — Sat, 21 Jan 2012 15:47:01 GMT

I'm pleased to announce the official release of Jounce 2.0 for Silverlight 5. There are quite a number of new features available that I'll review in this post. Most significantly, of course, the code base has been updated specifically to target Silverlight 5. A number of bug fixes, feature requests, and Silverlight 5 features have been added. The DLL for Jounce is still just under 100 KB for release so it remains nimble and lightweight. There are two ways you can install the latest. Zip over to Jounce...(read more)

Paraffin 3.6–Now Keeping Custom Added Namespaces

jrobbins — Thu, 19 Jan 2012 23:44:35 GMT

Paraffin 3.6 can be downloaded here: http://www.wintellect.com/CS/files/folders/18310/download.aspx

Dan Gough had an excellent feature request to have Paraffin copy over any manually added namespaces to the .WXS file like the following. Previously, Paraffin ignored them, but no more.

 <?xml version="1.0" encoding="utf-8"?>
<Wix xmlns:util="http://schemas.microsoft.com/wix/UtilExtension"
     xmlns="http://schemas.microsoft.com/wix/2006/wi">
 

I updated Paraffin to copy over any namespaces added to the Wix element when creating the .PARAFFIN file. If you were having Paraffin inject additional elements with a .ParaffinMold file, now it’s easier than ever to keep your WiX fragments up to date.

When adding custom namespaces, put them before the default xmlns="http://schemas.microsoft.com/wix/2006/wi" as I’ve shown in the snippet above. With LINQ to XML, the xmlns attribute is special and does not show up in the Attributes collection so there’s no way I can sort it with the rest of the values. When generating the output XML file, XDocument always puts the xmlns attribute last. I tried all sorts of tricks to get it placed first but never got them to work.

There’s no trouble if you place your custom namespaces after the default xmlns, but in the .PARAFFIN file they will always appear first so you’ll see more changes when you diff the .WXS and .PARAFFIN file.

Please do let me know if you have feature requests! I considered adding a command line switch to allow adding custom namespaces when creating a .WXS fragment but didn’t think that would be used very much so decided against it. Of course, now that I’ve mentioned this option everyone’s going to ask for it. <grin!>

If you’re not familiar with Paraffin, please read the Zen of Paraffin document in the root directory of the download.

Visual Studio 2010 Extensions Recommendations

jrobbins — Mon, 16 Jan 2012 18:31:15 GMT

The other day I was asked which extensions for Visual Studio I use so in an effort to save keystrokes, I thought I’d list them here so I can refer people to this list. There’s no way this is a comprehensive list and I do add and remove extensions all the time. However, these are the ones that always stay installed because if they aren’t, I can’t use Visual Studio. By the way, these are all free.

Productivity Power Tools

Want a bunch of features for the next version of Visual Studio today? That’s exactly what Microsoft’s Productivity Power Tools are all about. Once you use the awesome Solution Navigator, you’ll wonder how you ever lived without it. Add in the better Tab Well UI, Quick Find, and all the other enhancements and you’re in Visual Studio heaven. This is the single most important extension available.

NuGet Package Manager

The first time you add an open source package to your solution, you’ll thank your lucky stars for this extension. It’s quick and easy so you can focus on what you need to do instead of the integration. What I find even better than the package manager is that NuGet adds a PowerShell window to Visual Studio. I’m using that constantly these days because the $dte variable exposes the Visual Studio automation model to PowerShell.

VS Color Output

This fine extension adds color-coding to output windows in Visual Studio. Seeing build breaks in red and good builds in green, as well as control over all other output, is something that should have been built into Visual Studio already. The latest version 1.1 update fixes a crashing issue people were reporting.

HTML Spell Checker

I can’t spell at all and this extension keeps me from looking like moron as others look at the comments in my code.

Highlight All Occurrences of a Selected Word

A super simple extension that does exactly what the title says. It’s wonderful when doing presentations to highlight a word and for looking at all uses of a global variable. Note that this extension offers no customizability so you’re stuck with the lime green highlight that does not work so well with you wild kids using dark background themes.

So what extensions can you not live without? I’d love to know what extensions you use so either blog about them or add them to the comments.

Setting the Power Plan with PowerShell

jrobbins — Sun, 15 Jan 2012 07:54:00 GMT

Edit: Make sure to read the comments from Shay Levy and Richard on clarifying my mistaken assumptions about how things work in PowerShell. Thanks to Richard & Shay for the clarifications!

As I’m a command line kind of guy, I look for every opportunity to stay in a PowerShell window at all times. “Why grab the mouse when you don’t have?” to is my motto! The other day I was working on my laptop and was running short of battery power so wanted to switch to the Power Saver plan. A quick search told me POWERCFG.EXE was the command line tool to use.

Hold on there Flash! POWERCFG.EXE with the –S option is the command line way to change power plans, but to specify the plan you must use the GUID of the plan. While I’m a big fan of GUIDs there’s several places where GUIDs are not appropriate: command line tools, URLs, and any other place where end users could see them. Shouldn’t you just be able to set the power plan by name like “Balanced, ” “Power Saver,” or if you are feeling randy, “High Performance?” That’s an oversight that needs to be fixed so below is a PowerShell script, Set-PowerPlan.ps1, that lets you set the power plan at the command line based on the name of the plan instead of an ugly GUID.

The basic idea of the script is to get the list of defined power plans from “POWERCFG.EXE –l” and parse the output with a regular expression looking for the plan name with matching GUID. With the GUID in hand calling “POWERCFG –s <GUID>” flips to the defined plan. The regular expression work was simple, but there was one thing that stumped me.

In all the PowerShell work I’ve done I’ve never needed to capture the output of an old-school command line program like POWERCFG.EXE. It seemed so simple to do something like “$plans = POWERCFG –l” to get the list of plans and parse the output with “$plans –match <some regex>” to pull out the GUID. Little did I know that would definitely not be anything approaching normal. Yet again a PowerShell-ism reached up and dope slap me hard.

Interactively in a PowerShell console window, I ran “$plans = POWERCFG –l” and double-checked that $plans was a string by executing “$plans | Get-Member” as piping to Get-Member will report the type of object. Sure enough I was looking at a System.String. Oddly, when I ran “$plans –match <regex>” it always returned false even though typing “$plans” definitely showed me the complete output of the “POWERCFG –l” and the exact string I was looking for was there.

What totally confused me was running “$plans.Length” as that reported “7” instead of the 364 characters I counted in the string. After a bunch of reading I finally realized that $plans is really a freaking ARRAY of seven lines instead of a complete string. When PowerShell captures the output of a regular command line program as an array of strings. Whenever one is first exposed to PowerShell you invariably are taught about the Get-Member command right at the beginning to figure out the type of an object. When Get-Member lies to you it’s hard to get a clue. It’s things like this that make you understand why so few developers have switched over to PowerShell.

If you want all the output of a regular command line program into an actual string you have two choices. The first is to explicitly type the receiving variable with [string] like the following: “[string]$plans = powercfg -l” The alternative is to gather the regular command output into a variable, but if you need to look across all that output pipe the variable array to Out-String surrounded by parenthesis as in “($plans | Out-String)”.

I’m sure some PowerShell Ninja will jump in here and tell me how I missed the obvious, but I don’t feel I did. Hopefully, this little PowerShell gotcha will help you go down the PowerShell route with more confidence. While PowerShell has some bumps along the way the journey is totally worth it!

Set-PowerPlan.PS1
 #requires -version 2.0
 
# (c) 2012 by John Robbins\Wintellect
 
<#.SYNOPSIS
Sets the current power plan.
.DESCRIPTION
The POWERCFG.EXE utility requires GUIDS when changing a power plan instead of
the name of the plan. That's highly inconvenient so this simple script allows 
you to use common sense names like "Balanced" or "Power Saver" instead.
 
To get the list of power plans on your computer execute 'powercfg -l'
.PARAMETER Plan
The name of the power plan to use.
.EXAMPLE 
Set-PowerPlan -Plan Balanced
Sets the power plan to the Balanced plan, the recommnded Microsoft plan.
.EXAMPLE 
Set-PowerPlan "Power Saver"
Sets the power plan to the Power Saver plan to reduce battery usage.
.LINK
http://www.wintellect.com/CS/blogs/jrobbins/archive/tags/PowerShell/default.aspx
#>
 
param ($Plan = $(throw 'You must specify the power plan, use "powercfg -l" for the plan names' ))
 
Set-StrictMode -Version Latest
 
# Get the list of plans on the current machine.
$planList = powercfg.exe -l
 
# The regular expression to pull out the GUID for the specified plan.
$planRegEx = "(?<PlanGUID>[A-Fa-f0-9]{8}-(?:[A-Fa-f0-9]{4}\-){3}[A-Fa-f0-9]{12})" + ("(?:\s+\({0}\))" -f $Plan)
 
# If the plan appears in the list...
if ( ($planList | Out-String) -match $planRegEx )
{
    # Pull out the matching GUID and capture both stdout and stderr.
    $result = powercfg -s $matches["PlanGUID"] 2>&1
    
    # If there were any problems, show the error.
    if ( $LASTEXITCODE -ne 0)
    {
        $result
    }
}
else
{
    Write-Error ("The requested power scheme '{0}' does not exist on this machine" -f $Plan) 
}
 

CRUD it’s now CQRS … or is it?

C#er : IMage — Sat, 07 Jan 2012 15:34:01 GMT

In 1983 author James Martin published a book called Managing the Data-Base Environment . It’s interesting the term database is hyphenated in the title; it hadn’t quite settled down as a mainstream term yet. I have not read this book myself, but my understanding is that he presented the concept of the “CRUD Matrix” for engineering how an application performs Create, Read, Update, and Delete operations against the database. Regardless of how the term was first coined, it has gained popularity and is...(read more)

Want Source Server to Work with Managed Minidumps in Visual Studio? Here’s How!

jrobbins — Fri, 06 Jan 2012 18:29:23 GMT

So you have an awesome minidump your IT guys grabbed with ProcDump. You’ve followed all the rules and have a Symbol Server and Source Server all set up. You open that dump with Visual Studio and BOOM, none of your indexed sources show up. You pull your hair out trying to get your public build sources appear but they never do and it’s just “SRCSRV: The module ‘<<path to the exe file>>’ does not contain source server information.” for everything in the Output window.

Fortunately, a smiling bald guy, Andy Hopper, figured out how to make it all work. Turns out when opening a minidump, the “managed debugging engine tries to verify that each source server enabled assembly is running as a fully trusted assembly from the CLR’s perspective.” Ahh, nothing like security to turn off a feature. The great news is that you can tell the managed debugging engine to stop doing the checks so the Source Server works with the managed minidumps. It’s as simple as setting a registry key. Swipe the registry script below and you are good to go.

All credit to Andy Hopper on this one!

 Windows Registry Editor Version 5.00
 
; Enables Source Server support when opening up managed minidumps in Visual Studio.
; All credit to Andy Hopper!
; http://smilingbaldguy.wordpress.com/2012/01/06/managed-minidump-debugging-now-with-source-server-support/
; If you're on a 32-bit machine (and why would you be?) remove Wow6432Node.
;
 
[HKEY_LOCAL_MACHINE\SOFTWARE\Wow6432Node\Microsoft\VisualStudio\10.0\AD7Metrics\Engine\{00000000-0000-0000-0000-000000000000}]
"RequireFullTrustForSourceServer"=dword:00000000
 

Things I Am Enjoying (December, 2011)

jrobbins — Thu, 29 Dec 2011 19:51:41 GMT

In the development world, there’s a lot of things that bump, distract, and annoy you through the day. Those get a lot of attention in blogs to help others work around those issues and to document the pain. What does not get a lot of attention are those things that work well and make your life better. In this blog post I want to shout the kudos for a few things I’ve been enjoying immensely in the last month. My list will not be anything as good as Scott Hanselman's 2011 Ultimate Developer and Power Users Tool List for Windows, but I’m sure loving what I mention below!

1Password from Agile Bits

With the news the last few years talking about security breaches and research showing everyone is using the same password everywhere if you’re not using a password manager you are plain crazy. I’ve been using 1Password for a while now and it’s so well integrated in all browsers across Windows, OS X, and phones, I basically forgot I was using it. When setting up a new machine recently I was perplexed for a minute as to why I couldn’t log into various web sites and where was the password button in the web browser? 1Password does its job so well I can’t help but recommend it because I forget I’m running it.

Speaking of passwords and security, all developers need to read the wonderful research paper “So Long, And No Thanks for the Externalities: The Rational Rejection of Security Advice by Users” by Cormac Herley of Microsoft Research. It discusses why normal people always use the same password and weak ones at that.

SlySoft Virtual Clone Drive

Windows 8 will finally have native ISO mounting support built in to the OS. It’s about time. However, with Windows 8 not releasing for quite a while you need something today to mount those ISO files. Virtual Clone Drive has been around for years and works on all Windows OS. I don’t have any software on a DVD any more because either downloaded it or converted it to ISO files. When using Virtual Clone Drive, select the Virtual Sheep option so your fake DVD drive shows up with the awesome angry sheep icon. The price is awesome for Virtual Clone Drive: free.

Other World Computing Data Doubler

As it was time for a laptop upgrade, I kept with my love of Apple hardware and bought a 15-inch MacBook Pro. As I’ve said many times to people: “Apple: The best Windows machines money can buy!”™® Because I don’t use DVDs any more the Apple drive is just taking up space in the machine. Fortunately, the fine folks at Other World Computing (OWC) have a great solution in Data Doubler that replaces your DVD with another hard disk. For $65 USD I slapped in the SSD I took out of my no longer needed desktop machine and instantly had another 240GB of sweet SSD speedy sexiness for my virtual machines.

The prospect of cracking open a unibody MacBook sounded daunting and I thought I might kill the magic hipster fairies that live inside of all Apple products. The good news is that OWC include all the tools you need to do the conversion and have fantastically detailed videos on all the exact steps for your particular machine. What I especially liked is that the Data Doubler came with replacement Phillips head screws to replace the hard to work with Torx head screws Apple uses in manufacturing. Now if I want to throw in a much bigger disk in the future, it will be that much easier to do it. That’s attention to detail!

VSColorOutput Extension by Blue Onion Software

Wading through the build output with a large project in Visual Studio is tedious. If only there were a way to use colors to have good lines in green, errors in red, and everything else in a gray it would be much easier to see what’s going on. Fortunately, Mike Ward over at Blue Onion Software did exactly that with VSColorOutput extension and it’s on my can’t live without list. Even better is that the code is open source on CodePlex so if you have never written a Visual Studio extension, it’s a great example.

Since I’m talking about Blue Onion, make sure to subscribe to Mike’s blog. His Friday Links posts always have something in them that I didn’t know about or find really interesting. My personal favorite category is the “Stuff I Just Like” links.

Microsoft IT VPN

It’s no surprise to you but there are a lot of problems with most VPN software. We have to use many different VPN solutions with all our clients and most of them range from painful to an all out death assault on your machine. You know, small issues like you can either VPN or hit the whole Internet but not both, each requires different anti virus software some of which are not up to date, and so on. Sadly, unless you are a Microsoft Employee or approved vendor you won’t get to see VPN software done outstandingly well. Microsoft IT has this awesome solution that uses smart cards in your badges before you connect, decent connection speed, killer security when you are connected, and never interferes with anything on your machine.

I really wish Microsoft would do some white papers on their IT VPN setup because it so much better than any other I’ve seen. Hopefully mentioning the internal VPN solution has won’t kill my NDA with Microsoft. I’m sure like any internal IT group, Microsoft IT only gets noticed when something isn’t working, but I just love their VPN solution and wanted to give them a solid shout out.

TFS Preview from Microsoft

Since TFS 2005 I’ve been running my own domain so I can use TFS and get experience with all of its facets. It was all a bit of overkill, because all I really need for my personal work is TFS Basics, but that wasn’t offered back in the day. TFS is an amazing product and it offers many bells and whistles that provide all the reporting and legal requirements that up to the largest organization requires. However, one thing I’ve noticed is that many teams use the same parts of TFS such as product backlog, bug tracking, version control, and build management, but never touch other pieces such as the SharePoint integration.

The TFS team has certainly noticed the same phenomenon and also saw an opportunity to provide hosted TFS. While TFS Preview isn’t formally in a beta with Dev 11 yet, I feel it’s the true killer release of TFS. For many teams it will hit the 90% sweet spot of their TFS usage, most likely provide a Service Level Agreement for uptime better than many internal IT organizations can offer, and be cheaper in the long run.

This last month I set up a full project with one-week sprints to work through using TFS Preview using the Scrum 2.0 template and I’m far more than impressed, I want to start throwing gobs of money at Microsoft right now! I couldn’t believe how polished the whole web experience has become and the Scrum board is my favorite Web 2.0 page ever. Other than companies with specific legal requirements for running your own TFS server, I can’t see why anyone would ever need to run their own TFS server. I wonder if there’s a business opportunity to offer automated migration of work items and check ins between your old server and the spiffy TFS Preview?

Parallels Desktop for Mac from Parallels

After Apple introduced Boot Camp that lets you boot the Macs into Windows, I was in all sorts of love because it is great hardware combined with zero crapware on Windows. I was more than happy to reboot between OS X and Windows whenever I needed to use one or the other. When Parallels first announced support for utilizing your Boot Camp a while ago (version 2.5), I gave it a try but quickly gave up because Windows and Office activations triggered whenever I switched between Boot Camp and Parallels. While I could have created a separate dedicated virtual machine, I didn’t want to waste the disk space for a second copy of Windows nor go through the installation hell of setting up a development machine twice and then trying to keep everything in sync between them.

When I bought my new Mac Book Pro, I figured I’d give Parallels another shot because being able to utilize Windows no matter if I was running OS X or Boot Camp seems very enticing. With version 7 the Parallels team completely and totally nailed it! I installed Windows in Boot Camp and activated it. Switching back to OS X, I installed Parallels, fired up the Boot Camp partition in a VM activated Windows again and that was it. I can use Windows (and Microsoft Office) either way and everything just works perfectly.

Parallels made it very easy to use the Windows VM full screen so that’s how I rolled for my initial usage. I’d read about the Coherence mode that allows all Windows applications to appear like normal OS X windows, but didn’t think it would be very useful. Let’s just say I was incredibly wrong. I love how smooth and seamless having all your windows from both operating systems running side by side. My wife came into my office and looking at the monitor could not figure out which OS I was running which I thought was pretty funny.

I just had a brilliant thought! With Windows 8 supporting Hyper-V on the desktop, if Microsoft would support your Apple OS X partition in Hyper-V you’d have the best of all possible worlds! Microsoft could call the feature Camp Boot just to make it even cooler. Being able to run OS X applications when you need them from Windows 8… Oh, please don’t make me wake up from this dream. <Grin!/>

Holiday Leftover Turkey Sandwiches

My wife is an amazing cook. If you ever meet me in person you will be able to tell that from my girth. Over the holidays she wanted to make a roast turkey so I certainly did not stand in the way because I love the big bird. While the turkey dinner is great, the leftovers are even better. Here’s the ultimate recipe for the food of the gods.

Two slices of very fresh squishy white bread
Spread Hellman’s mayonnaise on both internal sides of the bread (this is the secret!)
Fill the bottom bread with a layer of turkey about a quarter inch thick
Take a salt grinder filled with sea salt and lightly salt the layer of turkey
Place a single layer of freshly chilled lettuce on the turkey before putting the top slice of bread on the sandwich
Carefully mash the sandwich down until the bread conforms around the turkey
DO NOT CUT THE SANDWICH IN HALF
Pick up with both hands and enjoy!

So what have you find readers been enjoying over the last month?

Windows 8 Slate Review

C#er : IMage — Wed, 28 Dec 2011 11:36:04 GMT

About a week ago, I purchased a Samsung Series 7 Slate PC to learn more about the Windows 8 operating system and to test applications I will be developing primarily with C# and Xaml. The laptop ships with Windows 7 installed, but I quickly wiped the existing install and overlaid it with Windows 8. The process for the most part went smoothly. I had to acquire some Windows 7 drivers and install them in compatibility mode in order for the tablet to recognize orientation changes, and I still cannot get...(read more)

NuGet Nugget: File-System Based Package Stores

jgarland — Sat, 17 Dec 2011 02:53:00 GMT

A recent network “hiccup” posed a bit of a challenge to a demo that was built around showing how the Windows Azure Toolkit for Windows Phone (WATWP) NuGet packages make it easy to add Windows Azure cloud features to a Windows Phone 7 application. So how do you access NuGet content when a network connection isn’t available? What if you want to exert some management over the updates that are exposed to the developers in your enterprise, including exposing often-used or internal-use assets?

It turns out that NuGet offers some functionality that addresses these scenarios. In addition to supporting the ability to set up your own package server (also known as Creating Remote Feeds in the NuGet documentation), there is the ability to consume packages collected in a directory – either a network share or a local file-system folder. This is illustrated in the NuGet documentation under the subtopic "Creating Local Feeds” within the “Hosting Your Own NuGet Feeds” topic.

Populating a File-System Based Package Store

Any folder that contains NuGet .nupkg files can be set to be as a file-system based package server. From my own use, folders that contain subfolders with .nupkg files will also work, allowing for organization and hierarchy. If you already have a Visual Studio solution that has references to NuGet packages, moving these packages into such a local package store can be quite simple (especially for demos!) Just locate the “packages” folder that is created when the NuGet packages are added

The entire package folder is not required, since the nupkg files are really Zip files that contain all of the necessary contents. Search for files that end with the .nupkg extension.

Simply copy all of these files into the folder you are using for your file-system based package store. Note that a wider set of packages is available in your local package cache, which is normally maintained in <UserFolder>\AppData\Local\NuGet\Cache, and can be accessed from Visual Studio via Tools-Library Package Manager-Package Manager Settings, and click the “Browse” button in the General section of the Package Manager settings node.

Using File-Based Package Stores

To tell Visual Studio to consume file-based package stores, bring up the settings dialog (via Tools-Library Package Manager-Package Manager Settings or through the other accessors in Visual Studio) and select the Package Sources section of the Package Manager settings node. Provide a name and type in the path or browse to the package location and click the Add button. Note that the elements in the Available Package Sources list are shown in a check-list-box – they can be enabled or disabled. Elements in the list can also be reordered in order to determine the precedence in which the sources are searched for matching packages.

When adding NuGet package references to your project in Visual Studio via the Manage NuGet Packages dialog, note that the newly named source now appears within the “Online” package listing section.

The new source is also available as a pulldown option in the Package Manager Console window.

As I’ve been digging into NuGet more lately, I’ve been quite impressed by the functionality it exposes. There’s much more to it than just a right-click menu item and a dialog box that adds and updates project assembly references. Some of my current favorites include managing package references at the solution level and visualizing NuGet package chains. Be sure to check out the NuGet docs in case you have yet to discover your favorite.

DevBoston (Waltham) Presentation Content

jgarland — Thu, 15 Dec 2011 02:44:00 GMT

Many thanks to the attendees of my presentation tonight covering Developing Cloud Enabled Windows Phone Applications with Windows Azure. I apologize once again for the technical network-related gremlins that decided to attack us tonight…hopefully the workaround covered the necessary ground and everyone was able to see the concepts I was trying to show.

As promised, I have posted the content for the presentation here. This includes the slide deck with the various resource links, as well as the final project. As I mentioned, I have “sanitized” the configuration of the project to omit my specific Access Control (ACS) settings. This involved changing the AccessControlResources.xaml file in the phone project and the Web.config file in the web role project. Look for the text [your-xxx-here] for where to substitute your own ACS information.

Because the network issues prevented us from accessing the NuGet site or repository, I wanted to be sure to list the packages that were used in these projects:

Phone.Storage	Adds support in the phone project to access Azure Storage.
WindowsAzure.Storage.Proxy.AccessControl	Adds support in the server-side MVC3 based web role to field secured storage requests using ACS to generate the authentication token
Phone.Storage.AccessControl	Adds support in the phone project for interacting with ACS-secured storage, including a login page with the ACS-aware login control.
WindowsAzure.Notifications	Adds support in the server-side MVC3 based web role to handle registration & storage for Push Notification endpoints
Phone.Notifications.BasePage	Adds support in the phone project (including a UI page) for enabling notifications in the application and registering with server-side push notification endpoint.
MPNSRecipe	Adds the MPNS Recipe, used in the worker role project.

Silverlight 5 Released: Myth vs. Fact

C#er : IMage — Fri, 09 Dec 2011 12:12:02 GMT

It is very exciting to see the release of Silverlight 5 today, despite all of the rumors flying around the Web. Read the original release announcement from the Silverlight Team here . This is proof positive the team made a commitment to release a new version by the end of the year and stuck to it. This release offers major functionality over prior releases and is something I believe has the potential to revolutionize development for line of business applications, or I wouldn't be writing a book about...(read more)

My .NET Nuggets Keynote Talk From Houston Tech Fest October 15th, 2011

JeffreyR — Sun, 04 Dec 2011 23:41:54 GMT

http://usergroup.tv/videos/net-nuggets---houston-tech-fest-keynote

Handling Extremely Large Data Sets in Silverlight

C#er : IMage — Sun, 20 Nov 2011 09:00:01 GMT

While writing Chapter 14 of my book, Designing Silverlight Business Applications: Best Practices for Using Silverlight Effectively in the Enterprise (Microsoft .NET Development Series) I focused on an area that is quite common with line of business applications: extremely large data sets. In the example I generated almost 1,000,000 contact rows to illustrate how they would be managed by the Silverlight client. Like many software problems, there are many solutions; here is an excerpt of the three...(read more)

Boston .Net Code Camp Presentation Content

jgarland — Sun, 06 Nov 2011 03:41:17 GMT

I would like to thank the organizers and attendees of the recent 16th (wow!) Boston Code Camp where I did a talk on Developing Cloud-Enabled Windows Phone Applications with Windows Azure – and special thanks to everyone who stuck it out once the snow started falling in order to catch my talk. Obviously, it took longer than expected to get this content posted – Nashua got hit especially hard by the storm, including a 75% city-wide power outage the day following the Code Camp event, along with accompanying telecom and even cellular outages. I am happy to say that I finally got my power turned back on mid-week, and am slowly but surely digging out of the mountain of backlog that piled up during the multi-day outage.

The content can be found here. Because I demoed ACS, some of the items that are placed in the project would normally reference my “real” Azure account…they have been removed and replaced with the phrase “YOUR CONTENT HERE.” You will need to replace these values with your own from the Azure ACS management portal in order to be able to run the provided code. Also, in order to use the Azure Emulator, be sure to run Visual Studio in Admin mode when working with this project.

Is That a WeakReference In Your Gen 2 or Are You Just Glad to See Me?

jrobbins — Sat, 29 Oct 2011 05:39:58 GMT

Sometimes it’s easy to see why your .NET server application is using so much memory, but other times it makes no sense at all. I was at Microsoft earlier this week and someone who’d taken my debugging class stopped me and asked an excellent question. The scenario they had was their service memory would just grow at a steady rate without ever going down. The team found a fix for the memory leak through savvy internet searching but found it frustrating they could not see the answer through SOS and SOSEX. The person gave me the dumps as they wanted to know how they could have found the issue quicker. The research was pretty interesting so I thought I’d share the results.

The first command you always run after loading SOS is !dumpheap –stat so you can get a picture of the overall memory usage. On the dumps the team gave me, the result showed something very similar to the following at the end of the output:

 0000000000386ce0        9         7328      Free
000007fee1d26ac8      464        18720 System.String
000007fee1d2afd0       34       183560 System.Object[]
000007fee1d478a0    11098       355136 System.WeakReference
 

In the real mini dump those WeakReferences were taking up over 270MB! The weak can kill you in the .NET world.

Whenever I see a WeakReference, you’re looking at some form of cache because it’s a special class that you use to reference an object, but allow that object to be garbage collected. So we know someone’s caching something, but who is doing the caching?

Running !dumpheap –type System.Weak yields the following output:

 0000000002603f88 000007fee1d478a0       32     
0000000002603fa8 000007fee1d478a0       32     
0000000002603fc8 000007fee1d478a0       32     
total 0 objects
Statistics:
              MT    Count    TotalSize Class Name
000007fee1d4f320        1           40 System.Collections.Generic.List`1
                                       [[System.WeakReference, mscorlib]]
000007fee1d478a0    11098       355136 System.WeakReference
Total 11099 objects
 

Yep, that List<WeakReference>, is probably the issue. So it’s time to look who created it by doing a !gcroot on it’s address.

 0:004> !gcroot 00000000025ad460 
Note: Roots found on stacks may be false positives. Run "!help gcroot" for
more info.
Scan Thread 0 OSTHread b3c
Scan Thread 2 OSTHread 3dc
DOMAIN(0000000000399A60):HANDLE(Pinned):4c17d8:Root:  00000000125a7048(System.Object[])->
  00000000025ad460(System.Collections.Generic.List`1[[System.WeakReference, mscorlib]])
 

Life just got miserable. .NET stores static fields in an Object Array for each app domain. The static array is pinned in memory so that’s the clue. Sadly, with .NET 4 SOS the only way to see which object has the List<WeakReference> as a field without manually dumping each object in the heap. Back in the .NET 1.1 days there was a way to pretty easily figure out the holding class, but Microsoft changed the implementation so it no longer works.

Fortunately, there is a way to figure out those static fields. All it takes is a little investment in the Professional edition on the amazing .NET Memory Profiler. Always purchase the Professional edition because that’s the version with the advanced feature to open mini dumps. Opening large mini dumps can take a long time as .NET Memory Profiler has to build up the reference chains and other data. However, I’m more than happy to let .NET Memory Profiler take it’s time because to do all of that work manually in SOS would consume months and make me give up technology.

After opening the mini dump of my sample program, which took about 60 seconds, I typed List into the Overview tab to narrow down to the List<WeakReference>

Double clicking on the on List<WeakRefefence> takes you to the Type details tab and shows you exactly who owns that pesky static.

It’s a TraceSource so we have the culprit! In fact, looking at the type instance graph shows the whole reference chain.

Looking at the TraceSource constructor in Reflector shows exactly where the WeakReference is created.

 public TraceSource(string name, SourceLevels defaultLevel)
{
    if (name == null)
    {
        throw new ArgumentNullException("name");
    }
    if (name.Length == 0)
    {
        throw new ArgumentException("name");
    }
    this.sourceName = name;
    this.switchLevel = defaultLevel;
    lock (tracesources)
    {
        _pruneCachedTraceSources();
        tracesources.Add(new WeakReference(this));
    }
}
 

The _pruneCachedTraceSources method is interesting and shows exactly why those WeakReferences are all stuck in Gen 2.

 private static void _pruneCachedTraceSources()
{
    lock (tracesources)
    {
        if (s_LastCollectionCount != GC.CollectionCount(2))
        {
            List<WeakReference> collection = new List<WeakReference>(tracesources.Count);
            for (int i = 0; i < tracesources.Count; i++)
            {
                if (((TraceSource)tracesources[i].Target) != null)
                {
                    collection.Add(tracesources[i]);
                }
            }
            if (collection.Count < tracesources.Count)
            {
                tracesources.Clear();
                tracesources.AddRange(collection);
                tracesources.TrimExcess();
            }
            s_LastCollectionCount = GC.CollectionCount(2);
        }
    }
}
 

Basically, the cache is only cleared whenever new TraceSource is added or a call to Trace.Refresh is made. In the Microsoft code they were mistakenly allocating a new TraceSource and TraceSwitch, which also has the WeakReference list, every time a connection came in. How this happened is that they converted what was a singleton static object into something they allocated on each call. That meant lots of TraceSource and TraceSwitch allocations but with this magic underneath causing big memory usage. You’ve probably guessed by now that you should always make your TraceSource and TraceSwitch fields statics so you hold only the one instance and avoid this potential memory issue.

Note that I’m not saying the implementation of TraceSource or TraceSwitch is wrong as it gives you the ability to refresh all your tracing in one call instead of making you manage all the individual instances yourself. That’s a nice feature of the tracing system in .NET. The implementation just doesn’t expect that you’ll be allocating hundreds of thousands.

While I would love SOS to have a better way to track down these static field problems, at least we do have a solution with .NET Memory Profiler.

Using Jounce Navigation to Create OOB Child Windows in Silverlight 5

C#er : IMage — Fri, 21 Oct 2011 12:22:03 GMT

One of the reasons I prefer to manage navigation as an event, rather than a strongly typed interface or handler, is because it allows for so much flexibility and extensibility in the navigation pipeline. In my Jounce framework , for example, the basic navigation event simply wires up an instance of a view to a view model and makes no presumptions about where that view belongs - it leaves positioning the view to the developer. The region manager simply listens for navigation events and passes the...(read more)

Working with PivotViewer and the CxmlCollectionSource

sloscialo — Mon, 17 Oct 2011 22:39:14 GMT

Microsoft’s PivotViewer control is an amazing tool for visualizing data and creating a unique UI for your application. The one issue everyone seems to have with it, however, is its lack of styling capability. In fact, working with PivotViewer in Expression Blend yields little in the way of styling or templating. There are only a few color settings one can make, and some generic overall changes. Replacing the filter panel or info panel is not currently supported.

What to do?

Since we cannot style the filter panel, we need to hide it and put our own in. Hiding the panel is relatively simple and straight-forward. Simply put, you need to subclass the PivotViewer and override the OnApplyTemplates() method, then walk the tree until you find the filter panel. Fortunately, tools like Snoop or Mole can help you determine where the filter panel resides. Below is a snippet of code showing where the filter panel resides in the Silverlight 5 version of the PivotViewer.

   1: public override void OnApplyTemplate()

   2: {

   3:     base.OnApplyTemplate();

4:

   5:     Grid partContainer = (Grid)this.GetTemplateChild("PART_Container");

   6:     CollectionViewerView cvv = ((CollectionViewerView)(partContainer).Children[2]);

   7:     Grid container = cvv.Content as Grid;

   8:     Border viewerBorder = container.Children[1] as Border;

   9:     Grid viewerGrid = viewerBorder.Child as Grid;

10:

  11:     // Filter Panel

  12:     viewerGrid.Children[2].Visibility = System.Windows.Visibility.Collapsed;

  13: }

NOTE: This is very brittle code and will most likely fail when Microsoft releases a new version of the PivotViewer.

Now that the filter panel is gone, we need to create our own. If you’re manually creating the facets and data in code, then you should have no trouble binding a new Filter control to your data structures. But what if you’re using the CxmlCollectionSource and loading your data from a cxml external file?

As anyone who’s worked with the CxmlCollectionSource can tell you, the facets and their filter values aren’t readily available for consumption. In order to build up a collection of facets and filters, you to perform a little preprocessing. The Items collection off the CxmlCollectionSource is the dataset you’re working with, however, getting values and properties for the items isn’t immediately apparent.

My solution was to create a small class to hold the facet information I required:

   1: public class Facet

   2: {

   3:     public string Category { get; set; }

   4:     public string Value { get; set; }

   5:     public bool IsChecked { get; set; }

   6: }

In order to iterate through the Items collection, you need to wait until the CxmlCollectionSource finishes processing the .cxml document. Since it occurs asynchronously, you can start your processing in the event handler for the StateChanged event. That can look something like this (I’m not implementing an MVVM pattern for simplicity’s sake. This is just part of the code-behind for the MainPage.xaml).

   1: void OnLoaded(object sender, RoutedEventArgs e)

   2: {

   3:     if (_cxml == null)

   4:     {

   5:         _cxml = new CxmlCollectionSource(new Uri(HtmlPage.Document.DocumentUri, "/Data/PivotViewerData.cxml"));

   6:         _cxml.StateChanged += CxmlStateChanged;

   7:     }

8:

   9:     return;

  10: }

11:

  12: void CxmlStateChanged(object sender, CxmlCollectionStateChangedEventArgs e)

  13: {

  14:     if (e != null && e.NewState == CxmlCollectionState.Loaded)

  15:     {

  16:         MyPivot.PivotProperties = _cxml.ItemProperties.ToList();

  17:         MyPivot.ItemTemplates = _cxml.ItemTemplates;

  18:         MyPivot.ItemsSource = _cxml.Items;

19:

  20:         ProcessFacets();

21:

  22:         this.DataContext = _facetData;

  23:     }

24:

  25:     _cxml.StateChanged -= CxmlStateChanged;

  26: }

The next step is to iterate over the Items of the CxmlCollectionSource and build a dictionary of Facets and their properties. The Items collection is a collection of PivotViewerItems that do not contain the actual values of the data elements. Instead, you need to call a method, GetPropertyValue(id) in order to get the list of properties that particular data elements contains.

The ProcessFacets() method below simply iterates over each item in the data set and determines which properties it contains that are filterable and what the acceptable values are for each. For example if your data has two filterable properties, such as “Ingredients” and “Serving Size”, these two facets could have a wide range of acceptable values for each data element. The call to GetPropertyValue for “Ingredients” for an particular item may return “Oil” and “Vinegar”, while another item may return “Milk”, “Oil” and “Peanuts.” The dictionary built by ProcessFacets will create a Key for “Ingredients” and add a List of four strings representing the four unique values.

I think it may be clearer just to read the code below:

   1: private void ProcessFacets()

   2: {

   3:     // Iterate through all the PivotViewerItems.

   4:     foreach (var item in _cxml.Items)

   5:     {

   6:         // Determine what Propeties it has that are filterable.

   7:         var facets = from f in item.Properties

   8:                      where

   9:                          (PivotViewerPropertyOptions.CanFilter ==

  10:                           (f.Options & PivotViewerPropertyOptions.CanFilter))

  11:                      select f;

12:

  13:         // For each facet, get its values.

  14:         foreach (var f in facets)

  15:         {

  16:             // create a new facet if it doesn't exist.

  17:             if (!_facetData.Facets.ContainsKey(f.Id))

  18:                 _facetData.Facets.Add(f.Id, new List<Facet>());

19:

  20:             // get the facet values.

  21:             var props = item.GetPropertyValue(f.Id);

22:

  23:             // there can be more than one value per facet.

  24:             foreach (var p in props)

  25:             {

  26:                 // don't add the same one more than once.

  27:                 if (!_facetData.Facets[f.Id].Any(o => o.Value.Equals(p)))

  28:                     _facetData.Facets[f.Id].Add(new Facet()

  29:                                                     {

  30:                                                         Category = f.Id,

  31:                                                         Value = p.ToString(),

  32:                                                         IsChecked = false

  33:                                                     });

  34:             }

  35:         }

  36:     }

  37: }

So, there you have it.

Armed with this data, you can now create your own filter panel and programmatically control the PivotViewer independently of the built-in panel. All you would need to do from this point on is write the Xaml for your Filter view and bind the Facet data to it. Finally, call SetViewerState on the PivotViewer and pass in the filter string built by your new view. Note, however, that the filter string is a mini-language of a sorts and will require some processing in code to generate the appropriate parameter. To get you started, I iterate over the dictionary like so:

   1: string[] filters = _facetData.Values

   2:   .SelectMany(facet => facet.Where(prop => prop.IsChecked))

   3:   .Select(prop => string.Format("{0}=EQ.{1}", prop.Category, prop.Value))

   4:   .ToArray();

5:

   6: string filterString = string.Join("&", filters.ToArray());

7:

   8: MyPivotViewer.SetViewerState(filters.Length > 0 ? filterString : "");

The PivotViewer is an extremely powerful tool to have in your arsenal, but it is not very customizable. With a small hack and some understanding of the data set, some of its limitations can be overcome. I hope this post gets you on the road to creating your own custom PivotViewer applications.

Boston Phone Camp Presentation Materials

jgarland — Fri, 14 Oct 2011 01:49:50 GMT

I had a great time talking about the Windows Azure Toolkit for Windows Phone at the Windows Phone Camp event in Cambridge, MA earlier today. I have posted the slide deck here for those who are interested in getting at the web links it contains.

If you missed the event and/or are interested in other Windows Phone Camp events, more information is available here.

Quick Tip: Design-Time Views for Regions

C#er : IMage — Tue, 11 Oct 2011 19:07:02 GMT

If you've worked with the Region Management pattern before, one source of frustration can be the lack of a design-time view. While you can compose individual views to be designer-friendly, the aggregate views that mark regions often end up devoid of anything useful. A simple little trick, however, can change that. You may be familiar with creating design-friendly view models , but the extensions for Blend work the same with views. For example, consider a main page that has a layout divided into regions...(read more)

Using Visual States to Set Focus on a Control

C#er : IMage — Fri, 07 Oct 2011 12:58:03 GMT

A common problem encountered in Silverlight applications is how to set the focus properly when transitioning between controls. For example, in the reference application I'm writing for the book Designing Silverlight Business Applications there is the option to either edit an existing record or create a new one. The result of clicking the appropriate button is a panel overlay that zooms into view. Obviously, it makes sense once the panel is rendered to set the focus to the first field so the user...(read more)