Debugging tricks

I was sitting with someone the other day and watching him debug an application and it made me want to post a couple tricks with the debugger that can help. 

first: learn some of the simple shortcuts. F5 starts the app with debugging ctrl+F5 starts it without. I was surprised by the fact that he took his hands off the keyboard to look for the mouse so that he could click the little icon on the toolbar every time he wanted to run something.

F9 sets (and clears) breakpoints – this is probably the handiest thing--  and F11 will “step into” a method, while F10 will step over it.

Those are the basics.

In addition, you can go to view->other windows->command window in Studio and have access to all the debugger info (and then some). A couple of the most useful things are:

        “Debug.DisableAllBreakpoints” and “Debug.EnableAllBreakpoints”. These alone are so useful, it’s scary. On any complex application, you know, the one that you’ve been working on for the last 3 days without coming up for air, you’ve got lots of steps to do before you get to the “good stuff”. Once you do actions X + Y, you want to step through loop Z to see what it’s doing. But you don’t want to step through Z until you’ve done X and Y. So you can end up stepping through lots of code that you really don’t care about. But if you disable all breakpoints, then run, do X and Y, then Enable all breakpoints, you will fly right past your breakpoints until you need them. Very cool.



      typing ? followed by a variable (there needs to be a space between the ? and the variable name) will print the contents of the variable. This is basically the same as hovering over the variable with your mouse or doing a quick watch, but typing it is easier when you’re looking for someArray[i].someObject.someProperty . I’ve seen lots of people spend all day trying to “drill down” in hover over without clicking on the wrong thing and making it vanish. I do it too, but the debug command is way easier. 

 

      Also, remember conditional breakpoints. When you set a break point, you can right click on it and select “condition”. This will open a dialog that will allow you to enter whatever you like and stop only when the condition is true. So, you can break on the 321^st iteration of the loop without having to step through the first 320. 

.  Hope this all helps. Please list some of your favorites below. 
-    --kevin

Extension methods

Yay! I finally have an excuse to use extension methods.

First, a brief explanation of what they are. Suppose you have an object – say a string. And you want to add some functionality to it. You could subclass the object (assuming it’s not sealed) and add your new method.

But if all you want to do is add one tiny little method, subclassing seems a bit top-heavy, doesn’t it? Besides, unless you’re using an object factory pattern (my favorite design pattern, by the way), you face the prospect of finding and changing every object instantiation in every line of code of your project to replace the parent with the child class. On large, multiple developer projects, this gets rough.

Microsoft gives you a work around. What you can do is to add a special static method somewhere in your code and .Net will automagically assign this to the desired class.

For example,

        public static int WordCount(this String str)

        {

            return str.Split(new char[] { ' ', '.', '?' },

                             StringSplitOptions.RemoveEmptyEntries).Length;

        }

The magic is the keyword “this” in the method signature. “This” tells the compiler that “WordCount” is an extension method on the string object.

The end result is that your code can now do something like:

       string x = "this is a test string";

       Console.WriteLine(x.WordCount());

And the Console will show the word count of x, just as if “WordCount” was a public method on the string class.

I’ve thought this was cool for a long time, but couldn’t find a use for it.

But, Dmytrii Nagirniak posted a reply to a thread on Stack Overflow that provides an awesome use:

http://stackoverflow.com/questions/1725903/determine-if-datacolumn-is-numeric

To sum it up, .Net has no “IsNumber()” method. So looking at a potential data value, it’s really hard to know if it’s a number type. What you end up with, is a complex if statement that does a GetType(), but then has to check to see if the type is a Double OR a Single OR an Int32 OR an Int64 OR a UInt16 OR…. Etc.

Putting this into an extension method makes a ton of sense. (I’m not sure why Microsoft didn’t already do this, frankly). This means that developers don’t need to deal with this mess each time, but just have to call

x.IsNumber().

The code for the extension just looks like this:

  public static Type[] numericTypes = new[] { typeof(Byte), typeof(Decimal), typeof(Double),

        typeof(Int16), typeof(Int32), typeof(Int64), typeof(SByte),

        typeof(Single), typeof(UInt16), typeof(UInt32), typeof(UInt64)};

 public static bool IsNumber(this object x)

    {

        if (x == null)

            return false;

        return numericTypes.Contains(x.GetType() );

    }

