In this case, I want to put a window just under another control, aligned to its left side.

CalcWindow calc = new CalcWindow();

Point point = this.PointToScreen(

    new Point(0, this.ActualHeight));

PresentationSource source = 

    PresentationSource.FromVisual(control);

double dpiX = 

    96.0 * source.CompositionTarget.TransformToDevice.M11;

double dpiY = 

    96.0 * source.CompositionTarget.TransformToDevice.M22;

calc.Left = point.X * 96.0 / dpiX;

calc.Top = point.Y * 96.0 / dpiY;

calc.Show();

The crux of this is getting the current DPI. You could use P/Invoke to call native methods to get this, but the transformation matrix contains the same information as well.

For my solution I wanted something that behaved very similarly to the WinForms NumericUpdown control.

Some of the specifications:

1. Allows user to set Value, MaxValue, MinValue, Increment, and LargeIncrement.
2. Text directly entered is limited to numbers
3. Pasted text is not intercepted, but when the control has lost focus it will be validated and reset to the previous value if necessary
4. Two buttons, for increment and decrement
5. Holding down the buttons with the mouse causes the number to increment continuously
6. Up and down increment and decrement by Interval
7. Page Up and Page Down increment and decrement by LargeInterval
8. This version only supports integers

Creating the control

To begin, create a new WPF project and add a new User Control called NumericEntryControl. This will create a pair of .cs and .xaml files.

In the XAML file, change the <Grid> root element to be a <DockPanel>.

<UserControl 

    x:Class="NumericEntryDemo.NumericEntryControl"

    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"

    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"

    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" 

    xmlns:d="http://schemas.microsoft.com/expression/blend/2008" 

    mc:Ignorable="d"

    xmlns:my="clr-namespace:NumericEntryDemo" Width="200" Height="26">

    <DockPanel>

    </DockPanel>

</UserControl>

Before we add the controls, let’s add some properties to our user control to hold the values the controls will use. These are dependency properties in order to take advantage of all the WPF goodness like data binding and animation. Let’s also add standard .Net property wrappers.

public partial class NumericEntryControl : UserControl

{

    public static readonly DependencyProperty ValueProperty = 

        DependencyProperty.Register("Value",

            typeof(Int32), typeof(NumericEntryControl),

            new PropertyMetadata(0));

    public static readonly DependencyProperty MaxValueProperty = 

        DependencyProperty.Register("MaxValue",

            typeof(Int32), typeof(NumericEntryControl),

            new PropertyMetadata(100));

    public static readonly DependencyProperty MinValueProperty = 

        DependencyProperty.Register("MinValue",

            typeof(Int32), typeof(NumericEntryControl),

            new PropertyMetadata(0));

    public static readonly DependencyProperty IncrementProperty = 

        DependencyProperty.Register("Increment", 

            typeof(Int32), typeof(NumericEntryControl),

            new PropertyMetadata(1));

    public static readonly DependencyProperty LargeIncrementProperty = 

        DependencyProperty.Register("LargeIncrement",

            typeof(Int32), typeof(NumericEntryControl),

            new PropertyMetadata(5));    

    public Int32 Value

    {

        get

        {

            return (Int32)GetValue(ValueProperty);

        }

        set

        {

            SetValue(ValueProperty, value);

        }

    }

    public Int32 MaxValue

    {

        get

        {

            return (Int32)GetValue(MaxValueProperty);

        }

        set

        {

            SetValue(MaxValueProperty, value);

        }

    }

    public Int32 MinValue

    {

        get

        {

            return (Int32)GetValue(MinValueProperty);

        }

        set

        {

            SetValue(MinValueProperty, value);

        }

    }

    public Int32 Increment

    {

        get

        {

            return (Int32)GetValue(IncrementProperty);

        }

        set

        {

            SetValue(IncrementProperty, value);

        }

    }

    public Int32 LargeIncrement

    {

        get

        {

            return (Int32)GetValue(LargeIncrementProperty);

        }

        set

        {

            SetValue(LargeIncrementProperty, value);

        }

    }

}

Creating an incrementing TextBox

Add a TextBox inside the <DockPanel> and bind its text to the value we created in our control:

<DockPanel d:LayoutOverrides="Width">

    <TextBox 

        x:Name="_textbox" 

        Margin="2,0" 

        Text="{Binding Value, 

            Mode=TwoWay, 

            RelativeSource={RelativeSource FindAncestor,

                AncestorLevel=1, 

                AncestorType={x:Type my:NumericEntryControl}}, 

            UpdateSourceTrigger=PropertyChanged}" 

        HorizontalAlignment="Stretch" 

        HorizontalContentAlignment="Right" 

        VerticalContentAlignment="Center" />

</DockPanel>

This will create a TextBox that sizes itself with its parent (a feature I wanted, but is not strictly necessary) and  its text will be bound to the Value in our UserControl.

Handling text input

It used to be that you pointed with a mouse and entered text with a keyboard. However, it is common now to enter text with a stylus, gestures, or some future method not invented yet. Thankfully, WPF supports generic text input handling so you don’t have to concern yourself with the specific hardware.

public NumericEntryControl()

{

   InitializeComponent();

   _textbox.PreviewTextInput += 

        new TextCompositionEventHandler(_textbox_PreviewTextInput);

}

void _textbox_PreviewTextInput(object sender, 

                   TextCompositionEventArgs e)

{

    if (!IsNumericInput(e.Text))

    {

        e.Handled = true;

        return;

    }

}

private bool IsNumericInput(string text)

