Because of this, you occasionally have a rather urgent need to roll back everyone to the last working version, and this turns out to be rather easy.

In the publish’s output folder you will see a file called “<application name>.application”. This is the ClickOnce Application Deployment Manifest and contains a load of details about the application and in particular the version to install and where to find it.

You will also see an “Application Files” folder which will contain a folder for each version of your application deployed so far. To revert all of your users to a previous version, simply copy the “<application name>.application” file from the relevant version subdirectory over the one in the root, then either point your users at your ClickOnce location or if you had the application set to check for and apply updates automatically just tell them to restart. The application will detect that there is a “newer” version (even if that version is in fact older) and allow the user to install it.

The original TextBox control would automatically set the caret (cursor) position to the end of the text and use ScrollToCaret() to ensure the last line was always visible after dynamically adding content. This doesn’t quite work the same when called on a RichTextBox as it appears to scroll until just the very top of the caret is visible, resulting in at best a few pixels of the last line’s text visible.

Quite a bit of googling of the problem reveals lots of discussion but not much in the way of a suggested solution.

Fortunately, user32.dll provides calls we can use to set the scroll position and we can access these unmanaged functions through P/Invoke as follows:

[StructLayout(LayoutKind.Sequential)]
public class POINT
{
    public int x;
    public int y;

    public POINT()
    {
    }

    public POINT(int x, int y)
    {
        this.x = x;
        this.y = y;
    }
}

const int SB_VERT = 1;
const int EM_SETSCROLLPOS = 0x0400 + 222;

[DllImport("user32", CharSet = CharSet.Auto)]
static extern bool GetScrollRange(IntPtr hWnd, int nBar, out int lpMinPos, out int lpMaxPos);

[DllImport("user32", CharSet = CharSet.Auto)]
static extern IntPtr SendMessage(IntPtr hWnd, int msg, int wParam, POINT lParam)

Then, when you want to set the scroll position (“control” is your RichTextBox instance):

int min, max;
GetScrollRange(control.Handle, SB_VERT, out min, out max);
SendMessage(control.Handle, EM_SETSCROLLPOS, 0, new POINT(0, max - control.Height));

This is the first of four exams I’m aiming to complete in order to become a Microsoft Certified Professional Developer.

static void Main(string[] args)
{
...
}

with a useful string array of arguments like you do in a regular C# console app, so how do you access them?

In a default WPF application, the entry point to the program is the Application object. This object has an event Startup which is fired, unsurprisingly on startup of your app and contains StartupEventArgs. You can query this object to get to your arguments as follows:

public partial class App : Application
 {
   ///
   /// A static string array containing our start-up command line arguments
   ///
   public static string[] Args;

   protected override void OnStartup(StartupEventArgs e)
   {
       Args = e.Args;
       base.OnStartup(e);
   }
}

Store them in a static member and then you can access them elsewhere in your application as Apps.Args.

So far, so good. But what happens if you actually need some arguments to run, and so want to check and fail gracefully if they don’t exist? I found that if I checked in my OnStartup handler, I still couldn’t halt the start-up of my application on error.

Instead, I added a Loaded event handler to my MainWindow. This is fired once the Application and MainWindow have been loaded so I know I my static Args member will have been set by the time it is fired. I can do all the validation I want on my argument array and decide whether to continue execution or stop and provide an error to the user.

public MainWindow()
{
     InitializeComponent();

     // Make sure the command line arguments have been processed
     this.Loaded += new RoutedEventHandler(MainWindow_Loaded);
}

void MainWindow_Loaded(object sender, RoutedEventArgs e)
{
    if (App.Args.Length == 1)
    {
        // everything is good, do stuff
    }
    else
    {
        // ERROR!!!
        MessageBox.Show("Not enough arguments!");
        App.Current.Shutdown();
     }
}

The answer is in one of the attributes of Binding called “UpdateSourceTrigger” which has the following options:

• LostFocus – Update bound property when the control loses focus (TextBox default).
• PropertyChanged – Update bound property in real-time.
• Explicit - Update bound property when UpdateSource() is called

It is this last setting which allows us to delay updating our bound property until we tell it to.

Let’s say we have a UserControl containing a TextBox, ‘MyTextBox’ which is bound to some Dependency Property and two buttons, ‘OK’ and ‘Cancel’. Depending on how you hook your buttons up (with RoutedCommands or click handlers (eugh!)) the ‘OK’ button’s code looks like this:

BindingExpression be = MyTextBox.GetBindingExpression(TextBox.TextProperty);
if (be!=null) be.UpdateSource();

The ‘Cancel’ button’s code does the reverse:

BindingExpression be = MyTextBox.GetBindingExpression(TextBox.TextProperty);
if (be!=null) be.UpdateTarget();

Et voila! Your dependency property will now only update when you want it to.

Following on from my previous post, where I explained how to create a ControlTemplate to style a TextBox in WPF, I’ve got an object, TextEntryBox, which dervies from a TextBox (it provides some custom event handlers when text is entered, but to all intents and purposes, it’s a regular TextBox).

I wanted to style my TextEntryBox, this time including a button within my ControlTemplate (this will eventually toggle an on-screen keyboard pop-up, but that’s another blog post!). I came up with this:

All’s well and good, until I want to try and handle the Click event for that button within my TextEntryBox class. Even Matthew MacDonald’s “Pro WPF in C# 2008″ which has proved a lifesaver for all things WPF since I’ve been working with this technology only had the following words of wisdom;

“You can’t attach event handlers in the control template. Instead, you’ll need to give your elements recognizable names and attach event handlers to them programmatically in the control constructor”

But whatever I tried I couldn’t access the event in my constructor, until I remembered the seperation between the visual and logical trees in WPF.

The template is applied at runtime, and so elements contained within it it are part of the visual tree. My class, and therefore my class’ constructor is executed within the logical tree, so I needed to attach my event handler after the template had been applied. You can do this by overriding OnApplyTemplate in your class, obtain the template that’s being applied, and then you have access to the named button’s events, like this:

public override void OnApplyTemplate()
{
    DependencyObject d = GetTemplateChild("PART_KeyboardPopupButton");
    if (d != null)
    {
        (d as Button).Click += new RoutedEventHandler(KeyboardPopupButton_Click);
    }

    base.OnApplyTemplate();
}

Note the null check, as someone could have applied a completely different template to the object.

Q: If you want to create a ControlTemplate to provide a custom style for a TextBox, how do you specify where the text goes when it’s used in WPF?

A: The answer was hidden in the depths of the MSDN Documentation. You have to include a <ScrollViewer> within your ControlTemplate with an x:Name value of “PART_ContentHost”.

Here’s a noddy example:

This was screaming out to be screen-scraped and developer Tyler Hall has stepped up to the plate with Sosumi – A MobileMe Scraper. Using Sosumi is literally a case of including the class in your PHP, instantiating it with your MobileMe username and password and calling its locate method which returns an object containing the current latitude, longitude and result accuracy, it’s as simple as that!

At the moment I’ve got a cron job on my server hitting this every five minutes and logging to a database. If the data hasn’t changed since the last logged entry, a counter is incremented and timestamp_last is set. A very simple Google Map displays these locations as points on a map but I’ve got loads of ideas of stuff to play about with, such as:

• Plot the reported accuracy of each location as a circle on the map, more Google Maps fiddling.
• Modify which points are mapped based on time and date ranges through the webpage, some PHP + AJAX experience.
• Store locations of common places I visit, then for each point logged (taking into account the accuracy range) I can programatically work out where I am.  Could then auto-generate “Richard is at work”, “Richard is at home”, etc… reports for my blog/twitter/facebook etc… =).

Bit sad I know, but it seemed too good for a total sync-monkey like myself and I’ll never pass up an opportunity, however contrived, for a PHP mash-up!

I’ve been making notes throughout the whole experience and so plan to post them shortly with the aim of helping anyone else who finds themselves in a similar situation and needs to get up to speed with Windows network driver development (NDIS 5.1). I am by no means an expert but want to share what I’ve learnt so far.

The null-coalescing operator (to call it by its more catchy name) allows you to provide an alternative value in the event that the reference type object (or nullable value type) you are trying to access evaluates to null. So instead of having to do something like this:

            int? myNullableInt = null;
            int myInt;

            if (myNullableInt == null)
            {
                myInt = -1;
            }
            else
            {
                myInt = (int)myNullableInt;
            }

You can do this in-line:

myInt = myNullableInt ?? -1;

Apologies for the heavily contrived and quite pointless example, but at least it gets the syntax down and should make it apparent how useful this operator can be when dealing with a mixture of nullable and non-nullable types.