And this allows  you to instantiate any object and define whether the object is a number type.

A second (useful) variation of this examines whether a DataColumn (ie, in a DataTable) is a number type. It’s different because the DataColumn.GetType() would just return “DataColumn, you moron”, so you have to look at “DataColumn.DataType” :

  public static bool IsNumeric(this DataColumn col)

    {

        if (col == null)

            return false;

        return numericTypes.Contains(col.DataType);

    }

Pretty cool stuff.

--kevin

Addons

I've added a few extensions to Visual Studio that I thought I'd point out. By way of disclosure, I'm using Studio 2010 Professional, so these may or may not work with anything else.

First:
Power Productivity Tools from Microsoft

This is the coolest and most useful plug in I've found. You can follow the link above to see what it does in detail, but it includes things like auto brace completion, a couple improvements to quick find and a really nice improved scroll bar that allows you to see all break points and bookmarks on the scroll bar. Best of all, you can turn each feature on and off individually.So if all you want is to be able to cntr-click to go to the definition (very handy, by the way) you can shut the rest down.

Next:
Power Commands
This one is a bit less useful for me, but still has some nice things. The ability to "open containing folder" so you can get to the Windows Explorer location of the file is, itself, enough of a reason to get this. "Open Command Prompt" also ranks up there, since it will not only open the prompt, but auto-navigate you to your project folder.

Finally:
Indent Guides
This is a must have! It basically draws little colored lines connecting every open brace to its corresponding close brace. So it makes it much easier to debug a nested if inside of a loop inside of a method inside a class inside a name space and actually *understand* it.


Other things:
Keyboard shortcuts
Microsoft has made some of the keyboard shortcuts available as a poster.
Some of my favorite lesser-known ones:

• F12 on anything will take you directly to its defintion
• ctrl and the minus sign ( - ) is like a "back" button in a browser and will return to your last location. So if you put a cursor on a method reference, then hit F12, you'll be at the method definition. If you then type ctrl-, you'll be "back" to the place where you originally put your cursor.
• ctrl+shift+-  () will move you forward -- like a "forward" button in a browser. 
• Ctrl+shift+b does a build of the current project. 

Hope this all helps you be more productive. I think I deserve a cookie now.
--kevin

Another Little C# Thing I didn't know

Sometimes I don't think I know much about C# (or anything else for that matter).

I didn't know you could do this:

static void two(string x, int num=1)

in this, the parameter "num" is optional. I didn't know you could optional parameters in C#. I've been looking at C# code since C# has been around -- code reviews, my own code, samples on the internet -- but I can't recall ever seeing anyone use this.

Here's a code sample.

        static void Main(string[] args)
        {
            two("one", 2);
            two("two");
        }
 
        static void two(string x, int num=1)
        {
            Console.WriteLine(x + " " + num);
        }

You can also used named parameters. So this also works:
        two(num:7, x :"named");
(at least in .Net 2.0 and later).
I remember named and optional parameters in VB4,
but I was completely clueless that you could do it in C#.

Now, we're all a tiny bit less clueless.
--kevin

Quick diversion to Skyrim            

OK. Here’s a geek thing: I like to play computer games sometimes. Occasionally, I give into my guilty pleasure until it becomes an obsession. Naturally, I often keep my obsession hidden, like any good addict.

But I have to blog my recent experience with Skyrim, because I think it says a lot about the industry.

When my Skyrim disk arrived from Amazon, I eagerly popped the DVD into the drive and salivated during its loading. Only, you can’t just install a PC game anymore. The only way you can play (well, without a lot of back-door things) is to install Steam. For the non-gamers out there, Steam is an online service that verifies that I really own the copy of Skyrim I’m playing. Now forget the fact that Skyrim sold 3.5 million copies in the first 48 hours after its release and sold something around 10 million copies total, the companies that make this stuff now want to make sure that some poor 14 year old in Iowa isn’t playing illegally and costing them the 10 million and *first* copy they could have sold, so they burden the other 10 million of us with this top-heavy, internet-based nonsense.

