Rob Herbst

The Visual Studio editor has a very useful incremental search feature built in. Let’s try it out.

• Create a new Windows Application project.
• Open up the Form1.Designer.cs file in the editor.
• CTRL + I (this activates Incremental search mode)
• Type: “disp” (without the quotes)
• The selection should have moved to the first match of “disp” in the file.
• Type CTRL + I again. This moves you to the next match.
• CTRL + SHIFT + I moves you to the previous match.
• BACKSPACE removes the last character from the search string.
• ESC cancels incremental search mode.

If you develop with ASP.NET you need to subscribe to Scott Guthrie’s blog.

His blog is full of detailed and well written articles that provide invaluable insight to any ASP.NET programmer.

He just posted the PowerPoint presentation and the sample code from his TechEd talk. I would highly recommend you download and review the sample project. I know every time I download samples that Scott has posted I learn something new.

Some of the features shown:

• app_offline.htm
• cross page postbacks
• maintaining scrollback position
• default button
• custom databinding expressions

Here’s my addition to the lists started on the Retrospector blog and commented on by Michael Affronti and Steve Clayton:

Geeks like to be challenged with really interesting problems.

Most geeks, myself included, want to be challenged with really interesting problems to solve. The kind of problems that are only limited by your own creativity and determination to come up with the most simple, elegant and effective solution.

Do you have any more you would add to the list?

If you work with managed/native code interop you should read this blog post series {Part 1 & Part 2} by BorisJ who is a Visual C++ Program Manager at Microsoft.

He provides good examples and clear explanations of some C++ interop scenarios.

How would you like to be able to write the programming equivalent of “I might need this later….but I’m not so sure”? I’ll show you how.

A WeakReference is an object with a very interesting behavior, it allows you to keep a reference to an object while still making it possible for it to be garbage collected. See a previous post for a little more detail and links. Internally the WeakReference type uses an IntPtr to track a GCHandle that was acquired using the GCHandleType of Weak or WeakTrackResurrection.

This can be very useful if you are trying to managing the lifetime of objects in a cache or adding optimizations to possibly save time by not having to recreate an expensive object.

Let’s look at an example.

In your class you created two member variables:

WeakReference _weakRef = null;

Person _strongRef = null;

You created two new Person objects (which are simple objects I just created for this example, consisting of a Name property and some reference tracking code). Next you set the member variables to the newly created instances of the Person objects.

_weakRef = new WeakReference(p1);

The difference here you’ll notice that _strongRef is just a regular normal reference, whereas _weakRef is set to a WeakReference object with the person object (p1) passed in as a parameter in the constructor.

If a garbage collection were to occur, or just for testing purposes you called it yourself with:

GC.Collect();

Then the p1 target object that is held by the _weakRef member variable should be garbage collected. You can write code to check:

I found a very interesting blog called “Softies On Rails” that is written by two developers who have spent a lot of time developing software using Microsoft .NET.

Here are a few of my favorite posts on their blog:

Rails IDE for Windows after reading this post I downloaded the IDE and it’s like a mini version of Visual Studio just for Ruby On Rails — pretty cool.

Ruby 101: It’s a script

.NET to Rails Survival Guide

Why Rails? Part 3: Ruby

Why Rails? Part 5: Because I can test it

Overall a very interesting blog. Subscribed! And good luck with your new venture guys!

If you have ready my previous posts you know I am learning the Ruby language and the Rails web application framework.

I saw this post on blogs.msdn.com by Tim Ng that provides details on using RubyCLR to call VB.NET methods from Ruby which seems pretty straightforward and calling Ruby from VB.NET which is more complex.

Between the IronPython project and now RubyCLR it open’s up some interesting possibilities for using the power of dynamic languages in .NET.

Here is my entry for the latest Problogger Group Writing Project. If you would like to participate too, you can submit your entry before the end of the day Thursday August 17th.

I wanted to write about something that I thought would be very useful to anyone who uses the web. The search box on Google has some neat features in addition to searching. Here are my favorites:

1. Calculator - performs math and conversions
1. 5 miles in km
   
2. 2 ^ 6
   
3. 34 * 97
2. URL Information - find out what sites link to a url
1. www.problogger.net
3. Definitions - provides the definition of the word entered
1. define Blog
4. Phone Number Lookup - you can look up residential and business phone numbers
1. starbucks new york
5. Answers - you can enter in fact based questions and Google returns the answers
1. population of united states
2. birthplace of bill gates
6. Site specific searches - if you enter a site:url then your search results are restricted to just that site
1. list site:problogger.net
7. Stock quotes - enter a ticker and get a stock quote including a chart
1. goog
8. Weather
1. weather san jose, ca
9. Map Info
1. 1 infinite loop, cupertino, ca
10. Movies - display movie information for a given location or zip code
1. movies 98104

To see the whole list of Google search features visit their help center.

There’s a great feature hidden in the Find Window Combo Box that is part of the standard Toolbar in Visual Studio.

1. Open Visual Studio
2. CTRL + N (Create a new file) choose “HTML Page”
3. Position the cursor on the tag
4. Press CTRL + /
5. The focus should have shifted to the Find Combo Box
6. Type >
7. Now type E
8. Cool! It’s a command line with built in Intellisense.
9. Type dit.LineT
10. The entry for Edit.LineTranspose should be selected
11. Press enter

You’ll notice that the and tags are now transposed. Take a few minutes to look around at what commands are available in this list. You can browse the list by entering one letter at a time. For example “>a” to see all the items that begin with a.
This is a great way to quickly execute commands that aren’t mapped to convenient keyboard shortcuts.

If you have never used WinDBG or the SOS extensions before, read the following blog posts by Mike Taulty:

• A word for WinDBG – Part 1
• A word for WinDBG – Part 2

Mike walks you through a sample debugging session with WinDBG. Then in the second part, he focuses on the SOS extensions for .NET debugging. With the SOS extension you can do some seriously cool stuff:

• View thread/threadpool info
• View the finalizequeue
• See what’s allocated on the managed heap
• Determine what is keeping your managed object from being finalized by viewing it’s “roots”

If you have Visual C++ installed you can actually use SOS calls from the Visual Studio debugger! Read Mike’s post, that walks you through the setup and use of SOS from inside Visual Studio. As Mike points out, make sure you go to the project properties, choose Debug, and then check “Enabled unmanaged code debugging”. Be prepared the very first time you do this, it might be slow because the symbols have to be downloaded/loaded.