After a short hunt online, I found an excellent library that can be used as an alternative, and I built a simple reader with it.  Here are the basic steps to create one yourself:

NOTE: To build and test this example you must use a physical phone rather than the emulator, as you will need access to the camera feed. 

 

Create a new Windows Phone Project in Visual Studio

I used Visual Studio Ultimate, but the Express version that ships with the Windows Phone SDK will do just fine.  Use the basic phone template for this example:

Be sure to select ‘Windows Phone 7.1’ as the target OS:

Update the App Manifest

If you plan to submit a camera-based app to the marketplace, then you must ensure that the WMAppManifest.xaml contains this capability element:

<Capability Name="ID_CAP_ISV_CAMERA"/>

A different element is required for the front-facing camera: ID_HW_FRONTCAMERA

Create the QR Reader Window and Output Area

Inside the content Grid in MainPage.xaml, add a Rectangle and a TextBlock:

 

<!--TitlePanel contains the name of the application and page title-->

<StackPanel x:Name="TitlePanel" Grid.Row="0" Margin="12,17,0,28">

    <TextBlock x:Name="ApplicationTitle" Text="QR SCANNER"

                Style="{StaticResource PhoneTextNormalStyle}"/>

    <TextBlock x:Name="PageTitle" Text="scanner" Margin="9,-7,0,0"

                Style="{StaticResource PhoneTextTitle1Style}"/>

</StackPanel>

<!--ContentPanel - place additional content here-->

<Grid x:Name="ContentPanel" Grid.Row="1" Margin="12,0,12,0">

    <!-- rectangle which acts as the 'camera window' -->

    <Rectangle Height="300" HorizontalAlignment="Left" Margin="82,61,0,0"

                Name="videoRectangle" Stroke="White" StrokeThickness="5"

                VerticalAlignment="Top" Width="300">

        <Rectangle.RenderTransform>

            <RotateTransform x:Name="videoRotateTransform"/>

        </Rectangle.RenderTransform>

        <Rectangle.Fill>

            <VideoBrush x:Name="viewfinderBrush"/>

        </Rectangle.Fill>

    </Rectangle>

    <!-- Textblock which will hold the output of the QR Code -->

    <TextBlock Height="171" HorizontalAlignment="Left" Margin="31,406,0,0"

                Name="resultText" Text="<nothing to display>"

                VerticalAlignment="Top" Width="399" TextWrapping="Wrap"

                TextAlignment="Center" />

</Grid>

 

This should result in a main page like this:

The Rectangle will act as the camera viewer – notice that it has a VideoBrush as its fill;  this will eventually contain the live feed from the camera.  The TextBlock will display the content read from the QR Code.

Directives and Variables

In MainPage.xaml.cs, add a few relevant using statements, such as for the Devices namespace so we can use the PhotoCamera type:

using Microsoft.Devices;

using System.IO;

using System.Windows.Media.Imaging;

Declare some variables inside the main app class:

private PhotoCamera camera;

private bool capturing = false;

   

Handle Navigation

It is recommended practice to initialise and dispose of the camera object when we navigate to and from our page, respectively, so we need to override these methods:

 

protected override void OnNavigatedTo(

           System.Windows.Navigation.NavigationEventArgs e)

{

    if (null == camera)

    {

        camera = new PhotoCamera();

        // filred when the camera is initialised

        camera.Initialized += camera_Initialised;

        // fired when the button is fully pressed

        CameraButtons.ShutterKeyPressed += camera_ButtonFullPress;

        // fired when an image is available.

        camera.CaptureImageAvailable += camera_CaptureImageAvailable;

        // set the VideoBrush source to the camera output

        videoRotateTransform.CenterX = videoRectangle.Width / 2;

        videoRotateTransform.CenterY = videoRectangle.Height / 2;

        videoRotateTransform.Angle = 90;

        viewfinderBrush.SetSource(camera);

    }

    base.OnNavigatedTo(e);

}

// user navigated away from page

protected override void OnNavigatedFrom(

           System.Windows.Navigation.NavigationEventArgs e)

{

    if (camera != null)

    {

        // unhook the event handlers

        CameraButtons.ShutterKeyPressed -= camera_ButtonFullPress;

        camera.CaptureImageAvailable -= camera_CaptureImageAvailable;

        camera.Initialized -= camera_Initialised;

        // dispose of the camera object

        camera.Dispose();

    }

    base.OnNavigatedFrom(e);

}

 

