Marshaled Thoughts

Introduction to jQuery Sample Code

Chad — Thu, 03 Feb 2011 12:29:00 -0700

It is over a week late, but this post includes the sample code from my “Introduction to jQuery” presentation from the Springfield .NET Users group last week. The zip file in this post includes a Visual Studio 2010 Web Application that provides basic jQuery samples. The samples include manipulating the DOM, ajax, and jQuery UI. There is even a “try it” type page for experimenting with selectors and effects. Enjoy!

IntroductionToJQuery.zip (253.05 kb)

Catching Common Exception Handling Mistakes

Chad — Tue, 18 Jan 2011 11:10:00 -0700

Microsoft provides excellent guidance for exceptions, but it's easy to forget and make some of these common exception handling mistakes. Below is a list of "must remember" exception handling guidance when programming in C# (although most of this is also applicable to other .NET languages.)

When to Catch Exceptions?

Only catch an exception when you understand exactly why it will be thrown and can recover from it.

If you follow this one rule, it will prevent many of the problems that you can get into when handling exceptions. Most of the time, you can find a list of exceptions that a member will throw from the member's XML documentation. You can access this documentation via Intellisense or by hovering the mouse cursor over the member. For detailed documentation, you can often see a list of exceptions along with the specific condition that will throw the exception on the member's MSDN documentation page.

This may feel funny at first, but remember that exceptions aren't bad. Understanding when and why a specific exception will be thrown will create more stable and secure code. If your application crashes because of an unhandled exception, that's just a signal that you forgot to program for a specific condition. So, before typing “catch” answer both of these questions:

Do I know exactly why this exception is being thrown here?
Can I recover from this exception?

Do not catch System.Exception
You should never catch System.Exception (or System.SystemException,) unless you plan to log and immediately re-throw the exception. Because all managed exceptions ultimately inherit from System.Exception, you cannot possibly know exactly why the exception you’re catching is being thrown. You should always catch the most specific exception type that you can.

If you do succumb to the temptation of catching System.Exception and are able to repress the shame from such coding do be sure to use “catch(Exception) {…}” NOT “catch {…}”. A catch statement without an exception type will catch all exceptions, including non-CLS exceptions.

"throw;" != "throw err;"
If you catch an exception for logging or other reasons, but then need to re-throw the exception, ALWAYS use "throw;". "throw err;" will affect the stack trace making troubleshooting more difficult. Look at the following call stacks and sample code for an example of the problem that "throw err;" causes.

// With throw err;
//at MyApp.Program.Method1() in ...\Program.cs:line 29
//at MyApp.Program.Run() in ...\Program.cs:line 18
//at MyApp.Program.Main(String[] args) in ...\Program.cs:line 13

class Program
{
  static void Main(string[] args)
  {
    Program p = new Program();
    p.Run();
  }

  void Run()
  {
    this.Method1();
  }

  void Method1()
  {
    try { Method2(); } catch (Exception err) { throw err; }
  }

  void Method2()
  {
    try { Method3(); } catch (Exception err) { throw err; }
  }

  void Method3()
  {
    throw new InvalidOperationException();
  }
}

// With throw;
//at MyApp.Program.Method3() in ...\Program.cs:line 33
//at MyApp.Program.Method2() in ...\Program.cs:line 28
//at MyApp.Program.Method1() in ...\Program.cs:line 23
//at MyApp.Program.Run() in ...\Program.cs:line 18
//at MyApp.Program.Main(String[] args) in ...\Program.cs:line 13

class Program
{
  static void Main(string[] args)
  {
    Program p = new Program();
    p.Run();
  }

  void Run()
  {
    this.Method1();
  }

  void Method1()
  {
    try { Method2(); } catch (Exception) { throw; }
  }

  void Method2()
  {
    try { Method3(); } catch (Exception) { throw; }
  }

  void Method3()
  {
    throw new InvalidOperationException();
  }
}

Visual Studio 2010 Icon Library

Chad — Sat, 03 Jul 2010 09:25:00 -0700

Icons make our applications more usable and visually stimulating. Before scouring the internet for free icons or purchasing an icon library, check out the icons that ship with (non-Express versions of) Visual Studio for free.

Since Visual Studio 2005, Visual Studio has shipped with common Windows and Office icons to encourage us to build more consistent looking applications.

Icon formats include bmp, ico, png, and xaml. Also, some animations are included in gif and avi formats. The Visual Studio Icon Library is a zip file in the program files directory.

C:\Program Files (x86)\Microsoft Visual Studio 10.0\Common7\VS2010ImageLibrary\1033