{

    foreach (char c in text)

    {

        if (!char.IsDigit(c))

        {

            return false;

        }

    }

    return true;

}

This prevents anything except numbers from being entered, whether via character recognition or keyboard. It does not, however, prevent the user from pasting non-numeric text into the box. We’ll handle that later.

Validating Text input

It’s problematic to validate and correct user input as they are entering it. For example, if you set the MaxValue to 100, then every time you enter 1000, it jumps to 100, it can be jarring. It’s a similar situation with text pasted into the control. What the NumericUpDown control does is handle these sort of situations when the control loses focus.

To prepare for this, when the control gains focus, we need to save the last valid value so we have something to restore to.

When the control loses focus, we need to first verify that it is a number and if so, clip it to the bounds of our MinValue and MaxValue. If anything fails, set it back to the previous value.

public partial class NumericEntryControl : UserControl

{

    private int _previousValue = 0;

    public NumericEntryControl()

    {

        InitializeComponent();

        _textbox.PreviewTextInput += 

            new TextCompositionEventHandler(

                _textbox_PreviewTextInput);

        _textbox.GotFocus += 

            new RoutedEventHandler(_textbox_GotFocus);

        _textbox.LostFocus += 

            new RoutedEventHandler(_textbox_LostFocus);

    }

    void _textbox_GotFocus(object sender, RoutedEventArgs e)

    {

        _previousValue = Value;

    }

    void _textbox_LostFocus(object sender, RoutedEventArgs e)

    {

        int newValue = 0;

        if (Int32.TryParse(_textbox.Text, out newValue))

        {

            if (newValue > MaxValue)

            {

                newValue = MaxValue;

            }

            else if (newValue < MinValue)

            {

                newValue = MinValue;

            }                

        }

        else

        {

            newValue = _previousValue;

        }

        _textbox.Text = newValue.ToString();

    }

}

Handle arrow keys

Just because WPF can handle text input from a variety of sources in a hardware-agnostic way doesn’t mean we should ignore the particular strengths of the keyboard. Specifically, we should handle the up and down arrows.

public NumericEntryControl()

{

    ...

    _textbox.PreviewKeyDown += 

        new KeyEventHandler(_textbox_PreviewKeyDown);

}

void _textbox_PreviewKeyDown(object sender, KeyEventArgs e)

{

    switch (e.Key)

    {

        case Key.Up:

            IncrementValue();

            break;

        case Key.Down:

            DecrementValue();

            break;

        case Key.PageUp:

            Value = Math.Min(Value + LargeIncrement, MaxValue);

            break;

        case Key.PageDown:

            Value = Math.Max(Value - LargeIncrement, MinValue);

            break;

        default:

            //do nothing

            break;

    }

}

private void IncrementValue()

{

    Value = Math.Min(Value + Increment, MaxValue);

}

private void DecrementValue()

{

    Value = Math.Max(Value - Increment, MinValue);

}

IncrementValue() and DecrementValue() are pulled out as their own method because they’re used in the button-handling code as well (see below).

The code so far is a perfectly usable textbox that accepts only numbers and can be incremented using the keyboard. Typically, however, we also need to support the mouse, and for that we need buttons (unless you want to do something exotic like programs like Photoshop and Lightroom do, where text boxes have support for incrementing gestures—that’s another article).

A button you can hold down

Adding buttons to increment once per click is pretty easy, but we really want to be able to hold down the buttons and have the TextBox increment. Let’s start by adding the XAML for the buttons:

<UserControl 

    x:Class="NumericEntryDemo.NumericEntryControl"

    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"

    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"

    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" 

    xmlns:d="http://schemas.microsoft.com/expression/blend/2008" 

    mc:Ignorable="d"

    xmlns:my="clr-namespace:NumericEntryDemo" 

    Width="200" Height="26"

    >

    <DockPanel d:LayoutOverrides="Width">

        <Button x:Name="buttonDecrement" 

                DockPanel.Dock="Left"

                Content="-" 

                Width="{Binding ActualHeight, 

                    ElementName=buttonDecrement, Mode=Default}" 

                Height="{Binding ActualHeight, 

                    ElementName=_textbox, Mode=Default}"/>

        <Button x:Name="buttonIncrement" 

                DockPanel.Dock="Right" 

                Content="+" 

                Width="{Binding ActualHeight, 

                    ElementName=buttonDecrement, Mode=Default}" 

                Height="{Binding ActualHeight, 

                    ElementName=_textbox, Mode=Default}"/>

        <TextBox 

            x:Name="_textbox" 

            Margin="2,0" 

            Text="{Binding Value, 

                Mode=TwoWay, 

                RelativeSource={RelativeSource FindAncestor,

                    AncestorLevel=1, 

                    AncestorType={x:Type my:NumericEntryControl}}, 

                UpdateSourceTrigger=PropertyChanged}" 

            HorizontalAlignment="Stretch" 

            HorizontalContentAlignment="Right" 

            VerticalContentAlignment="Center" />

    </DockPanel>

</UserControl>

Note that the button Width property is  bound to its own ActualHeight property, and the Height property is bound to the TextBox’s ActualHeight. This has the effect of keeping the buttons square, the same height as the TextBox. It’s an effect I wanted, but you can easily dispose of it. With these buttons, our control finally takes shape:

How fast should we increment?

Before writing the code to do the incrementing as we hold the button down, it’s worth considering how fast the incrementing should occur. Ideally, we would want it to increment at about the same rate as if we were holding down the up key on the keyboard. The keyboard repeat rate is an operating system value that we can retrieve.