Here the PhotoCamera object is initialised to to use ‘primary’ camera, which is the rear-facing one. If you want to use the front-facing camera in an application, then you can call the alternate constructor like this:

camera = new PhotoCamera(CameraType.FrontFacing);

Add Camera Event Handlers

The event handlers are quite simple and simply initialise some settings and respond to the user taking a picture:

private void camera_Initialised(object sender, CameraOperationCompletedEventArgs e)

{

    // set the camera resolution

    if (e.Succeeded)

    {

        var res = from resolution in camera.AvailableResolutions

                    where resolution.Width == 640

                    select resolution;

        camera.Resolution = res.First();

    }

}

// user has pressed the camera button

private void camera_ButtonFullPress(object sender, EventArgs e)

{

    if (capturing) return;

    capturing = true;

    camera.CaptureImage();

}

We will add the ‘camera_CaptureImageAvailable’ handler later.

 

Download the Barcode Library

The library can be downloaded here:

https://twit88.com/platform/projects/show/mt-barcode

It ships with a sample Windows Phone 7 app, but this doesn’t read the data directly from the camera; instead it uses some hard-coded test images.  It also ships with an example desktop app for generating your own codes.

 

Add the Barcode Library to the Project

In MainPage.xaml.cs, add the following using statement:

 

using MessagingToolkit.Barcode;

 

Add a reference to the Windows Phone 7 version of the library:

 

Decode the QR Code Image

The camera_CaptureImageAvailable event handler is called once we have an image to process. This is where we try to decode any possible QR Code it contains:

private void camera_CaptureImageAvailable(

    object sender, 

    ContentReadyEventArgs e)

{

    capturing = false;

    Stream imageStream = (Stream)e.ImageStream;

    BarcodeDecoder barcodeDecoder = new BarcodeDecoder();

    Dictionary<DecodeOptions, object> decodingOptions = 

                        new Dictionary<DecodeOptions, object>();

    List<BarcodeFormat> possibleFormats = new List<BarcodeFormat>(1);

    Result result;

    Dispatcher.BeginInvoke(() =>

    {

        WriteableBitmap qrImage = new WriteableBitmap(

                                        (int)camera.Resolution.Width, 

                                        (int)camera.Resolution.Height);

        imageStream.Position = 0;

        qrImage.LoadJpeg(imageStream);

        possibleFormats.Add(BarcodeFormat.QRCode);

        decodingOptions.Add(

            DecodeOptions.PossibleFormats, 

            possibleFormats);

        try

        {

            result = barcodeDecoder.Decode(qrImage, decodingOptions);

            resultText.Text = result.Text;

        }

        catch (NotFoundException)

        {

            // this is expected if the image does not contain a valid

            // code, Or is too distorted to read

            resultText.Text = "<nothing to display>";

        }

        catch (Exception ex)

        {

            // something else went wrong, so alert the user

            MessageBox.Show(

                ex.Message, 

                "Error Decoding Image", 

                MessageBoxButton.OK);

        }

    });

}

Compile and Deploy

As mentioned at the top of this post, you will need to deploy the app to a real phone, since the Emulator generates its own test output which is useless in this case.

That’s it.  You should now have a basic QR Reader.  Test it by reading the code below:

Here is an implementation of FizzBuzz that solves the original request to display the ‘numbers’ between 1 and 100:


foreach($i in (1..100))
{
    $out = ""
   
    if($i % 3 -eq 0)
    {
        $out += "Fizz"
    }
   
    if($i % 5 -eq 0)
    {
        $out += "Buzz"
    }
   
    if($out -eq "") {$out = $i}
   
    $out
}

Note the use of the modulus operator (‘%’), which returns the remainder of a division.  If the remainder is zero, then the number being divided (the ‘dividend’) must be an exact multiple of the number doing the dividing (the ‘divisor’).  So, this is an excellent way to check things like ‘is a number odd or even’ (calculate ‘X % 2’ – no remainder it’s even).

Here we use the modulus operator to check the FizzBuzz rules regarding divisibility by 3 or 5.  Although we also have a rule for divisible by 3 and 5, we don’t need to check that condition explicitly as it will show up naturally in the results from the two calculations we already make.