(Example of the nonsense : I can’t play Skyrim if my internet connection goes down, even though I paid my $50 for the game and it’s not an online game. It’s kinda like OnStar preventing you from starting your car unless you first tell them your password. If you happened to park in an underground garage, too bad. You’ll have to be towed. Oh and Steam launches at start up every time I boot. There’s no option to turn that off without digging through a bunch of registry keys—which I did, by the way. Without doing that, every time you boot, you have to wait for the dialog to come up and prompt for your password, after it finishes verifying that the Steam service is available on the internet.)

I told myself last time I played a Steam game that I would never do it again. Seems I lied to myself. Well, to be fair, it wasn’t obvious that Skyrim used Steam. I think I’d heard it at one point, but forgot it. So, it is what it is.

Steam added quite a while to the install. It has to connect to the internet and sign you in with your account. Of course, I couldn’t remember my Steam password. I mean, it’s not like I use it all the time or have it tattooed on my arm or anything. So after a half an hour of installing and resetting and such, I was in.

Once I was in, Steam started to advertise to me – because, clearly, 10 million sales isn’t enough. Mostly, they advertise downloadable content, but occasionally, they push new games.

I get that I watch commercial TV and have to watch the ads because I don’t pay for it. And I get that I have to pay for HBO so that I don’t see the commercials. But when I pay for something *then* also have to watch the commercials, it fries my cupcakes.

OK. So I’m in and have seen all the ads. Now the game starts in earnest. The default settings on the game came up with lower-than-acceptable resolution, but I changed that. The game also came up in full screen mode, which I hate. I multi-task. I’m typically playing a game like this while I’m surfing the web, updating facebook, checking email and chatting with a friend. So I re-set the full screen to “windowed” mode – only to discover that the game was obviously written for an Xbox, since the window had no controls on it, and was just about impossible to drag. Oh, and it was on the wrong monitor. It always comes up on my primary, even though I set it for the secondary. Because, of course, Xboxes only have one monitor, I guess.

I figured out a trick to drag the window (had to place another app over it, so that just the outside of the frame was shown, then select the overlay-ed window and slide the mouse up until I just hit the exposed part of the frame. Then I could drag... no, really).

Well, a pain, but functional. So the game comes up and is just about *unplayable* with a mouse and keyboard. Oh, there’s instructions on how to do it, but the interface is completely unmanageable. Because it was made for an Xbox -- with its Xbox gamepad -- not a PC.

I remembered that I had an old Logitec game pad, so I shut down the game and searched for my controller. Got it, plugged it in and re-started the game. Only, Steam (God love them) re-set all my graphics settings and opened the game full-screen on the wrong monitor again, after trying to upsell me, of course. (*sigh*).

Well, OK, fine-- only the game doesn’t see my controller at all. I Google. And find out that the *only* control the game will support is the Xbox controller, because—wait for it -- it was written for the Xbox. I Google some more and find an emulator that will translate my Logictec controller into Xbox-ese, and fake out the game into thinking it’s an Xbox one.  So, I swallow the virus risk (well, I did scan the file), run the emulator and I’m good.

I restart Skyrim, sign into Steam and wait for Steam to respond. Steam re-sets my video again and opens full-screen on the wrong monitor with the low video settings. Then it tries to upsell me. But the emulator works.

So I’m gaming now. Although I spent so much time messing with it that I haven’t actually gotten into the game much. It’s playable now. But, so far, it’s not much fun. Hopefully, after $50 and a few hours of my time, that will change.

But all this speaks to the computer industry. The company that makes Skyrim (Valve, I think?) made something like half a billion dollars from the game. But it isn’t enough money anymore to avoid ads, to allow people to run offline or to actually support the target platform.

I see the same thing in other software I buy. The general quality sucks – I don’t mean functionality, I mean the platform support and such. Windows 8 looks like a kludge (more on that later). We’re told that we need a new interface because the old interface won’t support notepads – even though I don’t have a notepad… because the zillion dollars they make from PCs isn’t enough. The new version of Office (so I hear) will incorporate Office 365’s online support, even though I do a lot of editing offline. My new Dell gets angry when I don’t synch with Dell’s online cloud, even though I have no interest in putting anything on their online portal.