There are actually two values:

private static int _delayRate = 

    System.Windows.SystemParameters.KeyboardDelay;

private static int _repeatSpeed = 

    Math.Max(1, System.Windows.SystemParameters.KeyboardSpeed);

The delay rate is how long we should wait before starting the repetition, and is given in multiples of 250ms. Roughly speaking, humans can determine and control actions with lengths of time of about 200ms, so 250ms is a good value to start with. Any shorter and the repetition might start when it was not intended (say, if they just click the button instead of holding it down).

The keyboard speed is the number of times per second we should repeat—sort of. The value can be 0, so because of the way I use it below I want to sure it’s at least 1.

To allow us to hold the button down, we need to override the default mouse handling of a button which is to disable the standard LeftMouseButtonDown/Up messages. Instead, we need to handle the PreviewMouseLeftButtonDown message and its corresponding Up message.

When we handle the down message, we need to set a timer for the keyboard delay value. When we handle the timer’s tick, we need to increment (or decrement) and change the timer’s interval to the repeat speed. This repeat speed is calculated merely by dividing 1000ms (1s) by the rate per second. There may be better ways, but this gets pretty close to the rate experienced by the keyboard on my computer. Finally, when the mouse button is released we need to stop the timer. We also do a final increment, which will cover the case where the user clicks instead of holds.

We also need to capture the mouse in case the user moves it off the button—otherwise the timer will just keep incrementing forever.

Here’s the code:

private DispatcherTimer _timer = 

    new DispatcherTimer();

private static int _delayRate = 

    System.Windows.SystemParameters.KeyboardDelay;

private static int _repeatSpeed = 

    Math.Max(1, System.Windows.SystemParameters.KeyboardSpeed);

private bool _isIncrementing = false;

public NumericEntryControl()

{

    ...

    buttonIncrement.PreviewMouseLeftButtonDown += 

        new MouseButtonEventHandler(

            buttonIncrement_PreviewMouseLeftButtonDown);

    buttonIncrement.PreviewMouseLeftButtonUp += 

        new MouseButtonEventHandler(

            buttonIncrement_PreviewMouseLeftButtonUp);

    buttonDecrement.PreviewMouseLeftButtonDown += 

        new MouseButtonEventHandler(

            buttonDecrement_PreviewMouseLeftButtonDown);

    buttonDecrement.PreviewMouseLeftButtonUp += 

        new MouseButtonEventHandler(

            buttonDecrement_PreviewMouseLeftButtonUp);

    _timer.Tick += new EventHandler(_timer_Tick);

}

void buttonIncrement_PreviewMouseLeftButtonDown(

    object sender, MouseButtonEventArgs e)

{

    buttonIncrement.CaptureMouse();

    _timer.Interval = 

        TimeSpan.FromMilliseconds(_delayRate * 250);

    _timer.Start();

    _isIncrementing = true;

}

void buttonIncrement_PreviewMouseLeftButtonUp(

    object sender, MouseButtonEventArgs e)

{

    _timer.Stop();

    buttonIncrement.ReleaseMouseCapture();

    IncrementValue();

}

void buttonDecrement_PreviewMouseLeftButtonDown(

    object sender, MouseButtonEventArgs e)

{

    buttonDecrement.CaptureMouse();

    _timer.Interval = 

        TimeSpan.FromMilliseconds(_delayRate * 250);

    _timer.Start();

    _isIncrementing = false;

}

void buttonDecrement_PreviewMouseLeftButtonUp(

    object sender, MouseButtonEventArgs e)

{

    _timer.Stop();

    buttonDecrement.ReleaseMouseCapture();

    DecrementValue();

}

void _timer_Tick(object sender, EventArgs e)

{

    if (_isIncrementing)

    {

        IncrementValue();

    }

    else

    {

        DecrementValue();

    }

    _timer.Interval = 

        TimeSpan.FromMilliseconds(1000.0 / _repeatSpeed);

}

And voila! A NumericEntryControl that’s basic and easy-to-use for both keyboard and mouse.

Further improvements

This isn’t the last word in numeric entry controls, by any means. There are many ways to accomplish it, and this is one that worked well for me. There are a number of further enhancements you could do (and perhaps should do):

• More validation
• Ensure that MaxValue >= MinValue
• Set focus to the TextBox when the control gains focus (maybe)
• Define strokes to increment and decrement with a stylus
• The user can change the keyboard repeat rate through Control Panel. This program could be modified to listen for updates to this value.

There’s also another, really cool feature that I will add to this in a future post.

Download full source.

Found this article helpful? Want a resource of hundreds of similar, how-to tips? I’ve written a book that covers topics like this and more in C# 4. Check out C# 4.0 How-To!

However, I severely underestimated how much I would enjoy this book. I’m about half way through and find it so interesting and compelling a read that I feel I have to write about it.

The thing that really strikes me about this book is how entertaining and readable it is. I am not a big crypto or security guru, so I came to this book largely ignorant of of the topics and history.

The book is a wonderful blend of how encryption works with the history that surrounded its development. For such a seemingly-complex topic, Singh seems to have hit the perfect blend of history and instruction. Starting with the rudimentary Caesarian ciphers (basically, letter substitution) he builds up the techniques in the millenia-old one-upsmanship game between those who encipher and those who attempt to decipher. He starts with frequency analysis and history progresses he builds upon the previous techniques in explaining ever-more sophisticated attacks.