A slightly more compact version, using a switch statement:

    switch ((1..100))
    {
            {$_%15 -eq 0} {"FizzBuzz";continue}
            {$_%3 -eq 0} {"Fizz";continue}
            {$_%5 -eq 0} {"Buzz";continue}
            Default {$_}
    }

This makes use of a lesser-known feature of switch – the ability to supply a scriptblock as the ‘condition’ to match against.  Typically, switch is used to match numbers and simple strings, but it is much more powerful than that; the above is a fairly simple example, but the scriptblock could be much more complex, which the restriction that it return $true or $false, so switch can tell if the match was successful.  In his excellent book, PowerShell in Action, Bruce Payette (co-designer of PowerShell) rates switch as the most powerful feature in PowerShell because of this incredible flexibility.

To count the number of ‘Fizz’, etc between 1 and 1000, a simple modification of the original attempt is required:

1 .. 1000 | foreach{
    $out = ""
   
    if($_ % 3 -eq 0)
    {
        $out += "Fizz"
    }
   
    if($_ % 5 -eq 0)
    {
        $out += "Buzz"
    }
   
    if($out -eq "") {$out = $i}
   
    $out
} | Where-Object {$_ -like "*zz*"} | Group-Object

FizzBuzz is a game often played by schoolchildren as a way to practice their metal arithmetic abilities (or as a game for drunken adults, if you listen to Wikipedia).  The rules we will use are:

• Count from 1 to 100, displaying the numbers as you go, however ...
• Any number divisible by 3 should be replaced by the word “Fizz”
• Any number divisible by 5 should be replaced by the word “Buzz”
• Any number divisible by both 3 and 5 should be replaced by the word “FizzBuzz”

The first 20 “numbers” would then be:

1, 2, Fizz, 4, Buzz, Fizz, 7, 8, Fizz, Buzz, 11, Fizz, 13, 14, FizzBuzz, 16, 17, Fizz, 19, Buzz

This is a deceptively simple task that I sometimes include as a challenge in my PowerShell workshops.  While I just use it as an unusual and fun way to learn about scripting (specifically looping and decision making), some recruiters actually use it as a screening tool when hiring developers!

Once you have your solution, modify it to count the number of “Fizz”, “Buzz” and “FizzBuzz” entries between 1 and 1000.

Have fun and get some hints here if you need them.

Get-WmiObject –Class Win32_BIOS |
     Format-Table Description, ReleaseDate -AutoSize

Description          ReleaseDate             
-----------          -----------             
Phoenix ROM BIOS A14 20090511000000.000000+000

While you can read the dates (they are in “year-month-day-hour-minute-second” format), they are difficult to parse quickly, especially if you have a long table filled with them.

Fortunately, PowerShell helps you out by adding the ConvertToDateTime() method to each WMI object.  This allows you to do things like this:

$os = Get-WmiObject –Class Win32_OperatingSystem
$os.ConvertToDateTime($os.InstallDate)

10 May 2011 14:54:26

It is easy to include this in a table using a calculated property:

$Lease = @{Label=“Lease Expires”;  
Expression={$_.ConvertToDateTime($_.DHCPLeaseExpires)}}

