Josh Einstein

The following can be easily added to your PowerShell profile or imported as a module to create convenient variables for referencing special folder paths. For example, “$PathDesktop\blah.txt”.

##############################################################################
#.SYNOPSIS
# Gets the path to the system special folder identified by the folder name.
#
#.DESCRIPTION
# This function is equivalent to the Environment.GetFolderPath method.
#
#.PARAMETER Folder
# An Environment.SpecialFolder enumeration value which can be specified as
# a string or literal in PowerShell (see example.)
#
#.EXAMPLE
# Get-SpecialFolder Favorites | Set-Location
#
#.RETURNVALUE 
# The full path to the specified system folder.
##############################################################################
function Get-SpecialFolder([Environment+SpecialFolder]$Folder) {
    [Environment]::GetFolderPath($Folder)
}

function Script:Set-SpecialFolderVariable([Environment+SpecialFolder]$Folder,[String]$Description) {
    Set-Variable "Path$Folder" (Get-SpecialFolder $Folder) -Scope Global -Option AllScope,ReadOnly -Description $Description -Force
}

Set-SpecialFolderVariable ApplicationData        -Description "The directory that serves as a common repository for application-specific data for the current roaming user."
Set-SpecialFolderVariable LocalApplicationData   -Description "The directory that serves as a common repository for application-specific data that is used by the current, non-roaming user."
Set-SpecialFolderVariable Desktop                -Description "The logical Desktop rather than the physical file system location."
Set-SpecialFolderVariable DesktopDirectory       -Description "The directory used to physically store file objects on the desktop."
Set-SpecialFolderVariable Personal               -Description "The directory that serves as a common repository for documents."
Set-SpecialFolderVariable MyComputer             -Description "The `"My Computer`" folder."
Set-SpecialFolderVariable MyMusic                -Description "The `"My Music`" folder."
Set-SpecialFolderVariable MyPictures             -Description "The `"My Pictures`" folder."
Set-SpecialFolderVariable Favorites              -Description "The directory that serves as a common repository for the user's favorite items."
Set-SpecialFolderVariable Recent                 -Description "The directory that contains the user's most recently used documents."
Set-SpecialFolderVariable SendTo                 -Description "The directory that contains the Send To menu items."
Set-SpecialFolderVariable Templates              -Description "The directory that serves as a common repository for document templates."
Set-SpecialFolderVariable StartMenu              -Description "The directory that contains the Start menu items."
Set-SpecialFolderVariable Programs               -Description "The directory that contains the user's program groups."
Set-SpecialFolderVariable Startup                -Description "The directory that corresponds to the user's Startup program group."
Set-SpecialFolderVariable InternetCache          -Description "The directory that serves as a common repository for temporary Internet files."
Set-SpecialFolderVariable Cookies                -Description "The directory that serves as a common repository for Internet cookies."
Set-SpecialFolderVariable History                -Description "The directory that serves as a common repository for Internet history items."
Set-SpecialFolderVariable ProgramFiles           -Description "The program files directory."
Set-SpecialFolderVariable System                 -Description "The System directory."
Set-SpecialFolderVariable CommonApplicationData  -Description "The directory that serves as a common repository for application-specific data that is used by all users."
Set-SpecialFolderVariable CommonProgramFiles     -Description "The directory for components that are shared across applications."

It’s the little things in PowerShell that make a rigid C# developer smile… In the following example, I distribute an array result to separate variables in one line.

$NPA,$NXX,$Digits = Split-Phone 202-456-1111

# In C#, the equivalent would be
# string[] results = SplitPhone("202-456-1111");
# string npa = results.Length > 0 ? results[0] : null;
# string nxx = results.Length > 1 ? results[1] : null;
# string digits = results.Length > 2 ? results[2] : null;

And even the C# syntax mentioned above doesn’t exactly do the same thing because in PowerShell, if the array contains more elements than you’re distributing, the last variable can receive the “remainder” of the array. Since C# doesn’t really have a concept of singleton arrays being treated as strings, there is no direct analogy.

##############################################################################
#.SYNOPSIS
# Splits a phone number into NPA, NXX, and 4 digit components.
#
#.PARAMETER TN
# The telephone number to split.
#
#.RETURNVALUE
# If the specified number is a valid US telephone number, the return value is
# a 3 element array containing NPA, NXX, and the 4 digit line. Otherwise, an
# exception is thrown.
##############################################################################
function Split-Phone {

    param ( [String]$TN )

    
    $Pad = '\s*'
    $Sep = '(\s+|\.|\-)?'
    $Intl = '(?<intl>\+?1)?'
    $NPA = '(\s*\(?\s*(?<npa>\d{3})\s*\)?\s*)'
    $NXX = '(?<nxx>\d{3})'
    $Digits = '(?<digits>\d{4})?'
    
    $Pattern = "^$Pad$Intl$Sep$NPA$Sep$NXX$Sep$Digits$Pad`$"
    
    Write-Debug "Split-Phone Pattern: $Pattern"
    
    if ( $TN -match $Pattern ) {
        if ( $Matches['digits'] ) {
            @(  $Matches['npa'],
                $Matches['nxx'],
                $Matches['digits'] )
        }
        else {
            @(  $Matches['npa'],
                $Matches['nxx'] )
        }
    }
    else {
        throw "Invalid TN: $TN" 
    }
       
}