Calling STA COM Components from ASP.NET Webpage

Chad — Fri, 11 Jun 2010 16:10:00 -0700

Can not call friend function on object which is not an instance of defining class
Google offered little help resolving this problem, so I thought I’d create this keyword-rich blog post so that someday it might climb the page ranks and help someone.

At work, we have an ASP.NET website that uses our Visual Basic 6 COM library via .NET Interops. Everything works quite well until you create a new .aspx page and forget to add the AspCompat=”true” @page directive attribute. It’s an easy thing to forget (it’s bitten me twice now.) The difficult part is that the COMException has an error message that is misleading: “Can not call friend function on object which is not an instance of defining class”.

AspCompat=”true”
The solution is actually very simple. The problem is caused because ASP.NET pages execute in a multithreaded apartment (MTA) and the VB6 COM Components expect to be in a single-threaded apartment (STA.) Adding the AspCompat=”true” attribute to the @page directive to force the page to execute in a STA.

The MSDN documentation does offer one word of caution about setting AspCompat=”true”. It can introduce performance issues if you instantiate your COM objects inside the page’s constructor. Microsoft recommends keeping that code in the page event handlers such as Page_Init and Page_Load.

New Visual Studio 2010 Features

Chad — Thu, 29 Apr 2010 17:22:00 -0700

I’ve had some people ask for this list so I’m putting it up here for everyone. Below is my outline from Wednesday night’s Springfield .NET Users group meeting presentation. These are all of the new VS2010 features that I covered. Enjoy!

New VS2010 Features

Visual
- IDE redesigned for improved readability
  - Unnecessary lines and gradients removed
- Multi-monitor support
  - Document windows (Code Editor, Design View, etc.) can be placed outside of the IDE window.
    - Code Editor & Design View can now be viewed side-by-side

Performance
- Start-up is faster
- Add References Dialog is faster

Code Editor
- Zoom
- Clicking a symbol highlights all instances of that symbol
  - Move to next/previous with Shift+Ctrl+Up/Down
- Box Selection Enhancements
  - Box selection Alt+Select or Shift+Alt+Arrow (available prior to 2010)
  - Text Insertion: Type into a box to insert new text on every line
  - Paste Contents of one box to another
  - Zero-Length boxes
- Navigate To
  - Edit > Navigate To
  - Upper case characters make the search case-sensitive
  - Wildcard, regex, and boolean operators not supported

Intellisense
- "Contains"
- Camel case
- Completion v. Suggestion Mode
  - Suggestion mode doesn't insert the suggested intellisense item
  - Toggle Mode: Ctrl+Alt+Space when intellisense menu is visible.

Debugging
- Data Tips: Tool tip watch windows
  - "Stick" & "Float" debug values to the code editor
  - Like floating watch window
  - Scrolls with code
  - Hides when new file is viewed
  - Can add comments
  - Can be imported/exported (as .xml)
    - From debug > export datatips
- Break points window
  - Can label break points
  - Search and filter on labels
  - Helps manage break points
  - Can be imported/exported (as .xml)
    - From break point window
- Thread Window
  - Flag Just my Code > Group by Flagged > Collapse un-flagged - shows just my threads
  - Search by field values
  - Inline Call stack expansion
    - Click arrow in location field
  - Search call stacks
  - Thread arrow
- Save a mini dump
  - While VS breaks on an error > Debug > Save Dump
  - VS can now open a .dmp file directly (not file > open project)
- Historical Debugger (Team System, Managed Code only, 32 bit only)
  - Tools > Options > Historical Debugging
  - Allows you to step back in time

WPF & Silverlight Designer
- Silverlight Designer support (VS2008 was read-only)
- Drag-and-Drop data binding in WPF
  - Binding building dialog
- Debugging - WPF Tree Visualizer

Coding even faster with TemporaryMacro in Visual Studio

Chad — Mon, 12 Apr 2010 10:43:00 -0700

Last week I found my new favorite Visual Studio 2008 productivity tool: TemporaryMacro. You can find this functionality in Tools > Macros > Record/Run TemporaryMacro. Being a shortcut-junkie though, I prefer Ctrl+Shift+R and Ctrl+Shift+P for recording and playing respectively.

The Macro feature in Visual Studio is one of those things that I’ve always been aware of, but have never really taken advantage of because I didn’t want to manage a library of macros. The TemporaryMacro feature is a quick and easy to use “throw away” macro and great for tedious text modifications.