Surrounding this technical (yet still easy to understand) instruction is a fairly thorough narration of the history where these ciphers played a crucial role, from ancient Egypt, Julius Caesar, Mary Queen of Scots’ plot against Queen Elizabeth I, to legends of buried treasure protected by unbreakable ciphers, to the formidable German Enigma machine–

And let me be clear—he will teach you exactly how Enigma worked! It’s not that complicated, once you understand the principles that came before it.

Similarly, he explains how first the Polish and then the British cracked the Enigma as it evolved from the 1930’s to the end of the war, the mistakes the Germans made, and the things that, for example, the German Navy did to increase the security of it so that it became essentially unbreakable without external help (i.e., finding a codebook).

He discusses the Navajo code talkers (there is more to it than simply speaking an obscure language!), public key security, and finally quantum computing.

If you enjoy computer security topics, history, or just like to geek out, this is a great book to read.

Coincidentally, Simon Singh is also at the center of an unfortunate controversy in the UK surrounding some (I believe justified) comments he made about the British Chiropractic Association’s practices of encouraging procedures that could be considered unsafe. Rather than defend the practices with facts, they have decided to sue him for libel (the UK is infamous for having draconian libel laws that strongly favor accusers). You can learn more at his website.

You can also read a thorough explanation of the events at the Bad Astronomy blog.

It took maybe 6 hours of work and is about 3.4ft (1m) wide.

Feel free to leave comments at flickr, or check it out at my other LEGO posting sites (there are a couple of other shots of it):

• flickr
• Brickshelf
• MOCPages

• How to use P/LINQ (new in .Net 4!)
• Override Equals and implement IEquatable<T> correctly
• Enforce coding contracts (new in .Net 4!)
• Convert numbers to strings in arbitrary bases
• Various ways of rounding, including “snapping” to specific intervals.
• Dynamic discovery of WCF services
• Make your Silverlight 3 application run out-of-the-browser
• Speed up array access
• Easily split work among multiple processors
• Localize WinForms, WPF, ASP.Net, and Silverlight apps

…and hundreds of other topics, covering everything from the basics of C# to WPF, ASP.Net, interaction with the operating system, common application patterns and more. I cover all the new stuff that’s in both the C# language and the .Net 4 framework classes, as well as existing functionality.

Each topic begins with a brief description of when/where/why you would need to use the technique, followed by a brief explanation and source code.

I often just want a reference I can quickly dive into to remind me of how something is done. This book is my attempt to put in writing what I find valuable, both when I was learning C# and now when I just need to locate a sample quickly.

• C# 4.0 How-To at Amazon
• C# 4.0 How-To at Barnes and Noble

Over the next few months I’ll talk more about what’s in the book, and hopefully get back into blogging more programming topics.

The convention has more space than ever this year: 35,000 square feet.

The public hours are Saturday and Sunday, 11am-3pm. It’s only $7 per person (or max of $20 per family) and you don’t want to miss the amazing models that will be there.

I finally logged back into my flickr account and uploaded some recent photos from an evening trip to Mercer Island. It was around sunset, the light was beautiful, and I had about two hours to myself to just shoot what I could.

This hand was part of many holding a chain along some docks. The sunset was truly beautiful, but it was difficult to find a decent vantage point., given the people at the beach and the many trees. For more photos, check out my flickr stream.

I’m sure there are hundreds of places within a few minutes’ drive of here that have wonderful photo opportunities. It’s just a matter of taking the time to find them. I recently picked up the 18-200 VR lens for my D80 and absolutely love it. Also got the 50mm f/1.8Dthat is also wonderful.

I’ll probably be posting more pictures on this blog, just to share something.

It’s about 38” long. I have no idea how many pieces—many thousands because every surface is tiled over. The flaps and rudder move and the cargo bay opens up to reveal a detailed interior.

You can see it on BrickShelf or MOCPages.

I’ve started thinking about my next model, but haven’t done anything beyond prototyping. I’ve got other projects at the moment, so it will probably be a long time before it’s done.

If you see yourself in any of these, I’ll e-mail you what I have for no charge. I won’t do any processing on them, other than what I already have, however.

Gallery

I kissed Google goodbye more than a year ago and haven’t looked back. I think once people start using Bing, they’re going to do the same.

Answer Suggestions for IE8

IE8 is awesome, so go get it. Live Search has these things called Instant Answers where it can respond with succinct answers to your question, rather than just web pages that may have the answer. Good examples are weather and numeric conversions—you just want to know the answers, not necessarily follow links to find it.

You get normal search suggestions of course, but the cool thing is that the display of the instant answers is built right into IE8. You can type into the search box and have the answers returned right in the drop down as you type. Here are some samples:

Weather: Solve math equations:

There are a whole lot more kinds of answers. Maybe someday I’ll detail them.

Live Search Suggestions for Firefox

Firefox users haven’t been left out either. While there isn’t a full instant answers integration, Firefox does support search suggestions. You can download the plugin from the Firefox plugin directory.

Live Search for Windows Mobile

This is something I think really needs more publicity. I have a Samsung Saga i770, which I love. One of the first things I put on it was Live Search Mobile.

First of all, this thing has had speech recognition built-in since way before Google’s similar tools.

It can easily find directions, gas prices, movies, traffics, maps, local businesses (by categories), and general web info. I use this app all the time.

There is custom software you can install for both Windows Mobile and Blackberry. It will work on the web for any other mobile phone that can get on the Internet.

And, by the way, it supports auto-suggest as well.

On your phone, you can go to wls.live.com to get it.

Related links:

• Instant Answers in your IE8 Search box [Live Search blog]
• Live Search autosuggestions come to Firefox [Live Search blog]
• Live Search Mobile site

From everything I’ve read, people who have suffered through the WPF learning curve have this to say, more or less:

yeah, it was really tough going for a few months. But now I can create awesome apps in a fraction of the time it would take with older technologies.

So with that in mind, I really do want to learn WPF. I have a number of C# references, weighty tomes that bend my shelves, but the main book I use is Programming WPFby Chris Sells and Ian Griffiths. I really like this book—it goes in deep. However, I realized that reading through it cover to cover and doing all the sample apps wasn’t going to work—it gets boring, no matter how good the book is. So here is my recommendation on how to learn WPF (and it probably applies to any programming technology):

1. Start reading the book, do the code, type stuff in, copy it, tweak it. Do this for as long as you can.
2. Once step 1 becomes boring, STOP. It is not productive to force yourself through the whole thing like this.
3. Find a sample project in your target technology. I used Family.Show. There are plenty out there.
4. Think of a project YOU find interesting that would be good in [WPF|other]. Start doing this. Even if you don’t know where to start at all.
5. While getting started, every step will be a challenge. Figure it out step-by-step, going back to the book and online resources.

You might be tempted to skip steps 1-2. I think this is a bad idea. You need at least some foundational understanding. Only when you can’t take it any more and you’re in danger of quitting, move on.

This has worked well for me in learning WPF. I decided to implement a game (if it ever gets into a polished state, I’ll share it).

Don’t underestimate the challenges in step 4, though. I had to think about how to even start, going back to the book numerous times, reading large sections. I looked up articles online about patterns and WPF, user controls, and more. Many seemingly-small steps in just displaying windows took hours to figure out. Figuring out data binding (really figuring it out in the context of my app) took hours. The point of doing your own project isn’t because it’s easier than following the book—it’s because it’s fun and you have more motivation to learn.

• Instead of a critical section, InterlockedIncrement/Decrement is used.
• The sample driver program now demos using multiple threads using the CpuUsage class to show thread safety.

Download the C++ and C# projects that accompany this article.

Just to make it clear, there is no API called GetProcessCpuPercentage(). To find out the percentage, we can use some other, real APIs and do some calculations. Before getting to the equation and code, let’s discuss the different types of time available.

There are four types of time:

1. Wall time – The actual, real-world progression of time as measured by you on your watch.
2. Kernel time – The amount of time spent in kernel mode (protected, high-order mode of operation)
3. User time – the amount of time spent in user-mode (often by the process itself)
4. Idle time – nothing going on at all

Kernel, User, and Idle sum to total time, which is approximately wall-time.

Each process spends some time in kernel mode and some time in user mode. We just need to compare the time spent by a process to the time spent by all processes on the computer, since the last time we made such a measurement. It is important to note that we do NOT take into account the idle time.

Thus, the equation is

There are two APIs that are useful:

• GetProcessTimes – Get times for a specific process
• GetSystemTimes – Get total times for the entire system (all CPUs)

The times reported are absolute, so what we are actually interested is in the difference between the current times and those from a previous run.

Armed with this information, we can calculate the CPU usage for the current process (or any arbitrary process, for that matter).

Let’s do it first in C++ to demonstrate usage of the APIs.

CPU Usage Percentage in C++

Here’s the header file:

   1: #pragma once

   2: #include <windows.h>

   3:  

   4: class CpuUsage

   5: {

   6: public:

   7:     CpuUsage(void);

   8:     

   9:     short  GetUsage();

  10: private:

  11:     ULONGLONG SubtractTimes(const FILETIME& ftA, const FILETIME& ftB);

  12:     bool EnoughTimePassed();

  13:     inline bool IsFirstRun() const { return (m_dwLastRun == 0); }

  14:     

  15:     //system total times

  16:     FILETIME m_ftPrevSysKernel;

  17:     FILETIME m_ftPrevSysUser;

  18:  

  19:     //process times

  20:     FILETIME m_ftPrevProcKernel;

  21:     FILETIME m_ftPrevProcUser;

  22:  

  23:     short m_nCpuUsage;

  24:     ULONGLONG m_dwLastRun;

  25:     

  26:     volatile LONG m_lRunCount;

  27: };

