Therefore, you need to know the size of the data you’re going to serialize. There are a few ways to do this:

1. Measure the position you’re at, write the data, measure the new position, subtract, and that’s your length.
2. If you want to write the length first (which is usually better), you can write a dummy value, such as 0, then writing the data, then backing up in the stream, and writing the real value.
3. If you can’t back up the stream (very possible in some situations, or undesirable in others), you can measure the amount of data before you write. However, now you have to maintain that code in addition to the actual serialization.
4. My solution presented here, avoids having to maintain separate code by writing the data to a null stream which does not write any data, but keeps track of how much data was “written.”

class NullStream : System.IO.Stream
{
    public override bool CanRead { get { return false; } }

    public override bool CanSeek { get { return false; } }

    public override bool CanWrite {get { return true; } }

    public override void Flush() { /*do nothing*/ }

    public override long Length { get { return Position; } }

    private long _position = 0;
    public override long Position
    {
        get
        {
            return _position;
        }
        set
        {
            _position = value;
        }
    }

    public override int Read(byte[] buffer, int offset, int count)
    {
        throw new InvalidOperationException();
    }

    public override void Write(byte[] buffer, int offset, int count)
    {
        Position += count;
    }

    public override long Seek(long offset, System.IO.SeekOrigin origin)
    {
        throw new InvalidOperationException();
    }

    public override void SetLength(long value)
    {
        throw new InvalidOperationException();
    }
}

You can use it like this:

long GetDataSize()
{
    using (NullStream stream = new NullStream())
    {
        if (SaveData(stream))
        {
            return stream.Position;
        }
    }
    return 0;
}

There is a downside to something like this: you’re still essentially doing a lot of the work of serialization. Sure, you’re not writing out the bytes anywhere, but if, say, you need to encode a string as bytes before writing to the stream, that’s still going to happen.

Still, this technique made sense in my case, maybe it will work for you.

Here’s how it’s going to work:

1. Leave a comment on this post describing a project you’d like to build with C# 4.

2. I’ll pick two people from those comments at random.

(Make sure you enter your e-mail address where asked—it won’t be published to the blog, but I need it to contact you.)

I’ll leave the comments open for a while and I’ll update this post with the closing date.

Feel free to share a link to this blog post, tweet it, etc. If I get a lot of responses I may give away more.

Thanks to all those have already bought it!

UPDATE 18 May: I am going to close comments on Saturday morning (22 May) and pick the winners then. Thanks for commenting!

UPDATE 22 May: Comments are closed.

I hope to make this change with no downtime, but who knows who well that will work.

Well, it’s finally out! Amazon no longer lists the book as available for pre-sale, and it should be shipping to purchasers today or tomorrow. If you’re a B&N shopper, you can also order it there, or grab it in stores within a few days.

From the product description:

Real Solutions for C# 4.0 Programmers

Need fast, robust, efficient code solutions for Microsoft C# 4.0? This book delivers exactly what you’re looking for. You’ll find more than 200 solutions, best-practice techniques, and tested code samples for everything from classes to exceptions, networking to XML, LINQ to Silverlight. Completely up-to-date, this book fully reflects major language enhancements introduced with the new C# 4.0 and .NET 4.0. When time is of the essence, turn here first: Get answers you can trust and code you can use, right now!

Beginning with the language essentials and moving on to solving common problems using the .NET Framework, C# 4.0 How-To addresses a wide range of general programming problems and algorithms. Along the way is clear, concise coverage of a broad spectrum of C# techniques that will help developers of all levels become more proficient with C# and the most popular .NET tools.

Fast, Reliable, and Easy to Use!

• Write more elegant, efficient, and reusable code
• Take advantage of real-world tips and best-practices advice
• Create more effective classes, interfaces, and types
• Master powerful data handling techniques using collections, serialization, databases, and XML
• Implement more effective user interfaces with both WPF and WinForms
• Construct Web-based and media-rich applications with ASP.NET and Silverlight
• Make the most of delegates, events, and anonymous methods
• Leverage advanced C# features ranging from reflection to asynchronous programming
• Harness the power of regular expressions
• Interact effectively with Windows and underlying hardware
• Master the best reusable patterns for designing complex programs

I’ll be doing a book giveaway at some point as well, once I get my own shipment. Stay tuned!

Get it from Amazon

Get it from Barnes and Noble

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