Get-WmiObject -Class Win32_NetworkAdapterConfiguration `
    -Filter "NOT DHCPLeaseExpires = NULL" |
         Format-Table Description, $Lease –Autosize

Description                 Lease Expires      
-----------                 ------------      
Intel(R) WiFi Link 5300 AGN 04/08/2011 18:49:09

Strictly speaking the hashtable could be defined in-line with the Format-Table cmdlet, but I’ve put it on its own line for readability.

OK, first the stats:

1. There are 86 solutions if you allow for leading zeros in EFGH and consider ‘AB x CD’ to be distinct from ‘CD x AB’
2. There are 52 solutions if you rule out any with leading zeros in EFGH.  Leading zeros in AB or CD are not a consideration since there are no solutions where that is the case.
3. There are 26 solutions when leading zeros are disallowed and ‘AB x CD’ is considered to be the same as ‘CD x AB’.
4. The largest and smallest values of EFGH are, respectively:  6840 and 0456 (allowing leading zeros), or 6840 and 1058 (disallowing leading zeros).

So, how do you calculate all this?  There are two key things we need to know.  The first is how to build an executable expression one piece at a time. For example, if we set some variables like this:

$a = 5
$b = 7
$c = 2
$d = 4

We can create a string like this: “$a$b * $c$d”, which will generate this output if ‘run’ by itself: 57 * 24.  We get the standard variable replacement, but it didn’t execute the calculation that the string represents.  We can force it to do the calculation using Invoke-Expression:

Invoke-Expression “$a$b * $c$d”

Which gives the expected output: 1568.  We can go a step further:

$e = 1; $f =3; $g = 6; $h = 8
Invoke-Expression  “$a$b * $c$d -eq $e$f$g$h”

Which returns ‘true’.  Notice that the full expression, “57 x 24 = 1368”, is actually one of the solutions to the problem, since all of the digits are unique and the equation is true.  If you set $h = 9, then the digits are all still unique, but Invoke-Expression returns ‘false’, since the equation is no longer valid.  Using this technique we can easily check any possible solution to see if it represents a valid equation.

Now we know how to validate an expression that we build at runtime, we need to find a way to generate candidate expressions to test.  As this is a combinatorial problem, I am guessing there is no shortcut to finding the answers, though if you know different, I’m happy to be proved wrong!  The solution below uses simple brute-force to generate all possible combinations of digits, discarding any that fail the test.

As the final script has formatting issues due to the blog theme, I’ll describe the general approach and you can download the full solution from the link at the end. 

Firstly, we need an array of the digits:

$digits = 0 .. 9

Then we need to loop through these setting $a to each digit, then $b to each remaining digit, and so on:


foreach ($a in $digits)
{
    foreach ($b in ($digits -ne $a))
    {
        foreach($c in ($digits -ne $a -ne $b))
        {
            # rest of processing omitted
        }
    }
}

This nesting carries on, with each level looping through the unassigned digits until we reach $h, at which point we apply the Invoke-Expression test to see if the expression is valid – since we only use the unused digits from the previous step at each stage, we will not generate any duplicates, so anything that passes the test is not only a valid equation, but also guaranteed to have all digits unique – it is a solution to the original problem.

At this point, we could simply print out the correct solutions as we find them.  However, as the original question asked for some statistics, we need a way of counting the solutions.  Rather than run the script multiple times, a more efficient method is to capture each solution into a collection, that way we need only run the script once to get the solutions and we can sort, filter and count the them later.  The final step is to create a PsObject for each solution and add it to an array:

if (Invoke-Expression "$a$b * $c$d -eq $e$f$g$h")
{
     $solutions += New-Object PsObject -Property ` 
                   @{AB="$a$b"; CD="$c$d";EFGH="$e$f$g$h"} 
}

Once we have the array, we can count the solutions (and find the maximum an minimum values for EFGH) like this:

$solutions | Measure-Object EFGH -Maximum -Minimum

Get the full script here.

Recently I say the following tweet from @standupmaths:

Multiple two two-digit numbers to get a four-digit answer. ab × cd = efgh Can you find one with all eight digits different?

As it happens there are quite a few solutions to this problem.  Can you use PowerShell to find them? 

Some things to work out:

1. How many solutions are there if you allow EFGH to have leading zeros (e.g. ‘12 x 12 = 0144’) and consider ‘AB x CD’ to be distinct from ‘CD x AB’?
2. How many solutions are there if you disallow leading zeros in EFGH?  Why are leading zeros for ‘AB’ and ‘CD’ not a consideration?
3. How many solutions are there is you disallow leading zeros for EFGH and consider ‘AB x CD’ to be the same as ‘CD x AB’?
4. What are the largest and smallest values of EFGH (with and without leading zeros)?

Hints, if you need them.

So, it looks like 35 people attended the different sessions for PowerShell Week.  The following one-liner can generate a list of their names and email addresses from the individual attendee lists (linked in the original post):

1..5 |
    ForEach-Object { Import-Csv ("Session$_.csv") } |
        Select-Object Name, Email -Unique |
            Sort-Object @{Expression={$_.Name.Split(" ")[-1]}} |
                Export-Csv CombinedList.csv –NoTypeInformation

How does this work?  Well, the first two lines are reading the entries from all of the individual CSV files:

1..5 |
ForEach-Object { Import-Csv ("Session$_.csv") } |