The GetUsage() method is where the work occurs. The other methods are to help in the calculations. The critical section run count enables the code to be called in a multi-threaded environment without problems. I also prevent the code from being called more often than every 250ms. Here is the complete implementation:

   1: #include "StdAfx.h"

   2: #include <windows.h>

   3: #include "CpuUsage.h"

   4:  

   5: CpuUsage::CpuUsage(void)

   6: :m_nCpuUsage(-1)

   7: ,m_dwLastRun(0)

   8: ,m_lRunCount(0)

   9: {

  10:     ZeroMemory(&m_ftPrevSysKernel, sizeof(FILETIME));

  11:     ZeroMemory(&m_ftPrevSysUser, sizeof(FILETIME));

  12:  

  13:     ZeroMemory(&m_ftPrevProcKernel, sizeof(FILETIME));

  14:     ZeroMemory(&m_ftPrevProcUser, sizeof(FILETIME));

  15:  

  16: }

  17:  

  18:  

  19: /**********************************************

  20: * CpuUsage::GetUsage

  21: * returns the percent of the CPU that this process

  22: * has used since the last time the method was called.

  23: * If there is not enough information, -1 is returned.

  24: * If the method is recalled to quickly, the previous value

  25: * is returned.

  26: ***********************************************/

  27: short CpuUsage::GetUsage()

  28: {

  29:     //create a local copy to protect against race conditions in setting the 

  30:     //member variable

  31:     short nCpuCopy = m_nCpuUsage;

  32:     if (::InterlockedIncrement(&m_lRunCount) == 1)

  33:     {

  34:         /*

  35:         If this is called too often, the measurement itself will greatly 

  36:         affect the results.

  37:         */

  38:  

  39:         if (!EnoughTimePassed())

  40:         {

  41:             ::InterlockedDecrement(&m_lRunCount);

  42:             return nCpuCopy;

  43:         }

  44:  

  45:         FILETIME ftSysIdle, ftSysKernel, ftSysUser;

  46:         FILETIME ftProcCreation, ftProcExit, ftProcKernel, ftProcUser;

  47:  

  48:         if (!GetSystemTimes(&ftSysIdle, &ftSysKernel, &ftSysUser) ||

  49:             !GetProcessTimes(GetCurrentProcess(), &ftProcCreation, 

  50:                 &ftProcExit, &ftProcKernel, &ftProcUser))

  51:         {

  52:             ::InterlockedDecrement(&m_lRunCount);

  53:             return nCpuCopy;

  54:         }

  55:  

  56:         if (!IsFirstRun())

  57:         {

  58:             /*

  59:             CPU usage is calculated by getting the total amount of time 

  60:             the system has operated since the last measurement 

  61:             (made up of kernel + user) and the total

  62:             amount of time the process has run (kernel + user).

  63:             */

  64:             ULONGLONG ftSysKernelDiff = 

  65:                 SubtractTimes(ftSysKernel, m_ftPrevSysKernel);

  66:             ULONGLONG ftSysUserDiff = 

  67:                 SubtractTimes(ftSysUser, m_ftPrevSysUser);

  68:  

  69:             ULONGLONG ftProcKernelDiff = 

  70:                 SubtractTimes(ftProcKernel, m_ftPrevProcKernel);

  71:             ULONGLONG ftProcUserDiff = 

  72:             SubtractTimes(ftProcUser, m_ftPrevProcUser);

  73:  

  74:             ULONGLONG nTotalSys =  ftSysKernelDiff + ftSysUserDiff;

  75:             ULONGLONG nTotalProc = ftProcKernelDiff + ftProcUserDiff;

  76:  

  77:             if (nTotalSys > 0)

  78:             {

  79:                 m_nCpuUsage = (short)((100.0 * nTotalProc) / nTotalSys);

  80:             }

  81:         }

  82:         

  83:         m_ftPrevSysKernel = ftSysKernel;

  84:         m_ftPrevSysUser = ftSysUser;

  85:         m_ftPrevProcKernel = ftProcKernel;

  86:         m_ftPrevProcUser = ftProcUser;

  87:         

  88:         m_dwLastRun = GetTickCount64();

  89:  

  90:         nCpuCopy = m_nCpuUsage;

  91:     }

  92:     

  93:     ::InterlockedDecrement(&m_lRunCount);

  94:  

  95:     return nCpuCopy;

  96: }

  97:  

  98: ULONGLONG CpuUsage::SubtractTimes(const FILETIME& ftA, const FILETIME& ftB)

  99: {

 100:     LARGE_INTEGER a, b;

 101:     a.LowPart = ftA.dwLowDateTime;

 102:     a.HighPart = ftA.dwHighDateTime;

 103:  

 104:     b.LowPart = ftB.dwLowDateTime;

 105:     b.HighPart = ftB.dwHighDateTime;

 106:  

 107:     return a.QuadPart - b.QuadPart;

 108: }

 109:  

 110: bool CpuUsage::EnoughTimePassed()

 111: {

 112:     const int minElapsedMS = 250;//milliseconds

 113:  

 114:     ULONGLONG dwCurrentTickCount = GetTickCount64();

 115:     return (dwCurrentTickCount - m_dwLastRun) > minElapsedMS; 

 116: }

In order to test this, here is a simple program that starts two threads that run an infinite loop, eating the processor. On a dual-core system, this process will take roughly 85-95% of the CPU. I also start two threads to access the usage object and poll the CPU usage in order to demonstrate the thread safety of the object.

   1: // CpuUsageCpp.cpp : Defines the entry point for the console application.

   2: //

   3:  

   4: #include "stdafx.h"

   5: #include <windows.h>

   6: #include "CpuUsage.h"

   7:  

   8: DWORD WINAPI EatItThreadProc(LPVOID lpParam);

   9: DWORD WINAPI WatchItThreadProc(LPVOID lpParam);

  10:  

  11: CpuUsage usage;

  12:  

  13: int _tmain(int argc, _TCHAR* argv[])

  14: {

  15:     //start threads to eat the processor

  16:     CreateThread(NULL, 0, EatItThreadProc, NULL, 0, NULL);

  17:     CreateThread(NULL, 0, EatItThreadProc, NULL, 0, NULL);

  18:  

  19:     //start threads to watch the processor (to test thread-safety)

  20:     CreateThread(NULL, 0, WatchItThreadProc, NULL, 0, NULL);

  21:     CreateThread(NULL, 0, WatchItThreadProc, NULL, 0, NULL);

  22:     

  23:     while (true)

  24:     {

  25:         Sleep(1000);

  26:     }

  27:  

  28:     return 0;

  29: }

  30:  

  31:  

  32: DWORD WINAPI WatchItThreadProc(LPVOID lpParam)

  33: {

  34:     while (true)

  35:     {

  36:         short cpuUsage = usage.GetUsage();

  37:  

  38:         printf("Thread id %d: %d%% cpu usage\n", ::GetCurrentThreadId(), cpuUsage);

  39:         Sleep(1000);

  40:     }

  41: }

  42:  

  43: DWORD WINAPI EatItThreadProc(LPVOID lpParam)

  44: {

  45:     ULONGLONG accum = 0;

  46:     while (true)

  47:     {

  48:         accum++;

  49:     }

  50:  

  51:     printf("%64d\n", accum);

  52: }