http://richardsiddaway.spaces.live.com/blog/cns!43CFA46A74CF3E96!2089.entry

A couple things come to mind:

1. Why aren’t they just referencing the same ParameterAttribute the way C# does?
2. Specifying System.Management.Automation.ParameterAttribute doesn’t work either. It causes the error message to complain about not being able to find an attribute class that very much does exist.
3. Are they planning on supporting .NET attributes or maybe even classes in the future? (The PowerShell purist in me says “no no”, but the C# guy in me says “yes yes”!)
4. Shouldn’t it raise the error at the time the function is defined and not when it is invoked?

function Blah {
   [CmdletBinding()]
   param(
      [System.Management.Automation.ParameterAttribute (Mandatory=$true)]
      [String] $Name
    )
    
    "Hello $Name"
    
}

Blah "Jerry"
Blah "Newman"

I hate to admit it, but the convenience of having PowerShell ISE installed with the core installation of PowerShell 2.0 has been enough to get me to switch from PowerGUI, which is in my opinion a much more full featured free editor/debugger.

One thing that I sorely missed from PowerGUI (which is compounded by the fact that unless you’re on Windows 7, PowerShell ISE doesn’t have a "Recent Files" menu) is the ability to quickly open my profile script without having to browse for it.

Well PowerShell ISE is extensible, so if it lacks a feature, you can just add it in most cases. I’ve uploaded my PowerShell ISE profile which has some useful functions for automating the ISE. But the one in particular that implements the "Open Profile" feature is called….(wait for it)…. Open-Profile!

So you can type that in the immediate window, or use the custom menu item that gets added. It opens the user/global/host/generic/etc profiles if they exist.

function Open-File([String]$Path,[Switch]$Quiet) {

    $AllowedExtensions = @('.ps1','.psm1','.psd1','.ps1xml','.txt','.txt')
    $Extension = [System.IO.Path]::GetExtension($Path)

    try {

        if ( -not ($AllowedExtensions -contains $Extension) ) {
            throw "OpenFile: $Path cannot be opened in PowerShell ISE."
        }
        if ( -not (Test-Path $Path) ) {
            throw "OpenFile: $Path does not exist."
        }

        $Path = (Resolve-Path $Path).ProviderPath
        $PSISE.CurrentOpenedRunspace.OpenedFiles.Add($Path)

    }
    catch {
        if ( -not $Quiet ) { Write-Warning $_ }
    }

}

function Open-Profile {
    Open-File $PROFILE.CurrentUserAllHosts -Quiet
    Open-File $PROFILE.CurrentUserCurrentHost -Quiet
    Open-File $PROFILE.AllUsersAllHosts -Quiet
    Open-File $PROFILE.AllUsersCurrentHost -Quiet
}

One of the things I really like about PowerShell is how through the use of script blocks and locally scoped functions, you can create interesting script using perfectly valid, albeit odd looking PowerShell script. I had first done something like this without script blocks using the pipeline which was pretty ugly. It was mostly just a way of quickly building up objects using functions that wrapped New-Object and Add-Member.

New-PSObject |
    Field FirstName 'Josh' |
    Field LastName 'Einstein'

That was pretty handy but as a C# guy it still looked ugly. I got the idea from Bruce Payette’s book, PowerShell in Action to use script blocks and locally-scoped functions so that I didn’t have to pollute the runspace with a bunch of functions that were only valid within the context of another function.

New-PSObject {

    Field FirstName 'Josh'
    Field LastName 'Einstein'

    Property FullName { "$($this.FirstName) $($this.LastName)" }

    Method SayHello {
        param($to)
        "$($this.FirstName) says 'Hello' to $to!"
    }

}

How does it work? Well, like most things in PowerShell, functions have scope. So a function defined within another function is only valid during the execution of the outer function. This makes it possible to trample on existing functions and cmdlets too.

In Bruce Payette’s book he calls them "little languages".

This technique allows for some really clean and concise syntax similar to how some DSL’s are being used in .NET.

# Global functions used by New-PSObject
function Field([String]$Name,$Value,[String]$Format) {
    @{ MemberType='NoteProperty'; Name=$Name; Value=$Value; Format=$Format }
}
function Property([String]$Name,[ScriptBlock]$GetDefinition,[ScriptBlock]$SetDefinition) {
    @{ MemberType='ScriptProperty'; Name=$Name; Value=$GetDefinition; SecondValue=$SetDefinition }
}
function Method([String]$Name,[ScriptBlock]$MethodDefinition) {
    @{ MemberType='ScriptMethod'; Name=$Name; Value=$MethodDefinition }
}

##############################################################################
#.SYNOPSIS
# Creates a PSObject and initializes it with fields, properties, and methods
# using a ScriptBlock written in a mini-language.
#
#.DESCRIPTION
# The ScriptBlock passed to the Definition parameter can contain commands
# that are private to this function, such as Field, Property, and Method
# which define members on the new PSObject.
#
#.PARAMETER Definition
# The ScriptBlock that builds up the PSObject by using special commands such
# as Field, Property, and Method. See the example for more information.
#
#.PARAMETER InputObject
# A HashTable that contains key/value pairs that will be turned into
# NoteProperties on the new PSObject.
#
#.EXAMPLE
# New-PSObject {
#     Field FirstName 'Josh'
#     Field LastName 'Einstein'
#     Property FullName { "$($this.FirstName) $($this.LastName)" }
#     Method GetFullName { "$($this.FirstName) $($this.LastName)" } 
# }
#
#.EXAMPLE
# @{FirstName='Josh';LastName='Einstein'} | New-PSObject
##############################################################################
function New-PSObject {

    [CmdletBinding(DefaultParameterSetName='Definition')]
    param ( 

        [Parameter(ParameterSetName='Definition', Position=1)]
        [ScriptBlock]$Definition,
        
        [Parameter(ParameterSetName='Hashtable', Mandatory=$true, ValueFromPipeline=$true)]
        [HashTable]$InputObject
        
    )

    begin { }
    
    process {

        $Object = New-Object PSObject
        
        if ( $InputObject ) {        
            foreach ( $k in $InputObject.Keys ) {
                Add-Member -InputObject $Object -MemberType NoteProperty -Name $k -Value $InputObject[$k]
            }
        }
        elseif ( $Definition ) {

            $Members = &$Definition
            
            foreach ( $Member in $Members ) {
                if ( $Member.Format ) { $Member.Value = [String]::Format([String]$Member.Format,[String]$Member.Value) }
                if ( $Member.ContainsKey('SecondValue') ) { 
                    Add-Member -InputObject $Object `
                                -MemberType $Member.MemberType `
                                -Name $Member.Name `
                                -Value $Member.Value `
                                -SecondValue $Member.SecondValue
                }
                else {
                    Add-Member -InputObject $Object `
                                -MemberType $Member.MemberType `
                                -Name $Member.Name `
                                -Value $Member.Value
                }
            }

        }
        
        $Object
        
    }
    
    end { }

}