Seems to me, it’s all part of the same deal in computers to drive more review from the products. We’re being pushed into products that we’re told we want because it’s beneficial for the companies that make them. We’re having our personal data sold. We’re getting advertised to on our own computers.

Of course, we’re the ones who keep buying the stuff.

--kevin

Locks in C#

This is just something I didn’t know, so I thought I’d pass it along.

 When doing asynchronous coding in C#, it’s common to use the “lock” keyword, as in :

 lock(something)
 {
      // do stuff
}

One important thing that I didn’t know: the “lock” has no timeout. In some cases, this could be ok. But if the “something” that’s being done involves disk I/O or database access or anything that could potentially produce a lag, this could be bad. In some cases, it could even cause a deadlock.

Under the covers, “lock” just masks a call to Monitor.Enter and Monitor.Exit, so you can replace “lock” with these. Moreover, Monitor.TryEnter will allow you to set timouts, so you can use that. Even better, you can create a special object that implements IDisposable and do the “Monitor.Exit” in the Dispose() event. That way, any time the special object goes out of scope due to normal code flow or an exception, the Dispose() fires and you’re guaranteed to release the lock.

You can find a sample of this here:
http://www.koders.com/csharp/fid8EED099F752FABA10F6C8E661D1A6EF0736EB096.aspx

 Among other places. To use it, you just say:
 using (TimedLock.Lock(something, NumberOfMiliseconds))
 {
     // do stuff
}

So it works about the same way as “lock” only with the ability to pass a timeout. Very nice.

One other thing to remember is that locks are based on objects. If the “something” that you’re locking on is a simple type (say an int), .Net will box the int into a new object(). Unfortunately, the next thread that hits the lock sees that it’s an int and boxes it too, into it’s *own* object. The important thing is that thread1 and thread2 don’t share the object and both think they have a lock – which is really, really bad. So make sure the “something” is not a native type, but a real object. I sometimes use DateTime objects, since that also allows me to specify a datetime when the value would expire. But any subclass of object will do.


Till next time
--kevin

anonymous types & C#

My blog updates have been sparse lately. And by sparse, I mean non-existent. I mean rarer than a Google+ post.
There have been a lot of reasons for this – it’s been a rough winter and a busy spring so far.

But I’ve stacked up a lot of geek things to blog. I’ve got a little C# stuff, some SQL tricks, and a bit of general industry and gaming thoughts (for example, how Apple is now becoming more evil than Microsoft). For now, let me start with the C# stuff.

Anonymous types. My guess is you either
a) have no clue what they are,
b) think they’re the most evil thing since 8am meetings and are probably responsible for global warming or
c) love them so much you’re thinking about rewriting every line of code you’ve ever written (even things for companies you don’t work for anymore) to change all variables to anonymous types.

I’ve been a little surprised how little understanding people have of them. I blame Microsoft (as I often do). Why, oh why, did they select the “var” keyword when declaring anonymous types? I’ve had to explain to even senior technical people that they are *not* “variant” data types – like they kind you’d find in Javascript, for example. If you write
var x=””;
you *cannot* ever do
x=new Datetime();

the compiler will stop you.

Anonymous data types are bound at *compile* time, not run time. As I had to explain to someone just this week, there is no binary difference in the assembly between saying:
string x=””;
and
var x=””;
If you look at the MSIL, they are exactly the same.

So, as someone asked me this week: why use them?
Primarily, of course, they’re used for Linq. Because, at design time, the data set you are getting back from a Linq query isn’t known, you can’t very well use named data types. This is where it gets cool though.

If you think about what Linq does, it returns a set of data. That set is unknown at design time (as mentioned), but known at compile time through introspection. So, .Net uses reflection to type the data coming out of the Linq query and then creates class to contain it. The compiler does the work of creating the class definition and setting up a property (get()/set()) for each data element in the set.

The resulting class is “hidden” in that it’s not generated until compile time and in that it’s not named. Of course, names don’t really mean anything to the compiler anyway, so it doesn’t care, but that makes it complicated to actually refer to the specific class in code.
Enter the badly named “var”.

Here’s the cool thing. Since Linq is requiring the compiler to generate a class (really, it could *almost* use a struct, but it doesn’t for another reason which I’ll mention later), this means that the compiler now has the ability to generate class code. This means you can use that outside of Linq queries.