C# Version

In C#, The System.Diagnostics.Process can give us the time information for a specific process. However, we still need the Win32 API call for getting the total system times (GetSystemTimes). The Process class reports times in TimeSpans, not FILETIME, so our class is modified accordingly.

   1: using System;using System.Collections.Generic;

   2: using System.Linq;

   3: using System.Text;

   4: using System.Runtime.InteropServices;

   5: using ComTypes = System.Runtime.InteropServices.ComTypes;

   6: using System.Threading;

   7: using System.Diagnostics;

   8:  

   9: namespace CpuUsageCs

  10: {

  11:     class CpuUsage

  12:     {

  13:         [DllImport("kernel32.dll", SetLastError = true)]

  14:         static extern bool GetSystemTimes(

  15:                     out ComTypes.FILETIME lpIdleTime,

  16:                     out ComTypes.FILETIME lpKernelTime,

  17:                     out ComTypes.FILETIME lpUserTime

  18:                     );

  19:  

  20:         ComTypes.FILETIME _prevSysKernel;

  21:         ComTypes.FILETIME _prevSysUser;

  22:  

  23:         TimeSpan _prevProcTotal;

  24:         

  25:         Int16 _cpuUsage;

  26:         DateTime _lastRun;

  27:         long _runCount;

  28:  

  29:         public CpuUsage()

  30:         {

  31:             _cpuUsage = -1;

  32:             _lastRun = DateTime.MinValue;

  33:             _prevSysUser.dwHighDateTime = _prevSysUser.dwLowDateTime = 0;

  34:             _prevSysKernel.dwHighDateTime = _prevSysKernel.dwLowDateTime = 0;

  35:             _prevProcTotal = TimeSpan.MinValue;

  36:             _runCount = 0;

  37:         }

  38:  

  39:         public short GetUsage()

  40:         {

  41:             short cpuCopy = _cpuUsage;

  42:             if (Interlocked.Increment(ref _runCount) == 1)

  43:             {

  44:                 if (!EnoughTimePassed)

  45:                 {

  46:                     Interlocked.Decrement(ref _runCount);

  47:                     return cpuCopy;

  48:                 }

  49:  

  50:                 ComTypes.FILETIME sysIdle, sysKernel, sysUser;

  51:                 TimeSpan procTime;

  52:  

  53:                 Process process = Process.GetCurrentProcess();

  54:                 procTime = process.TotalProcessorTime;

  55:  

  56:                 if (!GetSystemTimes(out sysIdle, out sysKernel, out sysUser))

  57:                 {

  58:                     Interlocked.Decrement(ref _runCount);

  59:                     return cpuCopy;

  60:                 }

  61:  

  62:                 if (!IsFirstRun)

  63:                 {

  64:                     UInt64 sysKernelDiff = 

  65:                         SubtractTimes(sysKernel, _prevSysKernel);

  66:                     UInt64 sysUserDiff = 

  67:                         SubtractTimes(sysUser, _prevSysUser);

  68:  

  69:                     UInt64 sysTotal = sysKernelDiff + sysUserDiff;

  70:  

  71:                     Int64 procTotal = procTime.Ticks - _prevProcTotal.Ticks;

  72:  

  73:                     if (sysTotal > 0)

  74:                     {

  75:                         _cpuUsage = (short)((100.0 * procTotal) / sysTotal);

  76:                     }

  77:                 }

  78:  

  79:                 _prevProcTotal = procTime;

  80:                 _prevSysKernel = sysKernel;

  81:                 _prevSysUser = sysUser;

  82:  

  83:                 _lastRun = DateTime.Now;

  84:  

  85:                 cpuCopy = _cpuUsage;

  86:             }

  87:             Interlocked.Decrement(ref _runCount);

  88:  

  89:             return cpuCopy;

  90:                 

  91:         }

  92:  

  93:         private UInt64 SubtractTimes(ComTypes.FILETIME a, ComTypes.FILETIME b)

  94:         {

  95:             UInt64 aInt = 

  96:             ((UInt64)(a.dwHighDateTime << 32)) | (UInt64)a.dwLowDateTime;

  97:             UInt64 bInt = 

  98:             ((UInt64)(b.dwHighDateTime << 32)) | (UInt64)b.dwLowDateTime;

  99:  

 100:             return aInt - bInt;

 101:         }

 102:  

 103:         private bool EnoughTimePassed

 104:         {

 105:             get

 106:             {

 107:                 const int minimumElapsedMS = 250;

 108:                 TimeSpan sinceLast = DateTime.Now - _lastRun;

 109:                 return sinceLast.TotalMilliseconds > minimumElapsedMS;

 110:             }

 111:         }

 112:  

 113:         private bool IsFirstRun

 114:         {

 115:             get

 116:             {

 117:                 return (_lastRun == DateTime.MinValue);

 118:             }

 119:         }

 120:     }

 121: }

These classes can now be used wherever you need to monitor the CPU usage of a process.