Example Usage
This is a simple example, but yesterday I had pasted a digital certificate thumbprint into a .config file. The thumbprint had a space every two characters, that wasn’t necessary. To remove the spaces, I had to press: Right > Right > Delete for all 19 spaces that I wanted to remove.

With macros I started the recorder by pressing Ctrl+Shift+R. I pressed Right > Right > Delete to remove the first space. I then pressed Ctrl+Shift+R to stop the macro recording. Then I quickly pressed Ctrl+Shift+P 18 more times to replay the macro removing the remaining spaces.

Useful Text Manipulation Shortcuts
The record > replay process takes a tiny bit of forethought because you need to consider how executing the macro repeatedly will behave. You also need to think about the edge case of your final replay as you may accidentally change text that you didn’t intend to change. I use these shortcuts all of the time, but I find that within the context of macros I use them differently to affect the behavior of the text manipulation replays.

Arrow – Move the cursor left or right one character or up or down one line.
Shift+Arrow – Select text while moving cursor moves up, down, left, or right.
Ctrl+Left (or Right) – Move the cursor left or right one word at a time.
Shift+Ctrl+Left (or Right) – Select text while moving left or right one word at a time.
End – Move the cursor to the end of the line.
Ctrl+End – Move the cursor to the end of the file.
Home – Move the cursor to the beginning of text for the current line.
Home (a second time) – Move the cursor to the begging of the line.
Shift+{any of the home/end combinations} – Select text while moving the cursor.
Ctrl+Home – Move the cursor to the beginning of the file.
Shift+Delete – Delete the entire line.

It may feel slow at first, but I promise you that if you stick with it, the TemporaryMacro will become a frequent tool in your daily coding habits.

Attention To Detail: Problems Installing SQL Server 2008 on Windows 7

Chad — Thu, 01 Apr 2010 10:26:00 -0700

I tried installing SQL Server 2008 Developer Edition on a Windows 7 machine yesterday and ran into some issues that I thought I’d note here. I also re-learned a lesson about carefully reading error messages. The solution was simple, but I made it more difficult than it should have been. Hopefully this will help you when you decide to install SQL Server 2008 on a Win7 machine and also serve as a reminder that slow down and pay attention.

Windows 7 Known Compatibility Issues
When I first ran the SQL Server 2008 install, Windows 7 displayed a message box alerting me that there are known compatibility issues for SQL Server 2008 on Windows 7. You will want to remember to install SQL Server 2008 SP1 after successfully installing SQL Server 2008. For now, you can ignore this warning and continue with the install.

Rule Check – Previous releases of Visual Studio 2008
After choosing my install options and setting up configurations, the install failed with the Rule Check Result: “Previous releases of Microsoft Visual Studio 2008”. If you click the Failed link you will see instruction that Visual Studio 2008 SP1.

Installing VS2008 SP1 and re-starting the install corrected my problem.

The Lesson
For me the issue was mental sleight of hand. Since installing software is a no-brainer task, I was doing other things while the install ran. When the install first started, I made the mental note that I needed to install SQL Server 2008 SP1. Near the end of the install when the rule check failed for previous versions of Visual Studio 2008, I literally thought that it said SQL Server 2008.

I was pretty sure that I hadn’t installed SQL Server 2008 yet, but thought that maybe I had put an Express edition on there or something. I searched my installed programs and services, but didn’t find anything. I even tried installing SQL Server 2008 SP1. Only after reading through some blog posts about SQL Server 2008 compatibility issues on Windows 7 did I realize that I had misread the error message.

When reading error messages and stack traces from my own applications, I’m diligent about reading them closely, but I simply underestimated the level of attention that this install required. Whoops!

TCP Federation with Windows Identity Foundation

Chad — Thu, 25 Mar 2010 12:00:00 -0700

Windows Identity Foundation (WIF) makes it very easy to build basic federated scenarios. The WIF SDK offers Visual Studio templates for building simple Security Token Services (STS) and Relying Party (RP) services. The SDK also has an excellent help file with information about customizing the basic scenarios.

However, being as new as it is, there isn’t much guidance yet for building your own STSs and RPs from scratch. Also, the deployment and securirty best practices information is difficult to find or non-existent.

Lately, I’ve been researching WIF and discovered that I have a specific scenario that isn’t covered in the guidance. It seems to me that this would be a common scenario, but I was unable to find many resources online that offered help. In fact, I only found one blog post that was useful in solving this problem. You may want to check it out before going through all of the steps in this post.

My scenario included a Claims Aware Relying Party WCF service that that exposed its endpoints over net.tcp bindings. The STS could be accessed through wsHttp endpoints.