Why would I care? (I mean besides my own mental issues?)

Suppose you have a simple method which, say, reads the lines from a file and stores some info about them. For the sake of simplicity, lets say you want to know the original line number and the actual text from the input file—and you’ll be re-ordering the lines later, so you can’t just use a simple count, you have to persist the original.

You *could* create a class like this:
Class LinesAndCounts
{
int _lineNum =0;
int LineNumber
{
get
{
return _lineNum;
}
set
{
_lineNum=value;
}
}
…
…
…

And so forth.
It’s a lot of typing. And the class gets scoped to the assembly or the project or the namespace, not just the method. What if you’re just wanting to read a file, make some modifications to it, and re-write it, with the original line numbers. That shouldn’t require a class that gets scoped to the whole world, right?

What anonymous types let you do is this:
var x = new {LineNumber=0, LineText=”abc”};

The compiler will automagically generate code more or less the same as what I started to write above (before I got lazy). Frankly, I think that is so beautiful, it brings tears to my eyes (*sniff*,*sniff*). In one line of code, I’ve created a name-less class and assigned values that I can use later. Moreover, that class is scoped to the method/scope-block that created it. Once execution leaves the method, not only does “x” go out of scope, but the class itself gets de-scoped, and the garbage collector takes it back to the city dump.

So let me take a contrived, concrete example. Suppose I want to read all the lines of an input file. Let’s take a simple one:
its line one
its line two

And I want to print all these lines with their corresponding line numbers reversed. So the “its line two” would have line number 1, and “its line one” would have line number 2. And then I’m going to add a header line to throw this number scheme off.
OK, this is an overly simple example, and there are lots of efficient ways to do this using the file system objects and such. But let’s pretend that the operations are more complex than they really are.

I could create a class (call it MyClass) that would have 3 properties: the original line number, the text of the line, and the new line number. Then, I could add a method to this class that would transform the line numbers by taking the original line number and subtracting it from the total number of lines like

int Transform( int origLineNumber, totalLines)
{
return totalLines-origLineNumber;
}

I could create a List to hold the objects, and (for the sake of the demo) step through this original list to move the items to a new List with the re-numbered lines. Pretty inefficient, but demo-worthy and useful sometimes.

Doing that with anonymous types, though, I don’t need to create any of the classes. The code is here:


public class AnnonExample
{
public void messWithFile()
{
int lineNumber = 0;
var firstLine = new { LineNumber = lineNumber, LineText = "this is the new file", NewLineNumber=0 };
var lineList = (new[] { firstLine }).ToList();
lineNumber++;

foreach (string line in System.IO.File.ReadAllLines("fileStuff.txt"))
{
var theLine=new {LineNumber=lineNumber, LineText=line, NewLineNumber=0};
lineList.Add(theLine);
lineNumber++;
}

for (int i=0; i < lineList.Count; i++)
{
var l = lineList.ElementAt(i);
var p2 = Transform(l, (p) => new { LineNumber = p.LineNumber, LineText=p.LineText, NewLineNumber=((lineList.Count ) - (p.LineNumber)) });
Console.WriteLine(p2.LineNumber + ":" + p2.NewLineNumber + ":" + p2.LineText);
}


}
static T Transform(T element, Func transformFunc)
{
return transformFunc(element);
}
}

Note that the classes are all anonymous and loaded into lists and manipulated later. The “Transform” is accepting a lambda expression to do the dirty work, so it could be reused generically.

Under the covers, .Net is using the same anonymous class for each of the lines. It generates it once, then re-uses it. And it enforces type-checking on it – try to assign theLine=”x” at the bottom of the first loop and you’ll get a compile error. The generic list is the same way. You can’t fill it half-way with the lines above, then fill the rest with strings. It’ll bark.

My jury is still out on anonymous types. I can see their uses. But I do think they have the tendency to reduce readability if they’re over used. Still, they can be incredibly useful for the quickie class that you need just to hang onto for one iteration of a loop so that you can modify something, grab the results, then throw it away. In the example above, I could’ve done the same thing with parallel arrays, but I think this is much less messy. It isn’t always obvious how parallel arrays are connected. Here, it’s very straightforward.

In any case, it’s very cool stuff.

--kevin