5 groups are covered: Computer Science, Software Engineering, Programming, Experience and Knowledge.

Your competency is rated from Level 0 (beginner) to Level 3 (expert) across categories within each group.

• Level 0 == 2ⁿ
• Level 1 == n²
• Level 2 == n
• Level 3 == log(n)

These were unexpected.

Programming in the category scripting:

• n (Level 2) – PowerShell/Perl/Python/Ruby/VBScript
• log(n) (Level 3) – if you have published reusable code

Software Engineering in the category build automation:

• 2ⁿ (Level 0) - if you only know how to build from the IDE
• log(n) (Level 3) – Can setup a script to build the system and also documentation, installers, generate release notes and tag the code in source control

Knowledge in the category blogs:

• n² (Level 1) – Reads tech/programming/software engineering blogs and listens to podcasts regularly
• log(n) (Level 3) – Maintains a blog in which personal insights and thoughts on programming are shared

I hadn’t realized you could use Regular Expressions to manage fixed width text files.

Bill Sempf blogs and talks about the efficient way for Handling fixed width text with Regular Expressions (RegEx) and presents a C# solution.

The PowerShell Solution

The school is 32 characters, the location is 28 characters, and the year is 4 characters.

$records = @"
University of Illinois          Champaign, Illinois         1867
Indiana University              Bloomington, Indiana        1820
University of Iowa              Iowa City, Iowa             1847
University of Michigan          Ann Arbor, Michigan         1817
Michigan State University       East Lansing, Michigan      1855
University of Minnesota         Minneapolis, Minnesota      1851
Northwestern University         Evanston, Illinois          1851
Ohio State University           Columbus, Ohio              1870
Pennsylvania State University   State College, Pennsylvania 1855
Purdue University               West Lafayette, Indiana     1869
University of Wisconsin–Madison Madison, Wisconsin          1848
"@            

$pattern = '^(?<school>.{32})(?<location>.{28})(?<joined>.{4})$'            

ForEach($record in ($records -split "`r`n")) {
    if($record -match $pattern) {
        New-Object PSObject -Property @{
            School   = $matches.school
            Location = $matches.location
            Joined   = $matches.joined
        } | Select School, Location, Joined
    }
}            

# Results
School                           Location                     Joined
------                           --------                     ------
University of Iowa               Iowa City, Iowa              1847
University of Michigan           Ann Arbor, Michigan          1817
Michigan State University        East Lansing, Michigan       1855
University of Minnesota          Minneapolis, Minnesota       1851
Northwestern University          Evanston, Illinois           1851
Ohio State University            Columbus, Ohio               1870
Pennsylvania State University    State College, Pennsylvania  1855
Purdue University                West Lafayette, Indiana      1869
University of Wisconsin–Madison  Madison, Wisconsin           1848 

In PowerShell Version 1 that cmdlet is not available so you need to use the one of the Load* static methods found in System.Reflection.Assembly.

Why?

For example, in PowerShell, if you want to encode a Url you can use the UrlEncode method found in the .NET HttpUtility Class.

If you fire up PowerShell and try to call the static method UrlEncode found in System.Web.HttpUtility you’ll get this error.

[System.Web.HttpUtility]::UrlEncode("this is a test")

Unable to find type [System.Web.HttpUtility]: make sure that the assembly containing this type is loaded.

You can solve this by loading the System.Web .NET assembly. This is equivalent to being in the Visual Studio IDE, adding a reference and then adding a using statement.

Using Reflection.Assembly in PowerShell Version 1

