Question

I have my barcode reader programmed to add a prefix and suffix of “,” and otherwise to work just like a keyboard. I have a Windows Form that will be open when barcodes are scanned.

Rather than writing a bunch of KeyDown code, Reactive Extensions seems perfect for this kind of work. What I’d like to do:

• When a comma is pressed, start holding on to key presses (don’t let them be handled by any control on the screen)
• Collect all keys until another comma is pressed or 250ms have gone by.
• If no comma is pressed within 250ms, hand the key presses back to whatever control is active.
• If comma is pressed, do processing on the string value scanned in from the barcode.

How can I use System.Reactive to hold key presses when matching a prefix and suffix for a barcode scanner, process if suffix is matched, but handle key presses normally when the suffix isn’t matched within a time limit?

Answer 1

Someone will come along and probably give a more elegant answer than this. But I found this one challenging.

First things first, this example does not show how to do it for keys on forms. There is sufficient additional complexity there that it bears trying yourself first, or asking another question. It would require a full application to answer all aspects of your question here. Suffice to say that:

1. You can turn KeyEventArgs into an observable that could be used in this framework
2. You can decide to suppress KeyEventArgs that make it into the barcode stream with SuppressKeyPress
3. You can decide to not suppress any KeyEventArgs in the non-barcode stream

The solution as it stands involves defining a function that takes an IObservable<char> and turns it into a GroupedObservable that marks (with a bool) whether the underlying char was inside a ‘barcode’ stream (true) or not (false):

public IObservable<IGroupedObservable<bool, IObservable<char>>> GroupBySurroundingChars(IObservable<char> source, char ends, TimeSpan within)
{
    var result = 
        source.Buffer(() => 
            source.Select(c => {
                if (c == ends) return source.Where(x => x == ends).Amb(Observable.Timer(within).Select(_ => default(char)));
                else           return Observable.Return(default(char));
            }).Concat())
            .GroupBy(buffer => buffer.Count > 2 && buffer[0] == ends && buffer.Last() == ends, buffer => buffer.ToObservable());                        

    return result;
}

What this function is doing is:

1. Starting a buffer with every character
2. If that character wasn’t a comma, return the buffer immediately
3. If that character was a comma, hold the buffer open until another comma is found or 250ms have passed
4. Check if the buffer contains commas at either end (mark as a barcode) or not (mark as no barcode)

And then a full usage example:

var keys1 = "xxx,1234567,xxx,1,xxx".ToCharArray().ToObservable(Scheduler.ThreadPool).Do(_ => Thread.Sleep(100)).Publish().RefCount();
var keys2 = "xxx,1234567,xxx,1,xxx".ToCharArray().ToObservable(Scheduler.ThreadPool).Do(_ => Thread.Sleep(10)).Publish().RefCount();

var result = GroupBySurroundingChars(keys1, ',', TimeSpan.FromMilliseconds(250));

var barcodes = result.Where(x => x.Key);
var others = result.Where(x => !x.Key);

barcodes.Subscribe(groups => groups.Subscribe(x => x.ToList().Dump()));

If you use keys1, the key presses are too slow to find the first barcode, but it finds the second. If you use keys2, the key presses are fast enough to find both barcodes.

In either case, the others stream contains all keys that were not eventually marked as containing barcodes. The barcodes stream can be taken as a character by character stream, or converted into a List with each set of barcodes as I did above.