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:

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.

1. Create a delegate of the function you wish to be able to call:

   public delegate void MyDelegate(int i, string str);
   public class TargetThreadClass
   {
       public TargetThreadClass()
       {
           MyDelegate del = new MyDelegate(this.FuncToExec);
       }
       public void FuncToExec(int i, string str)
       {
          // Do something
      }
   }

2. Within the target thread, create an instance of a Dispatcher object and set it to the thread’s current dispatcher:

   Dispatcher UserDispatcher = Dispatcher.CurrentDispatcher;

   Then pass this dispatcher, along with the delegate into the source thread.

3. Then to call FuncToExec on the target thread, use:

   UserDispatcher.Invoke(del, new object[] { 123, "arg string"});

   Where the first parameter of Invoke is the delegate itself and the second an array of the delegate’s parameters (if any), in this example the delegate takes an int and a string.

I quite frequently want to capture key presses in my apps, and to do this I use Console.ReadKey which returns a nice ConsoleKeyInfo object to tell me what’s just been pressed. The problem is this call blocks until a key has been pressed and sometimes I don’t want to block out the main execution thread or have to create a separate thread *just* to handle the keyboard input.

This is where Console’s KeyAvailable property comes in.  It returns true if there is a key press available in the input stream without blocking allowing you to do something like:

while (true)
{
    if (Console.KeyAvailable)
    {
        ConsoleKeyInfo key = Console.ReadKey(true);
        switch (key.Key)
        {
            case ConsoleKey.F1:
                Console.WriteLine("You pressed F1!");
                break;
            default:
                break;
        }
    }
    // Do something more useful
}

static void Main(string[] args)
{
	// program code...
	// now set the return value to 1
	System.Environment.ExitCode = 1
}

This example returns 1, which can then be picked up by some good ol’ fashioned batch command-goodness. I’m already reminiscing back to my 1000+ line BBS mailer batch file back in 1995!

Also came across this which provides guidance on the special meanings of some exit codes.