[Reflection.Assembly]::LoadFile( `
  'C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727\System.Web.dll')`
  | out-null            

[System.Web.HttpUtility]::UrlEncode("this is a test")

Using Add-Type in PowerShell Version 2

Add-Type -AssemblyName System.Web
[System.Web.HttpUtility]::UrlEncode("this is a test")

Additional Reflection.Assembly usage

[void] [Reflection.Assembly]::LoadWithPartialName("System.Windows.Forms")
[reflection.assembly]::Load("mscorlib.dll") | Out-Null
[void][system.reflection.assembly]::loadfrom("c:\windows\system32\inetsrv\microsoft.web.administration.dll")

Additional Add-Type usage

Add-Type -AssemblyName "System.Windows.Forms"
Add-Type -AssemblyName "mscorlib.dll"
Add-Type -Path "c:\windows\system32\inetsrv\microsoft.web.administration.dll"

Compiling C# on the fly in Version 2

Add-Type -TypeDefinition @"
public class Test
{
    public static int Add(int n1, int n2)
    {
        return n1 + n2;
    }
}
"@

If you change the signature of the Add method you will get this error:

When compiling code on the fly or loading assemblies they cannot be unloaded.

.NET assemblies can’t be unloaded from a session (it’s a .NET thing, not a PowerShell thing) therefore DLLs can’t be unloaded from a session. This means that you can’t update a DLLs once it’s been loaded. We can’t even update the assembly on disk because the file is locked when the assembly is loaded.

- Bruce Payette Windows PowerShell in Action, Second Edition

Another way to use the –Path parameter on Add-Type

You can point to a C# source code file directly.

Add-Type –Path c:\test\Hello.cs

Add-Type is not limited to compiling only C#

You can inline these languages using the –Language parameter CSharp, CSharpVersion3, VisualBasic, JScript.

Notice, F# is not supported. Here is a post How to add an F# type to a PowerShell session that inlines F#.

NOTE: This uses the F# DLLs shipped with .NET 4.0

Add-TypeFSharp -TypeDefinition @"
module MyModule

let Add a b = a + b;;
"@                        

1..10 | % { [MyModule]::Add( $_, $_*2 ) }

Finally

There are additional parameters that the Add-Type cmdlet supports. You can generate a DLL file for the assembly with the specified name in the location, specify compiler parameters, specify assemblies which your code depends on and use wild cards when loading assemblies.

Check out the online help for Add-Type.

• Chad Miller published his Really Simple Data Dictionary – a meta data collector for SQL Server and Oracle. Developed in PowerShell
• Here is a PowerShell script that exports a Raven DB Index to CSV (comma separated values). Raven is an Open Source document database for the .NET/Windows platform
• Alan Renouf wrote a nice PowerShell script, Simple PowerShell selection box, which takes a list of items and puts it in a WinForm combo box, then after selecting the item sends, it down the pipeline. Check out these other posts:
  • Inject Dynamic WPF GUIs into your PowerShell Pipeline
  • 3 More Ways To Inject Dynamic WPF GUIs into your PowerShell Pipeline
  • Update: Dynamic GUIs and the PowerShell Pipeline
• Colleague Daniel Moore chatted with me about his cool Alpha-Blending Colors in PowerShell script. I like his walk through discussing his choice points in refactoring
• Bought my copy of Lee Holmes’ new book PowerShell Cookbook Version 2

• Doug Finke on the OData PowerShell Explorer! Check out the podcast run by Richard and Greg. Lots of fun talking about Open Data Protocol, PowerShell and the potential of PowerShell.
• Lee Holmes book is out, V2 Windows PowerShell Cookbook: The Complete Guide to Scripting Microsoft’s New Command Shell. He is part of the Microsoft PowerShell team and the first edition had excellent scripts and concepts. This should be great resource.
• Allen White is giving a pre-conference session at PASS. PowerShell is an amazing tool to help you automate your administrative processes. Allen has 9 sections to his outline for this session. Looks great.
• William Vambenepe says in his post The necessity of PaaS: Will Microsoft be the Singapore of Cloud Computing?

Under the DSI banner, Microsoft has been working for a while on improving the management/automation infrastructure for Windows, with tools like PowerShell (which I like a lot).

• It was great to watch this PowerShell script unfold from an interaction of 140 character tweets. Jaykul posted it HERE. With it you can do this:

C:\PS> math ‘(42 / 9) * ( cos(.56) ^ 3 ) + Tan 60’

• Dan Wanek posts Managing Windows with Ruby (Part 1) or… How I learned to stop worrying and manage Windows from Linux. He creates a Ruby library to tap into WinRM (windows remote management) that ships with PowerShell.
• Lance Robinson posts PowerShell TruncateAtWhitespace Function – if you have “Lance has a blog” and you need to truncate it to 8 characters or less, you get “Lance” instead of “Lance ha”.
• Posted a couple years ago, here are a handful of functions and alias’ that make working with TortoiseSVN from PowerShell a snap: Status-TortoiseSvn, SmartDiff-TortoiseSvn, RepoBrowser-TortoiseSvn, Commit-TortoiseSvn, Log-TortoiseSvn
• A colleague, Thorsten Lorenz, blogged about taking my Svn PowerShell prompt, merged it with the Git PowerShell prompt. Now he can be in a directory and gets feedback if it is a git or svn working copy.

Check it out. HERE is the podcast.

We talked about:

• OData – Open Data Protocol http://www.odata.org/
• PowerShell
• WPK (WPF for PowerShell, think Tcl/Tk)
• PowerShell and Data visualization, HERE, HERE and HERE
• and more

I want to thank Richard and Greg for having me on, smart guys and smart questions. They got me thinking about next steps for using PowerShell and features to add to the OData PowerShell Explorer.

So to get my head around the Ruby example, I worked up one way to do it in PowerShell using the New-Module cmdlet, wrapped it in a function and you can see the code below.

Like Ruby, PowerShell lets us assign a string to Address in the first example ($p1) and then in the second example ($p2) to a more complex object without breaking the Person implementation.

Rob Conery’s post goes on to show that C# 4.0 can do the same thing. The dynamic dial is being turned up for this static language.

Rob suggests:

C# is going more and more dynamic – time and feature set have proven that. Maybe it’s time to bend your thinking? Or maybe it’s not…

In either case it is possible to do and should make for interesting discussions.

Function New-Address {
    New-Module -AsCustomObject -Name Address {
        $Number  = $null
        $Street  = $null
        $City    = $null
        $State   = $null
        $Country = $null            

        Export-ModuleMember -Variable *
    }
}            

Function New-Person {
    New-Module -AsCustomObject -Name Person {
        $Name    = $null
        $Address = $null                    

        Export-ModuleMember -Variable *
    }
}            

$p1 = New-Person
$p1.Name = "Mary"
$p1.Address = "Number 17, Cherry Tree Lane"
$p1            

$p2 = New-Person
$p2.Name = "Burt"
$p2.Address = New-Address
$p2.Address.Number = 17
$p2.Address.Street = "Cherry Tree Lane"
$p2.Address.City = "London"
$p2            

# Result
Address                                                              Name
-------                                                              ----
Number 17, Cherry Tree Lane                                          Mary
@{City=London; Country=; Number=17; State=; Street=Cherry Tree Lane} Burt

#OData query to find @jonskeet http://tinyurl.com/jonskeet200000

So, how would you find Jon Skeet using the OData PowerShell Module?

First, download OData PowerShell Explorer.

Then paste this code into the console or run it from ISE (Integrated Scripting Environment).

My OData PowerShell Explorer is extracted in C:\CodePlex\psodata\trunk. Change the directory in the Import-Module to where you extracted the zip.

PowerShell Code

import-module C:\CodePlex\psodata\trunk\modules\OData.psm1
$se = New-ODataService `
  "http://odata.stackexchange.com/stackoverflow/atom"
$se.Users('$filter=Reputation gt 200000')

Results

# Results
AboutMe        : <p>
                 Author of <a href=`http://www.manning.com/affiliate/idevaffiliate.php?id=876_230` rel=`nofollow`>C# in Depth</a>.<br>
                 Currently a software engineer at Google, London.<br>
                 Microsoft MVP (C#, 2003 onwards)
                 </p>

                 <p>Sites:</p>

                 <ul>
                 <li><a href=`http://csharpindepth.com` rel=`nofollow`>C# in Depth</a>
                 <li><a href=`http://msmvps.com/jon.skeet` rel=`nofollow`>Coding blog</a>
                 <li><a href=`http://pobox.com/~skeet/csharp` rel=`nofollow`>C# articles</a>
                 <li><a href=`http://twitter.com/jonskeet` rel=`nofollow`>Twitter updates</a>
                 </ul>

                 <p>Email: skeet@pobox.com</p>

Age            : 34
CreationDate   : 2008-09-26T12:05:05.15
DisplayName    : Jon Skeet
DownVotes      : 295
EmailHash      : 6d8ebb117e8d83d74ea95fbdd0f87e13
Id             : 22656
LastAccessDate : 2010-08-01T21:54:18.477
Location       : Reading, UK
Reputation     : 200869
UpVotes        : 6460
Views          : 138078
WebsiteUrl     : http://csharpindepth.com

In this episode of geekSpeak, Microsoft Most Valuable Professional (MVP) Doug Finke takes us on a deep dive into PowerShell from a developer’s point of view. Doug shows techniques for integrating/debugging PowerShell from and to C# code as well as using PowerShell with a Windows Presentation Foundation (WPF) application. He also addresses using reflection at the command line, object pipelining, and PowerShell’s REPL. This geekSpeak is hosted by Glen Gordon andRachel Appel.

The geekSpeak webcast series brings you industry experts in a "talk-radio" format hosted by developer evangelists from Microsoft. These experts share their knowledge and experience about a particular developer technology and are ready to answer your questions in real time during the webcast.

• OData PowerShell Explorer
• OData Browser for the iPhone
• OData Explorer (Silverlight 4)
• Sesame Data Browser (Silverlight 4)
• LINQPad (Beta)
• Open Data Protocol Visualizer VS.Net 2010 Extension

via OData Primer