The Range Operator (..) is a nice way to quickly loop through a set of consecutive numbers.  We then take advantage of PowerShell’s excellent variable substitution to generate the name of the current file.  That is, “Session$_.csv” becomes “Session1.csv”, “Session2.csv”, etc.  This result sin every entry from each of the CSV files being sent along the pipeline for processing.

Next, the Select-Object cmdlet grabs the Name and Email fields for each entry and the “-Unique” switch ensures that any duplicates (and there are quite a few across the files) are discarded:

Select-Object Name, Email -Unique

At this point we have a collection of objects, one for each unique attendee.   Technically, we’ve done enough to now send the email to each attendee as mentioned in the original post.  However, for ease of use (and because the original problem asked for it), we should sort the names alphabetically.

Since the names are given as a single string containing all parts of the name, we need a way to break this into the individual words, so we can sort on the last name.   The good news is that Sort-Object allows us to do all of this in a single step:

Sort-Object @{Expression={$_.Name.Split(" ")[-1]}}

We simply supply the cmdlet with a hash table that defines an expression who’s result is used as the item to be sorted – in this case it will be the last name of the attendee. 

The expression uses the Split() method of string objects to generate an array where the first name is in position 0, the second name in position 1, etc.  In order to make sure we use the last name in all cases, we use the index “-1”, which translates as “the last item in the array” (“-2”, would be the “second to last item”, and so on).  If we didn’t use this and had assumed all attendees had only a first and last name, then “James Clerk Maxwell” would be sorted incorrectly, and really that’s no way to treat one of the greatest physicists of all time.

Finally, we use Export-Csv to generate a new file with the combined list of attendees.  The “-NoTypeInformation” switch prevents the cmdlet adding the object type name to the head of the file.

To answer the additional question about who attended the most/fewest sessions, we need to modify the code like this:

1..5 |
    ForEach-Object { Import-Csv ("Session$_.csv") } |
        Group-Object Name |
            Sort-Object Count –Descending

From the results, it is clear that “Marie Curie” attended the most sessions (all five – she can’t get enough scripting), and several people (including “Grant Imahara”,  “Leonhard Euler” and  “Douglas Adams”) need a bit more convincing about the wonders of Powershell as they attended only a single sessions each.

The week was a great success, but now I need to send a follow-up email.   I have to target it to just the attendees, so can’t just send an office-wide mail. The problem is that all I have are the separate attendee lists for each session (as CSV files), and, since attendance was more-or-less random, there is a lot of duplication between lists:

Attendee Lists

Can you use PowerShell to generate a single list of attendees and email addresses?  While making your list, consider these points:

• The list must be in alphabetical order by surname
• The list must account for everyone who attended at least one session, but should have no duplicate entries
• Although there are no two people in my office with same name, make sure your code could handle a situation where two attendees did have the same name (but, of course, different email addresses)?

While you’re at it, can you work out who attended the most sessions, and who attended the fewest?

Some hints, if you need them.

* – If any of my colleagues are reading this, no, you didn’t miss out - last week wasn’t “PowerShell Week”.  I made that up.  Wouldn’t it be great, though?

There are a number of things we need to look at to make a table with a  built-in chart (as mentioned in the hint file from the original post).  The first is working out how to read events from the event log:

This code will do that for us:

Get-EventLog -LogName System -EntryType Error,Warning |  
     Group-Object Source |   
          Sort-Object Count –Descending | 
               Format-Table Count, Name -Autosize


This is a single line of PowerShell.  I have broken the line at each pipe and indented the next row – I find this makes for neater and easier to read code when you have a long or complex 1-liner.

What is it doing? Well, firstly the Get-EventLog cmdlet gathers the specific event types (“error” and “warning”) from the target log (“system”), which it then sends to be grouped by Group-Object.  Group-Object produces a group of event entries for each unique source in the  stream sent by Get-EventLog.  It also kindly counts the number of items in each group, which Sort-Object makes use of to sort the groups in order starting with the most populous to the least.  Finally, Format-Table shows the information in a neat table like this:

Count Name                  
----- ----                  
  129 Kerberos              
   57 NETLOGON              
   36 cdrom                 
   29 Schannel              
   26 Microsoft Antimalware 
   25 DCOM                  
   17 Service Control Manager
    7 Disk                  
    2 Virtual Disk Service  
    2 WudfUsbccidDriver     
    2 volsnap               
    2 SCardSvr              
    1 Ntfs                  
    1 EventLog