I built this scenario but had a really difficult time updating the XML binding configurations for the RP and Client. This post includes my step by step notes for building the scenario described here. I’ve included the source code for download too, but it will NOT work on your computer because you will not have the same certificates or URIs. The steps and source code are provided for demonstration purposes and should not be used in production applications.

WIFSample.zip (99.74 kb)

How To: Implement Federated Security over TCP

The steps below are pasted directly from my OneNote notebook so I have to apologize for the quality – that said, they should be clear enough to follow along. This process creates a functional federated solution, but it is far from being production-ready. I’m sure that there is a more direct way to accomplish this, but I’ve found that this process is a reliable way to build the appropriate bindings for TCP Federation.

**Before you start, you should have installed the WIF SDK (be sure that you’re on a supported OS – Vista or higher) and that you have a good ~30 minutes to finish these steps.

Note: You can click any of these images for a larger version

Open Visual Studio 2008 as an Administrator (this is important because VS will need to create and install certificates in certmgr.msc)
1. Create a new Blank Solution
3. In Solution Explorer: Right-click the WIFSample Solution
4. Create your Relying Party Service (WCF Service Library)
6. Open the App.config, copy the base address for your RP service
8. In Solution Explorer: Right-click SampleRP project > Add STS Reference
13. Right-click SampleRP project > Properties
  1. Choose the debug tab
  2. Remove /client:"WcfTestClient.exe" from the Command line arguments field – it will annoy you.
Create HttpClient Console Application
2. Right-click HttpClient project > Add Service Reference
4. Right-click solution > Set startup projects
  1. Set all projects to start with the STS starting first, RP second and Client last
1. Call the RP Service from your Console Application
3. Add a reference to System.IdentityModel & Microsoft.IdentityModel to the RP service project
4. Update Service1's implementation to output the claims identity
Test that the Http Bindings are correct
Add netTcp Binding to RP
1. Open RP's App.config
3. Add endpoints for net.tcp bindings
5. Add the netTcp customBinding (you may want to copy this from the source code.)
7. And the binding for the STS
9. Lastly add the net.tcp endpoint to the audienceUris
Test that haven't broken your RP - Run the solution (note that you’re still using http endpoints on the RP)
Lastly, let's add a TcpClient
1. Right-click solution > Add New Project > Console Application
3. Right-click TcpClient project > Add Service Reference
5. Open TcpClient's app.config and comment the http endpoint
7. Implement the TcpClient
Success

ASP.NET Server-Side Events not Firing

Chad — Tue, 02 Mar 2010 12:27:00 -0700

Recently, I was troubleshooting a difficult to find bug in an ASP.NET website. The bug was clearly environmental since the website worked for many other customers. We could only reproduce it on this particular customer’s server, so my diagnostic options were limited.

The Symptom
This application contains an ASP.NET DataGrid control that will redirect to a new page when a row is clicked. After some SQL and ASP.NET tracing, I determined that the server-side RowCommand event wasn’t firing.

The Cause
To enable selecting a row by clicking it, the original developer added some custom JavaScript that would invoke the Select row command on the datagrid when the row is clicked. ASP.NET uses dollar signs to delimit control namespaces so that controls can be uniquely named within the control hierarchy. When the HTML is rendered, ASP.NET replaces the delimiters with an underscore and uses that name for the element’s ID attribute. When forcing the post back, the original developer simply replaced the underscores with dollar signs so that ctl01_content_datagrid became ctl01$content$datagrid.

This works normally, however on this customer’s server clt01 was being named _ctl01, this broke the original developers assumption about names since the first underscore was actually part of the control name and not a delimiter. When the post back made it to the server, ASP.NET didn’t fire the server-side event because the names were wrong.

The Fix
The correct way to fix this would be to use the ClientScriptManager (via Page.ClientScript) to emit the correct __doPostPostBack(…) statement, but this particular application relies heavily on ASP.NET’s “normal” naming convention. The quick and simple solution was to add the <xhtmlConformance mode=”Transitional” /> element to the web.config. Since Transitional is the default mode for this setting, I assume (but didn’t verify) that the mode was set somewhere deeper in the configuration stack such as a root-level web.config or machine.config.

Details for this setting are here –> http://msdn.microsoft.com/en-us/library/ms228268.aspx

Valentines Muncher

Chad — Mon, 15 Feb 2010 05:13:00 -0700

I have a fun post this week. At work we had a Valentine's Day event and all employees decorated Valentine bags. I saw this as an opportunity to build a robot using my Lego NXT set. I built and programmed the robot’s insides and my wife decorated and accessorized the robot’s outsides. Watch the video to see him in action.