Notice any improvements to be made? Leave a comment.

Download C++ and C# projects

For my current project, I needed a panel to layout controls vertically. The TableLayoutPanel can be awkward to work with, at least for what I need it to. At first glance, the FlowLayoutPanel looks it won’t work, since it produces something like this:

That’s with changing the FlowDirection to TopDown and putting AutoScroll to true.

But what I want is this:

To achieve this layout, merely set all the following properties on a FlowLayoutPanel:

• AutoScroll = True
• FlowDirection = TopDown
• WrapContents = False

et voilà, Instant stack panel.

With the new Webmaster Tools, you can now see which pages on your site are infected with malware (aka drive-by downloads). The links are clearly highlighted and disabled so that you won’t accidentally click on them.

Not only that, but you can also see what pages that your site links to are infected with malware. This is great if your site allows any user-generated content and it’s possible that some link spam has made it on.

In addition to these improvements in Webmaster Tools, the general Live Search engine is using the same malware detection to notify users of bad pages in the general search results. To see this, click on the link as if to visit it and you’ll get a pop-up instead.

If you run your own site, get signed up in Webmaster Tools and make sure you’re not contributing to the malware problem. If you do find that your site has malware on it, once you’ve removed it you can request that your site be reanalyzed.

For more info, check out these other blogs and articles:

• Live Search Webmaster Center Fall Update [Webmaster Center blog]
• Webmaster tools now sniffing for malware [Live Search blog]
• Microsoft’s Live launches malware detection service for webmasters [ZDNet blogs] (though the author incorrectly assumes that Live Search itself doesn’t offer this feature)
• Link to search results for articles about this

Here’s a brief run-down of my initial experience with it.

Installation

There is no installation file—everything is packaged into a zip. After running, I was greeted by a project selection screen, in which I created a new project and added some assemblies.

Analysis

Once you have all the assemblies you want to analyze selected, you can run the analysis, which generates both an HTML report with graphics, and an interactive report that you can use to drill down into almost any detail of your code. Indeed, it’s almost overwhelming the amount of detail present in this tool.

One graph you see almost immediately is Abstractness Vs. Instability.

This is a good high-level overview of your entire project at the assembly level. Basically, what this means is that assemblies that are too abstract and unstable are potentially useless and should be culled, while assemblies that are concrete and stable can be hard to maintain. Instability is defined in the help docs in terms of coupling (internal and external), while abstractness is the ratio of abstract types to total types in an assembly.

This is followed by the dependency graph:

After these graphics come lots of reports that dig into your code for all sorts of conditions.

For example, the first one in my report was “Quick summary of methods to refactor".” That seems pretty vague, until you learn how they determine this. All the reports in NDepend are built off of a SQL-like query language called CQL (Code Query Language). The syntax for this is extremely easy. The query and result for this report are:

With very little work on my part, I instantly have a checklist of items I need to look at to improve code quality and maintainability.

There are tons of other reports: methods that are too complex, methods that are poorly commented, have too many parameters, to many local variables, or classes with too many methods, etc. And of course, you can create your own (which I demonstrate below).

Interactive Visualization

All of these reports are put into the HTML report. But as I said, you can use the interactive visualizer to drill down further into your code.

The first thing you’re likely to see is a group of boxes looking like this:

These boxes show the relative sizes of your code from the assembly level down to the methods. Holding the mouse over a box will bring up more information about the method. You can also change the metric you’re measuring by—say to cyclomatic complexity.

Another view, perhaps the most useful of all is the CQL Queries view. In this, you can see the results from all of hundreds of code queries, as well as create your own. For instance, I can see all the types with poor cohesion in my codebase:

In this view, the CQL queries are selected in the bottom-right, and the results show up on the left. The metrics view highlights the affected methods.

Creating a query

Early in the development of my project, I named quite a few classes starting with a LB prefix. I’ve changed some of them, but I think there are still a few lying around and I want to change them as well. So I’ll create CQL query to return all the types that begin with “LB.”

   1: // <Name>Types beginning with LB</Name>

   2: WARN IF Count > 0 IN SELECT TYPES WHERE 

   3:  NameLike "LB" AND     

   4:  !IsGeneratedByCompiler AND 

   5:  !IsInFrameworkAssembly     

That’s it! You can see the results to the right. It’s ridiculously easy to create your own queries to examine nearly any aspect of your code. And that’s if the hundreds of included queries don’t do it for you. In many ways, the queries are similar to the analysis FxCop does, but I think CQL seems generally more powerful (while lacking some of the cool things FxCop has).

VS and Reflector Add-ins

NDepend has a couple of extras that enable integration of Visual Studio (2005 and 2008) and NDepend and Reflector. When you right-click on an item in VS, you will have some additional options available:

Clicking on the submenu gives you options to directly run queries in NDepend. Very cool stuff.

Summary and where to get more info

If you are at all interested in code metrics, and how good your code is behaving, how maintainable it is, you need this tool. It’s now going to be a standard part of my toolbox for evaluating the quality of my code and what parts need attention.

If you’re using NDepend for personal and non-commercial reasons, you can download it for free. It doesn’t have all the features, but it has more than enough. Professional use does require a license.

One of the things I was particularly impressed with was the amount of help content available. There are tons of tutorials for every part of the program.

I’m going to keep playing with this and I’m sure I’ll mention some more things as I discover them. For now, NDepend is very cool—it’s actually fun to play with, and it gives you good information for what to work on.

Links:

• NDepend homepage
• NDepend metrics explanation