We’re half-way to our end goal.  This information is useful as is (I think I might have an issue with Kerberos), but just to add that finishing touch of the ‘chart’, we need to tweak the code:

$Evt = Get-EventLog -LogName System `
    -EntryType Error,Warning |
        Group-Object Source |
            Sort-Object Count -Descending

$Scale = 20 / $Evt[0].Count

$Chart = @{Label="Chart";`
           Expression={"X"*(($_.Count) * $Scale)}}

$Evt | Format-Table Count, Name, $Chart -Autosize

Now, what is this doing?  The first line is just the same as before, except we capture the events into a variable instead of displaying them.  Next we calculate a scaling factor using the size of the largest group – here we divide 20 by the group size, so that in the final chart this group will be represented by 20 Xs. 

The interesting stuff takes place on the next line, where we use a hashtable (signified by ‘@{ … }’) to produce the ‘calculated property’ that will be our chart values.  The hashtable comprises of two parts, the ‘label’, which will become the title of the chart column in our final table, and the ‘expression’, which executes some PowerShell code to calculate the values in the rows of that column.  In this instance, we make use of the fact that the multiplication operator has an overload that effectively concatenates an input string with itself the given number of times.  For example, “X” * 5, produces: “XXXXX”.

Finally, we display the events in a table, which gives a result like this:

Count Name                    Chart              
----- ----                    -----              
  129 Kerberos                XXXXXXXXXXXXXXXXXXXX
   57 NETLOGON                XXXXXXXXX          
   36 cdrom                   XXXXXX             
   29 Schannel                XXXX               
   26 Microsoft Antimalware   XXXX               
   25 DCOM                    XXXX               
   17 Service Control Manager XXX                
    7 Disk                    X 

For the optional enhancements (running against multiple computers and grouping by source and Event ID), we need to perform these two simple changes:

To run the script against multiple machines, simply alter the GetEventLog cmdlet to include the –ComputerName parameter, like this: –ComputerName Server1, Server2, Server3, …

To group by source and Event ID, change the Group-Object cmdlet to include both, like this: Group-Object Source, EventID

For example, here is a table that compares the working set values for some processes:

Name              Working Set Chart         
----              ----------- -----         
svchost                133.19 XXXXXXXXXXXXXXXXXXXX
powershell_ise         112.82 XXXXXXXXXXXXXXXXX  
sqlservr                78.07 XXXXXXXXXXXX       
MsMpEng                 74.93 XXXXXXXXXXX        
svchost                 68.20 XXXXXXXXXX             
explorer                57.93 XXXXXXXXX          
svchost                 55.70 XXXXXXXX           
CcmExec                 41.02 XXXXXX             
dwm                     35.68 XXXXX              
SearchIndexer           30.46 XXXXX              
msitcertsvc             25.86 XXXX               
DcaTray                 25.77 XXXX               
svchost                 25.27 XXXX               
svchost                 23.95 XXXX 

The ‘chart’ is constructed in such a way that the number of Xs for each entry is relative to the maximum value for the target property.  So, here I have chosen a value of 20 Xs for the top svchost process which has a WS of 133.  This means, for example, that explorer with a WS of 58 will have 9 Xs:

20/9 ≈ 133/58

Thus, the general formula is:

Number of Xs = [(Maximum Xs) * (Current Property Value)] / (Maximum Property Value)

Obviously there is some slight discrepancy since we can’t show fractions of an X.  The choice of 20 as the maximum is arbitrary (though constrained by the display width) - you can try a different number to see what looks good, or, indeed use a character other than an X.

Your task is …

Generate a similar table for event log entries on the local system as follows:

• Only consider ‘error’ and ‘warning’ events from the ‘System’ log
• Group events by source
• Create a table with these columns: event source, number of events, chart. 
• Sort the table by ‘number of events’

This should provide a useful table showing the event source generating the greatest number of errors, but it could be enhanced to be even more useful, so once you have the technique, extend the table in these two ways:

1. Scan multiple servers, aggregating the information in one table
2. Add the ‘eventID’ to the list of properties, so that the table is sorted first by source, then event id, so you can be more granular about the ‘worst offender’.

If you’re in need of a hint, click here.