[snapinini.newobjecthelper]::newObjectFast(@{name="karl";age=31;now = [datetime]::Now})

very simple and its at least 6 times faster than the closest other technique in powershell. Most of hte overhead is in creating the hashtable. (otherwise its 90 times faster). The hashtable syntax is very convenient however maybe even its overhead is too much and we deserve a better way.

Here is the C# method. Its pretty basic stuff.

public static PSObject newObjectFast( Hashtable noteproperties )

        {

            PSObject obj = new PSObject();

            if (noteproperties != null)

                foreach(DictionaryEntry item in noteproperties)

                    obj.Properties.Add(new PSNoteProperty((string)item.Key,item.Value));

            return obj;

        }

- Karl

The extensibility model of ISE has caught on, and many people have been writing some great scripts adding hotkeys to do every what not you could imagine, so I’ve decided to start a codeplex project with the punny name “PowerShell ISE-Cream” . The Goal of this project is first to gather a huge variety of functionality that various people are willing to share, refactor it into production quality functions, with extensive error handling, and packaged in V2 Modules, and finally incorporate it in a way that users can easily turn on and off different features through a consistent configuration.

Right now however we are just going to gather whatever scraps there are, whether they conflict with each other or not, and anybody passionate about this can join the project, as we sculpt it hopefully into something both useful and beautiful.

Doug Finke has already joined the club with his Expand-Alias and Expand-CurrentAlias functions, and there are quite a few other functions that people i know are willing to share, so it should be good.

We’ll be brainstorming and deciding on a bunch of design issue, you can join the conversation on the first one in this discussion thread.

The PowerScripting Podcast tonight (Thursday 5th Feb 2009) will be talking about ISE. There should be a number of MVPs (including myself) and some PowerShell Team staff calling in. It Should be fun.

-Karl

Anyhow, I’m pretty much going to reblog the content from Tobias’s blog entry below. If you haven’t tried PS+ yet. I recommend wholeheartedly that you do. It really is about 3 generations and a couple of years ahead of anything else out there. Other vendors have only recently implemented “borrowed” features that have been in PowerShell Analyzer and PowerShell Plus since 2006.

http://powershell.com/cs/blogs/news/archive/2009/02/02/powershellplus-v2-1-beta-is-live.aspx

———————————————————

Exciting news! Effective immediately, PowerShellPlus v2.1 Beta is live and publicly available! Below you will find exciting information about an early look at what the PowerShellPlus team has been working on.

PowerShellPlus version 2.1 introduces several new and cool features focused on reducing the PowerShell learning curve, increasing the productivity of PowerShell development and exercising the capabilities of PowerShell 2.0. The new features include:

• Code sharing – Enables you to leverage the wealth of scripts that reside in the PowerShell.com and PoshCode.org libraries. Increase your productivity by quickly and easily searching and grabbing the scripts from those libraries. You can also submit your own scripts to the PowerShell.com library directly from PowerShell Plus Editor
• Visual Basic support – The PowerShell Plus Editor can now edit and run Visual Basic scripts
• STA mode support – Enables you to produce pretty cool looking GUI’s with Windows Presentation Framework (WPF) using PowerShell 2.0.
• PowerShell Assembly Detection – Gives the Learning Center an auto-upgrade path if PowerShell v2 CTP3 is detected and then displays the most up-to-date information
• Learning Center Auto-Load – Makes searching for a request with a single match much easier to use since the topic will load automatically, saving extra keystrokes
• Cmdlet parameter position – Shows you additional information in the code completion popup window about parameters including position and type
• Console size overlay – Shows you the height and width of the Console when you resize it
• Additional Sample Scripts - Active Directory, IIS 7.0 and MySQL
• PowerShell v2 CTP3 Support – Including Block Comments and the $Profile variable

How to get the New Version

Use the link at the bottom of this page to download the installation package, but before you do please read the following disclaimers, warnings and other general portents of doom.

• This software is a pre-release version and should not be deployed in a production environment. It will not work the way a final version of the software does. Features will change before the final release
• If you already have a PowerShellPlus license we recommend that you install this version on another machine, but we do support an upgrade in place your production version.
• If you upgrade your production version of 2.0 we will not overwrite any user customizations that have been made to PowerShellPlus but we do recommend you make a copy of the Sample scripts if you have modified them.
• A list of the changes is provided in the Release Notes in the Installation Package.
• This release is designed to provide the PowerShellPlus community with a preview of key features coming in 2.1 and to solicit feedback about them. This Technical Beta is not supported by the Idera Technical Support Team. Please visit the Beta Place: http://powershell.com/cs/forums/93.aspx

System Requirements

• Microsoft Windows PowerShell Version 1 or Version 2 CTP2 or CTP3
• Windows XP, Server 2003, Windows Vista, Server 2008, Windows 7

Installation Instructions

To install PowerShellPlus:

1. Click the link at the bottom of this page and complete the download form
2. An email will be sent with instructions on how to download the Beta.
3. After downloading the Beta, unzip the contents of the Installer package.
4. Read the Release Notes for late breaking information about the Beta.
5. If you are upgrading from PowerShellPlus 2.0 make that you copy the Sample Scripts to another location, if you have modified them.
6. Run the Setup.exe program to install PowerShellPlus 2.1.

Grab your copy now:

Download Here

For feedback, bug reports, suggestions and discussions regarding this beta release, please visit and use our Beta Place:

http://powershell.com/cs/forums/93.aspx

Enjoy!

-Tobias

So what’s this got to do with debugging? We’ll mostly it’s the real time aspect. You are able to process a lot of information (notes), in context, and are able to discern real-time what is out of place and wrong.

Compare that to typical debugging. You might use checkpoints, and tracing through code, slowing down the execution often a million-fold, tediously stepping through each line of code, looking here and there.
Alternatively you might be processing log output, whether a debug stream in your IDE, console output, or something else. However just getting those messages to somewhere you can display can be hard when threading, and you aren’t in the GUI thread etc.
Additionally you are having to interpret this, often after the fact, and you can often miss things when lots is going on. How often , especially when finding a rare threading bug, are you running something 10 or more times, and maybe logging 10 or so different events each time. Going through the log takes time, and sometimes you miss the cue.

So, is debugging with sounds going to change and revolutionize everything? No its just another tool in a really great toolkit we have these days.

I thank my friend Oisin Grehan (http://nivot.org ) for inspiring this as I don’t think I’ve used sound in debugging since the my  Demoscene  days when I was coding MOD players. Mod Players . So naturaller the tracker syntax has inspired me a bit.

So how does this work. Well work out the steps you are listening to, and maybe things you particularly want to catch, play the notes over and over a few times so you know mentality what to expect, then just start running you code, and listen to what actually IS happening, and then maybe at certain times you might make a certain note MEAN something (like middle  C  for TRUE function result and middle A for FALSE), but I typically just use notices to indicate execution flow, and if I want to know some value, I ask windows Speech API to help me out.

function Play-Note([string]$note,[int] $duration = 5)
{
  if (!($note -match '(\d+)')) { $note+='4' };[void]($note -match '([A-G#]{1,2})(\d+)')
  [console]::Beep((440 * [math]::Pow([math]::pow(2,(1/12)),
    (([int] $matches[2]) - 4)* 12 + $( switch($matches[1])
  {  'A'  { 0 }  'A#' { 1 }  'Bb' { 1 }  'B'  { 2 }  'C'  { 3 }  'C#' { 4 }  'Db' { 4 }
     'D'  { 5 }  'D#' { 6 }  'Eb' { 6 }  'E'  { 7 }  'F'  { 8 }  'F#' { 9 }  'Gb' { 9 }
     'G'  { 10 } 'G#' { 11 } 'Ab' { 11 }
  }))),$duration * 100 )
}

So two things. I’ve based the notes on common tracker syntax including the octave. so middle A is A4 , then you have things like F#3 etc. however if as with everything PowerShell we want pithy, so if you don’t put an octave number then it will be 4 by default.

play-note C ; play-note Eb ; play-note “C#”

also i included a duration, so if the want the note to be anything but the default half a second put that as a parameter

play-note Eb4 20

and you’ll get an E flat for 2 whole seconds. You may ask why I don’t use seconds or milliseconds, because those are our official measurements in this 1,000,000 3 grouped western world. Well the reason is pithiness (something i love in my scripts, but aren’t good about when it comes to blogging). Typically i want a note between say 300 milliseconds and 5 seconds. so if i used milliseconds i’d always have to have those 2 or 3 extra zeros, while if i used seconds I’d be doing things like 0.4 and 1.5. If Japanese and Chinese we often communicate number differently, and group them differently. so there is a word for 10,000 , so to say 15 thousand you may say 1 (character for 10,000) 5.

So what about voice. You can use a very simple function using the SAPI COM objects such as:

function Speak-words ([string]$words,[bool]$pause = $true)
{   $flag = 1
    if ($pause) {$flag = 2}
    $voice = new-Object -com SAPI.spvoice
    $voice.speak($words, [int] $flag)
    # 2 means wait until speaking is finished to continue
}

Typically though i don’t create a $voice everytime , but kept a reference somewhere , like in my V2 module. Others however have done more impressive things with the voice in powershell ( http://poshcode.org/667 | http://huddledmasses.org/powershell-speaks/ ).

So now you may want a way to play more notes and speak more words together, in a pithy line. you can just use play-notes

function Play-Notes
{
$defaultduration = 5;if($args[0] -is [int]) {$defaultduration = $args[0]}
for($i = 0;$i -lt $args.length;$i++)
 {    $duration = $defaultduration
    if ($i -lt $args.length-1) { if ($args[$i+1] -is [int]) {$duration = $args[$i+1] } }
    if ($args[$i] -is [string]) {
        if ($args[$i].startswith("!")) { speak-words $args[$i].replace('!','') } else
        { play-note $args[$i] $duration }
        }
 }
}

And with this you can simply pass in a list of notes, which will be played with a default duration, unless you choose to specify a duration after the note.

play-notes A B C 20 E 10 B 10

play-notes F5 2 E5 2 D5 2 C5 2 B5 2 A5 2 G 4 F5 2 E5 2 D5 2 C5 2 B5 2 A5 2 G 4

If you want to change the default duration to reduce the redundancy above, just put that number as the first parameter

play-notes 2 F5 E5 D5 C5 B5 A5 G 4 F5 E5 D5 C5 B5 A5 G 4

and finally if you want some speaking in there, just have your string start with an exclamation mark!

play-notes "!here we go now" Db5 Db Eb Gb Ab "C#" 6 !YEAH

But of course most of the time you will have speaking, you’ll want it to say something you don’t know like a variable or the results of a formula.

play-notes A“!$([datetime]::now)“ C

So you can get all these functions together at poshcode. ( Script | Download )  . We’ll time will tell if this will stay a habit of mine or be a fad. Additionally if you wanted to take this seriously you’d probably want to use something better than console.beep , maybe you’d use a full on MOD engine like http://fmod.org/ and having it running iringn a different process, and have a very cpu lightweight IPC going on, and different threads could play different channels, so between threads you could debug via Chords if you really have the ear for it.

WARNING, NOT A CUBICLE FRIENDLY DEBUGGING TECHNIQUE WITHOUT HEADPHONES UNLESS YOU WANT YOUR COLLEGUES TO DEBUG YOU.

Enjoy,

Karl

Script @ PoshCode: View Script | Download

Share on Facebook

—-

# PowerSmug photo sync script v1.0
# This PowerShell script will syncronize a folder of images with a users SmugMug account
# Please set the appropriate variables in the User Defined Variables region
# For more information visit http://shelltools.wik.is/Other_Projects/PowerSmug
#
# Images are uploaded to a gallery with the same name as the folder they are contained in.
# All folders below the Photo Directory path and the images they contain will be uploaded to SmugMug
# Folders that end in _ are ignored, so if you don't want to sync a folder with SmugMug, just add an underscore at the end
#
# Copyright 2008 Shell Tools, LLC

#Region User Defined Variables

$ApiKey = 'uVUvCbXP3f6MgO9wIRJn21YCIgEidVly'
$EmailAddress = '[SmugMug Email]'
$Password = '[SmugMug Password]'
$PhotoDirectory = '[Path To Photos]'
$filesToInclude = @('*.jpg','*.png','*.tif','*.cr2')
$worldSearchable = 1
$smugSearchable = 1

# Professional Accounts Only
$watermark=0
$watermarkId=0

#Email Variables
$smtpServer = '[SMTP Server]'
$smtpUser = '[SMTP User]'
$smtpPassword = '[SMTP Password]'
$smtpFrom = 'PowerSmug@shelltools.net'

#EndRegion

#Region Global Variables

$baseUrl = 'http://api.smugmug.com/hack/rest/1.2.0/'
$userAgent = 'PowerSmug v1.0'
$logFile = 'PowerSmug.log'
$script:SessionId = $null
$script:startStringState = $false
$script:valueState = $false
$script:arrayState = $false
$script:saveArrayState = $false
$script:datFileDirty = $false
$script:datFile = @()
$script:albumList = $null
$script:imageList = $null

#EndRegion

#region Helper Functions

function SendEmail([string] $to, [string] $subject, [string] $msg)
{
    $smtpMail = new-Object System.Net.Mail.SmtpClient $smtpServer
    $smtpMail.DeliveryMethod = [System.Net.Mail.SmtpDeliveryMethod]'Network'
    $smtpMail.Credentials = new-Object System.Net.NetworkCredential $smtpUser, $smtpPassword

    $smtpMail.Send($smtpFrom, $to, $subject, $msg)
}

function Get-MD5([System.IO.FileInfo] $file = $(Throw 'Usage: Get-MD5 [System.IO.FileInfo]'))
{
    # This Get-MD5 function sourced from:
    # http://blogs.msdn.com/powershell/archive/2006/04/25/583225.aspx
    $stream = $null;
    $cryptoServiceProvider = [System.Security.Cryptography.MD5CryptoServiceProvider];
    $hashAlgorithm = new-object $cryptoServiceProvider
    $stream = $file.OpenRead();
    $hashByteArray = $hashAlgorithm.ComputeHash($stream);
    $stream.Close();

    ## We have to be sure that we close the file stream if any exceptions are thrown.
    trap
    {
        if ($stream -ne $null) { $stream.Close(); }
        break;
    }

    # Convert the MD5 hash to Hex
    $hashByteArray | foreach { $result += $_.ToString("X2") }

    return $result
}

function SendWebRequest([string]$method, $queryParams, $ssl = $false)
{
    $url = $baseUrl
    if ($ssl -eq $true) {
        $url = $url.Replace("http", "https")
    }

    $url += "?method=$method"

    foreach ($key in $queryParams.Keys) {
        $url += "&$key=" + $queryParams[$key]
    }

    $wc = New-Object Net.WebClient

    $wc.Headers.Add("user-agent", $userAgent)
    [xml]$webResult = $wc.DownloadString($url)

    CheckResponseForError $webResult

    return $webResult.rsp
}

# Adds image information to our data file
function AddFile ([System.IO.FileInfo]$file, $smugId) { 

    $a = 1 | Select-Object Name, SmugId, LastModifiedTime;
    $a.Name = $file.Name
    $a.SmugId = $smugId
    $a.LastModifiedTime = $file.LastWriteTimeUtc.ToString()

    $script:datFile += $a
#    $script:datFileDirty = $true

    #we are now saving the file after each upload to prevent duplicates when there is a failure
    AppendDataFile $datFilePath $a
}

# writes the data file to the local directory
# each directory will have a data file with information for images contained in it
function SaveDataFile($filePath, $clearFile=$true)
{
    if ($script:datFileDirty -eq $false) { $script:datFile = @(); return }

    [System.IO.File]::Delete($filePath)

    $sortedFile = $script:datFile | sort-Object -property Name
    $sortedFile | Export-Csv $filePath 

    $script:datFileDirty = $false

    # mark the file as hidden
    ls $filePath | foreach { $_.Attributes = $_.Attributes -bor [System.IO.FileAttributes]::Hidden }

    if ($clearFile -eq $true) {
        # clear the variable
        $script:datFile = @()
    }
}

# appends a new row to the data file
function AppendDataFile($filePath, $record)
{
    if (test-Path $datFilePath) {
        $newLine = [System.String]::Format('{0},{1},"{2}"', $a.Name, $a.SmugId, $a.LastModifiedTime)
        Add-Content $filePath $newLine
    }
    else
    {
        $script:datFileDirty = $true
        SaveDataFile $filePath $false
    }
}

# ensure our web request was successful
function CheckResponseForError($xmlResponse)
{
    if ($xmlResponse.rsp.stat -eq 'fail')    {
        throw $webResult.rsp.err.msg
    }
}

#endregion

#region Login/Logout

function Login()
{
    if ($script:SessionId -ne $null) { return }

    $ht = @{APIKey=$ApiKey;EmailAddress=$EmailAddress;Password=$Password}
    $loginResult = SendWebRequest "smugmug.login.withPassword" $ht $true

    if ($loginResult.stat -eq "ok") {
        $script:SessionId = $loginResult.Login.Session.id
    }
    else {
        Throw "Error on login: " + $loginResult.Message
    }
}

function Logout()
{
    if ($script:SessionId -eq $null) { return }

    $ht = @{SessionID=$script:SessionId}
    $logoutResult = SendWebRequest "smugmug.logout" $ht
}

#endregion

#region Images

# this method is only needed if we cannot find the PowerSmug.dat file.
# preventing us from uploading duplicate images
function GetImage($name, $album)
{
    Login 

    $image = $script:imageList.Images | Where-Object { $_.FileName -eq $name }
    if ($image -ne $null) { return $image }

    # we are using heavy because we need the file name
    $ht = @{SessionID=$script:SessionId;AlbumID=$album.id;Heavy=1;AlbumKey=$album.Key}
    [xml]$script:imageList = SendWebRequest "smugmug.images.get" $ht

    return $script:imageList.Images.Image | Where-Object { $_.FileName -eq $name }
}

function UploadFile($file, $albumName)
{
    $album = GetAlbum $albumName
    # $image = GetImage $file.Name $album    
    # if ($image -ne $null) { return $image.id }

    $url = "http://upload.smugmug.com/" + $file.Name

    $wc = New-Object Net.WebClient

    $hash = Get-MD5 $file

    $wc.Headers.Add("user-agent", $userAgent)
    $wc.Headers.Add("ContentMd5", $hash)
    $wc.Headers.Add("X-Smug-FileName", $file.Name)
    $wc.Headers.Add("X-Smug-AlbumID", $album.id)
    $wc.Headers.Add("X-Smug-SessionID", $script:SessionId)
    $wc.Headers.Add("X-Smug-Version", "1.2.0")
    $wc.Headers.Add("X-Smug-ResponseType", "REST")
    $webResult = $wc.UploadFile($url, "PUT", $file.FullName)
    [xml]$webResult = [System.Text.Encoding]::ASCII.GetString($webResult)

    CheckResponseForError $webResult

    return $webResult.rsp.Image.id
}

function UploadExistingFile($file, $id)
{
    Login 

    $url = "http://upload.smugmug.com/" + $file.Name

    $wc = New-Object Net.WebClient

    $hash = Get-MD5 $file

    $wc.Headers.Add("user-agent", $userAgent)
    $wc.Headers.Add("ContentMd5", $hash)
    $wc.Headers.Add("X-Smug-FileName", $file.Name)
    $wc.Headers.Add("X-Smug-ImageID", $id)
    $wc.Headers.Add("X-Smug-SessionID", $script:SessionId)
    $wc.Headers.Add("X-Smug-Version", "1.2.0")
    $wc.Headers.Add("X-Smug-ResponseType", "REST")
    $webResult = $wc.UploadFile($url, "PUT", $file.FullName)

    [xml]$webResult = [System.Text.Encoding]::ASCII.GetString($webResult)

    CheckResponseForError $webResult

    return $webResult.rsp
}

#endregion

#region Album

function GetAlbumList($forceRefresh=$false) {
    Login

    if ($forceRefresh -eq $false) {
        if ($script:albumList -ne $null) { return }
    }

    $ht = @{SessionID=$script:SessionId}
    $script:albumList = SendWebRequest "smugmug.albums.get" $ht
}

function GetAlbum($name)
{
    #before we create an album ensure it doesn't already exist
    GetAlbumList

    $album = $script:albumList.Albums.Album | Where-Object { $_.Title -eq $name }
    if ($album -ne $null) { return $album } 

    Write-Host "Creating album: $name"
    $ht = @{SessionID=$script:SessionId;Title=$name;CategoryID=0;Public=0;
    X2Larges=0;X3Larges=0;Originals=0;Watermarking=$watermark;
    WatermarkID=$watermarkId;WorldSearchable=$worldSearchable;SmugSearchable=$smugSearchable}
    $result = SendWebRequest "smugmug.albums.create" $ht

    # be sure we refresh the album list after creation
    GetAlbumList $true

    return $result.Album
}

#endregion

#region Process File

function ProcessFile([System.IO.FileInfo]$file, $albumName)
{
    $photoObject = $script:datFile | Where-Object { $_.Name -eq $file.Name }

    if ($photoObject -ne $null) {
        if ($photoObject.LastModifiedTime -ne $file.LastWriteTimeUtc.ToString()) {
            # file has been modified, so re-upload the file
            write-Host "Updating existing file: " $file.FullName
            UploadExistingFile $file $photoObject.SmugId
            $photoObject.LastModifiedTime = $file.LastWriteTimeUtc.ToString()

            # mark the dat file as dirty so it will be saved after processing this folder
            $script:datFileDirty = $true
        }
    }
    else {
        #file doesn't exist in local file, upload to SmugMug
        write-Host "Uploading new file: " $file.FullName
        $id = UploadFile $file $albumName
        AddFile $file $id
    }
}

#endregion

#region Main Script

# this section will look through all sub-directories of $PhotoDirectory and upload the images to SmugMug
Get-ChildItem -recurse $PhotoDirectory | Where-Object { $_.Attributes -band [System.IO.FileAttributes]::Directory } | foreach {
    # don't process folders that end in _
    if ($_.FullName.EndsWith("_") -eq $false) {
        $datFilePath = $_.FullName + "\PowerSmug.dat"
        if (test-Path $datFilePath) {
            # casting as array to ensure we have an array returned
            [array]$script:datFile = import-Csv $datFilePath
        }

        $albumName = $_.FullName.Remove(0, $PhotoDirectory.Length).Trim('\')

        $path = $_.FullName + "\*"
        foreach ($file in get-ChildItem $path -include $filesToInclude) {
            ProcessFile $file $albumName
        }
        SaveDataFile $datFilePath
        $script:imageList = $null
    }
}

Logout

$date = Get-Date
Write-Host "Script Completed: $date"

trap [Exception] {
        $date = Get-Date
        $Msg = $date.ToString() + " ; " + $_.Exception.GetType().FullName + " ; " + $_.Exception.Message
        Add-Content $logFile $Msg
        SendEmail $EmailAddress "PowerSmug Error" $Msg
        break
    }

#endregion

—–

So here is a screenshot of PowerShell Analyzer running with PowerShell V2 CTP3. The new features are all related to the help features of advanced Functions.

• Region support for multiline comments <# #>
• Syntax Coloring for help documenting keywords (i.e.  .DESCRIPTION )
• Code Completion for help documenting keywords.
• Rich Rendering of advanced function help from get-help in HTML (any advanced function that is in the RunSpace)

So there. you go. However the help rendering is only in our really old 3 year old Help rendering engine. If you like it wait for our HelpFusion app which will be separate and be able to be used independently or from any PowerShell host. Some of you have seen it, but the rest of you will have to wait until we finish rewriting it for WPF.

Karl

This is your Admin Life

And you open the door and you step inside
We’re inside our servers

Now imagine that that Blue Screen is a white ball of healing light
That’s right, that exception itself is a white ball of healing light

I don’t think so

This is your job , Good to the last cpu cycle.
It doesn’t get any better than this.
This is your job and its ending one click at a time.

This isn’t your favourite tech conference. This isn’t no geek class.
Where you are now, you can’t even imagine what the bottom will be like
Only after disaster, will your server need resurrected.
Its only after you’ve lost everything that you’ll learn to script anything.
Nothing is static, everything is Dynamic
Without no agile script, it’s all falling apart.

This is your job.
(Without PowerShell)
It doesn’t get any better than this.
This is your job
And its ending one click at a time.

You are not a beautiful and unique engineer.
You are the same decaying GUI based admin  as everybody else.
We are all part of the same time consuming life draining Slavehood
We are the all cringing,ever working info-saviours of the world

You are not your dollarstore tech certification.
You are not your Antivirus failure.
You are not your dumbed down GUI management tools.

You are not your HR employee primary key
You are not your Active Directory login.
You are not your CIO’s latest tech fad.
You are not your hungover 70′s unix shell script.

You have to Code PowerShell.
You have to Code PowerShell.

You have to realize that someday GUI admins will be unemployed
Until you know that, you are useless.

I say never let me be GUI dependant
I say may I never be content.
I say deliver me from MMC console ripoffs.
I say deliver me from VBscript.
I say deliver me from misunderestimating linux zealots.
I say you have to PowerShell
I saw grow, and let the scripts run where they may

This is your job.
(Without PowerShell)
It doesn’t get any better than this.
This is your job
And its ending one click at a time.

You have to Code PowerShell
You have to Code PowerShell

I want you to script me as hard as you can.
I want you to script me as hard as you can.

Welcome to #powershell Club. If this is your first night, you have to code.

Enjoy – Karl

However Microsoft in their wisdom has made ISE rather extensible through the $PSISE variable, and many people already have added some very cool functionality to ISE through these.

When I first demo’d what was then MSH analyzer to Microsoft back in the first few months of 2006, the feature that seemed to stand out the most to the team was the ability to select an area of code and just run that. Thankfully that level of execution control is now in ISE as F6, but I wanted more, so i’m going to share with you a script that build a few months ago to add a couple of features.

F7 run the current physical line.

this basically will run the line where the caret current is at.

Real Time Strategy like control.. CTRL 1 , CTRL 2 etc

This here allows you to use comments to create regions, then EXECUTE those regions with a simple hotkey. I use this extensively. Often i am working on building a function, so I edit the function, press Ctrl 1 to apply the function, then if that was successful, press Ctrl 2 , then maybe Ctrl 3 to run some tests to make sure my changes to the function are what i am expecting.

This gives me a great AGILITY , putting what Jeffery Snover calls the Admin Development Model , but which is really REPL(Repeat Evaluate, Print , Loop ) rediscovered, on agile steroids.

function invoke-caretline
{
invoke-expression $([Regex]::Split($psISE.CurrentOpenedFile.Editor.text,"`r`n" )[$psISE.CurrentOpenedFile.Editor.caretline-1])
}
$psISE.CustomMenu.Submenus.Add("Run single line", {invoke-caretline} ,  'f7')
function invoke-region([int] $num)
{
$ed = $psISE.CurrentOpenedFile.Editor
$lines = [Regex]::Split($ed.text,"`r`n" )
$foundfirst = -1
$foundlast = -1
for($count = 0;$count -le $lines.length-1;$count++)
 {
   if ($lines[$count].startswith("#region") -and $lines[$count].contains("@$num"))
   { $foundfirst = $count;break}
 }
 if($foundfirst -gt -1)
 {
 for ($count = $foundfirst; $count -le $lines.length-1;$count++)
    {
    if ($lines[$count].startswith("#endregion") )
   { $foundlast = $count;break}
    } 

 if ($foundlast -gt -1)
   {
     $torun = ""
     $lines[$foundfirst..$foundlast] | % { $torun+=$_ + "`r`n"}
     invoke-expression $torun
   }
 } 

}
 $psISE.CustomMenu.Submenus.Add("run region 1", {invoke-region 1 },  'ctrl+1')
 $psISE.CustomMenu.Submenus.Add("run region 2", {invoke-region 2 },  'ctrl+2')
 $psISE.CustomMenu.Submenus.Add("run region 3", {invoke-region 3 },  'ctrl+3')
 $psISE.CustomMenu.Submenus.Add("run region 4", {invoke-region 4 },  'ctrl+4')
 $psISE.CustomMenu.Submenus.Add("run region 5", {invoke-region 5 },  'ctrl+5') 

Script @ PoshCode: View Script | Download

Sometime I’ll wrap all this up into a module, and add other PowerShell Analyzer-like functionality such as running the current PARAGRAPH. So often in an earlier PSA, and in SQL Query Analyzer, i’m highlighting again and again the SAME paragraph query and running it over and over again. Being able to just run the current paragraph saves that time.

Technorati Tags: powershell,shelltools,ISE,powershell analyzer

SURVEY: http://spreadsheets.google.com/viewform?key=pgTpVBomNgDwUA9uQNRKAbw&hl=en

Taking an app from an internal application to a shrink-wrap ready for
the masses state is a lot of work, and updating/supporting/marketting
a product even more so. So after the huge sucess of PowerShell Plus
which is now safe in Idera’s hands we need your help to decide what we
are going to release next. We plan to release some free projects, even
some opensource apps, but will likely look at productizing a project
so we can continue to feed our families. Please take the time to take
our survey

—–
As many of you know, PowerShell Plus has been a great success and is
now developed and sold by Idera, and we’ve made PowerShell Analyzer
100% free!. Despite PowerShell Analyzer not having much active
development done for almost 2 years, surprisingly it is still very
popular with a large user base. Based on your feedback and the
following thoughts we need to decide where to invest our development
time, and which internal prototypes to bring to the community.
•       We have invested a lot into PowerShell Plus, from vision and
incubation to a mature product and we don’t want to compete in the
marketplace directly with PowerShell Plus.
•       PowerShell editors are now a generic commodity. In addition to
the awesome PowerShell plus. There are many free “good enough”
solutions, including some open source ones, Microsoft’s upcoming
Graphical PowerShell Integrated Scripting Environment and some other
“lower common denominator” solutions that are still free.
•       We have created and continue to innovate PowerShell technology
that can live just as well outside an editor product as in one.

There are many questions on here. Feel free to not answer them all,
it’s the top questions that are most important to us, but the more you
fill in, the happier you’ll make us.

SURVEY: http://spreadsheets.google.com/viewform?key=pgTpVBomNgDwUA9uQNRKAbw&hl=en

-Karl

With the phenomenal success of PowerShell Plus and subsequent transfer to Idera, PowerShell Analyzer is now 100% free. You can read more and get it from our recently updated website – http://www.shelltools.net . In coming weeks we are going to do some surveys to help decide where we want to go as a company with PowerShell IDEs.

Sincerely,

Karl

Background

So what’s stopping PowerShell or practically anything from being portable? dependence on a particular file structure and the registry. Basically the technique I  “HOOK” apis so that whenever the process tries to call certain APIs (the filesystem and registry ones) the code in memory is changed to jump to custom code instead of the address of the DLL function export where DLL has been loaded. From there custom checks are done to see if its a file or registry setting to do with PowerShell, and if so the code delivers it up, as if it were there, even though its not.

This is a technique that as a programmer I have been doing for a long time. It involves a lot of assembler, historically being able to inject a DLL into a process and in memory rewrite the code, but it works great. The first time I worked out this technique as a programmer was back in the days of windows 95 which wasn’t unicode. I made an application that could enable Chinese and Japanese characters on english windows. Effectively I hooked the TextOut API, and if it was a process that had been chosen to say display in Japanese, and the font chosen was one that was chosen for this purpose then I custom drew the Japanese or Chinese Glyph otherwise I just called the real TextOut API call. Another technique when working on VisualJockey many years ago, I wanted to be able to pipe the output on a standalone graphics program into VisualJockey so we could do some video processing on it. The problem is that app drew to fullscreen directX itself, so I had to “hook” the directX apis, so that when it created the surface it didn’t make it fullscreen, and when it rendered it rendered to Texture instead of screen, and then some extra code to retrieve what it had rendered. Another Situation was changing a DB backend of an application without the Applications source, *simply* by hooking the ODBC apis (where we also could discover the password used). Another thing I used this technique for was to add some functionality to abandoned freeware that had no source code.

Fast forward to about 2002, Josua Honger , the main architect of VisualJockey, and also the Hippotiser (I could talk a week just about these amazing programs, the Hippotiser has gone on to become a huge sensation powering realtime effects for live T.V, large concerts, events like the nobel peace prize, broadway shows, and the worlds largest audiovisual setup- Love by Cirque de Soliel in Las Vegas)  were wanting to use the engine of VisualJockey to make a demoscene demo , without the copy protection , and in a portable manner (Demoscene demos aren’t allowed to install anything), and on top of that not scare the Green Hippo (who recently purchased the VisualJockey engine and didn’t want to risk it getting out and reused). We didn’t have time to roll our own solution so we found a rather recent product called Thinstall. Thinstall used the techniques mentioned about, but it stored all the files you choose in its own encrypted virtual file system inside one file – Just what we were needing. Thinstall in those days also was cheap enough for us, even though it was a hobby project, but as a young product it didn’t quite work fully with our VisualJockey because we used some interesting techniques anyhow, but I did gain a lot of respect for it, and for its author Jonathan Clark. Over the years I’ve played with it a few times for some hobby projects , but the cost went up and up and I couldn’t justify using it.

Fast forward to 2008, the complexities and risks of deploying and configuring applications have become a real pain point for many corporations and an abundance of solutions have tried solving this. Thinstall evolved its PR to target this market – and named it Application Virtualization, and most recently got acquired by VMWARE. (and renamed ThinApp) So now that there was a great beta to try. the scary thing is HOW EASY THIS WAS. I expected that I would have to spend many hours manually tweaking what to include/exclude – setting up the behaviour of the registry virtualization, but I had something done in 20 minutes, pretty much just following a few instructions. and Click next / next /next

HOW HOW HOW HOW HOW HOW HOW HOW

So I wanted to make 4 different versions of Portable Powershell

• Powershell V1 (just powershell, don’t include dotnet 2.0 – thus dotnet 2.0 is needed to be installed on a machine for it to work)
• Powershell V2 CTP2 (just powershell, don’t include dotnet 2.0 – thus dotnet 2.0 is needed to be installed on a machine for it to work)
• PowerShell V1 (include the who dotnet 2.0 so it can run even where dotnet isn’t)
• PowerShell V1 (include the who dotnet 2.0 so it can run even where dotnet isn’t)

The Key this is to have a Fresh OS to start from, so that you don’t miss any important files , and don’t get rubbish either, so the place to build this is most definately in a VM.

So what did i do?

1. Predownloaded what was needed
   1. XP SP2 install CD
   2. VMWARE THINAPP BETA (plus free beta key)
   3. DOTNET 2.0 redistributable
   4. Powershell V1 for XP installer
   5. Powershell V2 CTP2 installer
2. Setup the OS in a VM.
3. Installed ThinAPP
4. Made a snapshot of the VM
5. started the thinapp process
6. Installed dotnet 2.0
7. Installed PowerShell V2CTP2
8. Copied over PowerShell Analyzer
9. Completed the thinapp process , and build the Portable EXE for my V2 with dotnet Portable Powershell
10. Copied my portable powerShell off the VM
11. Reverted the snapshot
12. Repeated the process but for PowerShell V1
13. Reverted the snapshot
14. Installed dotnet 2.0
15. Made a new snapshot
16. repeated the process but just installing Powershell V1 (to make a smaller less heavy portable powershell that didn’t contain dotnet 2.0)
17. reverted and repeated the process for Powershell V2

There there you have it, 4 different flavors on a Portable Powershell made in just a few hours. I can’t give them enough praise for how far Thinstall has come and how easy the process was.

Are there any other options?

Definately! Thinstall is not the sole player in this now “application virtualization” arena. The management , configuration and deployment has been bundled into apps and called “Application Streaming“. Citrix added Application Streaming, Symantec has Altiris, and Microsoft bought out SoftGrid. The “streaming techniques aren’t typically really portable since they have some sort of agent or client/server architecture but the interesting one in this mix is software, Which i think is now renamed Microsoft Application Virtualization or APP-V for short. You can read their blog here. Actually the release candidate was just released YESTERDAY.

With thinstall, I’m interesting what the pricing is going to be under VMWARE. When its in beta its definitely financially feasible for me to have my own personal portable powershell for personal use, but that’s probably not the case post RTM.

I didn’t have time to play with APP-V yet. SO MUCH CHALLENGE IS WILL SOMEBODY TRY TO VIRTUALIZE POWERSHELL WITH APP-V AND TELL US HOW IT GOES. I presume Microsoft will be more likely to allow redistribution of PowerShell through one of their own technologies

Another cheap option I would challenge somebody is to try it in sandboxie , see if sandboxie is up to the job, as its very cheap, but i don’t know if it does full “portable”

Finally there is another way, that I might implement, and that is roll my own. I wouldn’t include the dotnet framework in this one (just too much work), but I can whip up a DLL in C++ and Assembler in no time to take care of powershell’s filesystem and registry needs. Of course I couldn’t redistribute portable PowerShell but I could make it into a small PORTABLEPOWERSHELLBUILDER.EXE app, that has a button that will build a portable PowerShell for you on any computer that has PowerShell installed in a similar manner to how BartPE or ReatogoXPE can build a bootable XP CD based on the files on a particular OS install.

Apart from the challenge of doing that, and doing some fun techniques that I’ve almost forgotten, and as a PowerShell tool vendor and partner of MS, I don’t want to do that. I want MS to allow PowerShell to be redistributed, in a portable manner, and if they can fit it into their schedule, do some minor reachitecture of PowerShell V2 to be naturally portable, but more on that in my next blog post.

Over and Out,

Karl Prosser / ShellTools

Technorati Tags: portable PowerShell,powershell,shelltools,thinapp,app-v

So I’ve loved portable apps from time memorial and have valued making my own apps as portable as possible – XCOPY friendly. I’ve valued this over some fancy installer. But what about PowerShell? Why can’t PowerShell be portable. Its the sort of tool that begs to be portable. Admins want a power tool, like powershell to be portable, to be able to be run on any computer without installing anything (changing ,even contaminating the state of the computer). Admins don’t want to have to worry about installing prerequisites such as dotnet 2.0 everywhere and neither do I. I want something that can be self contained , where I can run PowerShell v1 and v2 side by side if I choose, and as a builder of PowerShell hosts, I want to be able to embed, or distribute the PowerShell runtime along with my app, just like I can with a multitude of dotnet libraries and components.

Well is this possible. Yes, I’ve done it. In this blog post I’ll show some screenshots and a video about it, and talk about the WHAT and the WHY, and try to whelm up some passion in the community to encourage Microsoft to allow the PowerShell engine to be redistributed freely, easily , and portably. I know that many people will ask me – Can I download this, and I have to say NO – because we don’t have rights from MS to redistribute PowerShell, especially outside of its official packages, but the good news is that you can make this yourself, but I’m not going to tell you HOW to until tomorrow, hoping that instead of running of to recreate your own personal PowerShell nirvana you might read the rest of my rant and join the movement for a Microsoft endorsed Portable PowerShell.

But before we proceed here is a screenshot:

This beauty shows Server Core Enterprise – you can verify this isn’t a trick but is indeed server core by the operatingsystemSKU of 14 shown in the top window. (MSDN reference. ) Server Core does not have dotnet 2.0 (a prerequisite of PowerShell) installed and we haven’t applied any cool hacks or Russian reverse engineering  to get it working therefore we haven’t compromised the secure state of our servercore by installing any untested potential lasting security hole on it. We purely XCOPY across our files, or we can even run it off a USB drive. Another great benefit you see here is on the same machine we are running PowerShell V1 and V2 side by side. How many of us have had to set up a whole new machine or VM just to play with V2 CTP!!!!! and how many cough*cough have installed v2 on a production machine when we should have for lack of patience in setting up a dedicated v2 test machine?

So what are the features of this technique.

• Fully Portable
• versions that presume dotnet 2.0s preexistence (about 3MB to 10MB)
• Versions that don’t need dotnet 2.0 at all (about 100MB)
• Can run V1 and V2 side by side.
• Can run on a machine with PowerShell already installed, and your portable version has its own execution-policy and other settings.
• Can be packaged with SnapIns (so the SnapIns are portable also, no need to install or register them).
• Can be used with a custom Host , so you can have a Portable PowerShell Plus or PowerShell Analyzer.

Here is a 3 minute video showing Portable Powershell v1 and v2 and PowerShell Analyzer running side by side on a virgin XP SP2 box that doesn’t have dotnet 2.0 preinstalled.

Portable PowerShell from karl prosser on Vimeo.

So now you are saying, GIVE THIS TO ME NOW. Sorry but I can’t but in my next blog entry within a couple of days I will tell you how you can roll your own Portable PowerShell.

Please leave a comment on this blog if you are in favor of Microsoft relaxing its redistributable rules when it comes to PowerShell. Technically PowerShell doesn’t have much to stop it being Portable. Its fully dotnet, and although its installed in windows\system32 directory that is more a “political” feature , earlier betas would install elsewhere, and technically it wouldn’t be hard to make it a control in VS.NET that a custom host could merge into their project and be fully portable. There are many many possible use-cases for such portable uses  (both from the perspective of admins as well as developers creating PowerShell enabled and powered applications in the growing PowerShell ecosystem). If MS can’t make any changes technically to make it as easy as i suggest in V2, can they at least GIVE FULL REDISTRIBUTABLE RIGHTS FOR POWERSHELL as they do things such as the SQL server client side report viewer control in VS.NET.

All in favor say so in a comment!

And come back for more in a day or two.

Over and Out,

Karl Prosser / ShellTools.

Technorati Tags: PowerShell,Portable PowerShell,dotnet,Server core,PowerShell Analyzer

Some typical ways of doing in PowerShell have been either something like the following trick:

$a = 1 | select a , b , c , d

or with using the Add-member cmdlet as below:

$a | add-member -membertype noteproperty -name status -value done

however both are really slow. There is another way to do it in script, and that is directly with the PSobject, but still PowerShell (especially version 1) has a huge overhead when creating new objects with new-object but below is an example none the less.

$obj = new-Object system.Management.Automation.PSObject

$note = new-object System.Management.Automation.PSnoteproperty "karl" , "a value"

$obj.psobject.members.add( $note );

But if you really want to do speed, or if you have need to generate these objects in a cmdlet regardless of speed here is how you can do it in C#.

public static PSObject newPsCustomObject2()

        {

            //Creating a PSobject without any parameters in the constructor creates a PSCustomObjectg

            PSObject obj = new PSObject();

            //PSNoteProperties are not strongly typed but do contain an explicit type.

            obj.Properties.Add(new PSNoteProperty("age",24));

            obj.Properties.Add(new PSNoteProperty("name","jon"));

            //Alias allow you to cast one property as another as well as just plain aliasing

            obj.Properties.Add(new PSAliasProperty("ageasstring","age",typeof(string)));

            return obj;

        }

Some notes about the above, I didn’t show how you could add ScriptProperties or ScriptMethods yet as I wanted to keep it simple and not cover creating scriptblocks. Before I go lets performance test this baby compared to creating this in pure PowerShell.

So in the:

1) first corner we have creating the object with select-object, then setting the properties.(but we can’t set the alias)

2) Creating the object with new-object, then using add-member to add all the properties.

3) calling our static method above.

#select-object version

for($i = 0;$i -lt 50000;$i++) { $a = 1 |Select-Object age, name; $a.age = 24; $a.name = "john" }

#add-member version

for($i = 0;$i -lt 50000;$i++)

  { $a = new-Object psobject;

    $a | add-member -membertype noteproperty -name age -value 24

    $a | add-member -membertype noteproperty -name name -value "john"

    $a | add-member -membertype aliasproperty -name "ageasstring" -value "age" -secondvalue "string"

  }

#Our fast version

for($i = 0;$i -lt 50000;$i++) { $a = [snapinini.newobjecthelper]::newPsCustomObject2(); }

so we are creating 50,000 objects and the results are.

and i used to complain with the performance hit of a address lookup for a method in a C++ virtual method table!!

at worst the official add-member technique is over 60 times slower than calling C#, and thats not really RAW C#, thats still powershell invoking a C# method 50,000 times, and powershell managing a loop.

if fact just to test i added another test

$a = [snapinini.newobjecthelper]::newPsCustomObject3();

where newPSCustomObject3() moves the 50,000 loop to inside C#.. and here the speed is 0.95 seconds, so about half the speed of invoking the C# method from powershell each time – this speed difference I am happy with though. The PowerShell team seem to have done a good job of invoking C# methods quickly.

Another day I should investigate the speed of creating objects that have been created with the extended type system.

I’d love if somebody can run these tests in v2.

Also sometime soon I shall share a helper function you can use to quickly generate a PScustomObject with properties and values you specify in script.

-Karl

In V1 there seems to be extreme slowdowns when invoking cmdlet, functions, any type of scriptblock and when using the pipeline. If you write a one liner that is easy to read, very elegant, but uses a lot of “powershelly” techniques its performance is often terrible, compared to it you write it out as a longer script using more traditional imperative style with “C”ish loops as the like. This brings up the whole concept of what is cheaper and more valuable – CPU cycles that keep getting cheaper, or human time in writing and maintaining code – dynamic languages and especially shells will definitely answer that programmer productivity is more valuable, and thus performance can come second.(read about it in the context of python here.) However 59 millisecond average to call an empty powershell function on a dual core machine is pushing this truth to an absurdity. PowerShell should as a language should NOT be slower than BASIC on my Commodore-64 – an 1MHZ 8 bit machine.

Here is some background of where we are coming from. Brandon Shell Started it all here. And after we spend hours running tests and bantering about the subject on the #powershell IRC room on freenode, Mow covered some cool stuff here.

Basically the results of my tests showed that new-object is very slow in V1, but calling any CMDLET, even a simple C# cmdlet with one line of code is extremely slow, and about 30 to 50 times slower than calling that SAME  line of code from powershell as a static method on a C# assembly. Additionally if you take that 50 times faster static method call, and wrap in it a simple powershell function, you loose all your spend gains and its even slower than calling the new-object CmdLet.

The great thing from Mows tests is that in V2 it seems that on the language side of things, scriptblocks,functions and the pipelines have spend up drastically (in the magnitude of about 2000% to 3000%. And cmdlet invocation has spend up also, but is about 6 times slower than just calling C# static methods. GO V2 GO V2 , but is it enough?

Given that V1 is going to be important for a long time, I think that powershell scripters need to still try to script in a “PowerShelly” way, but when they determine that something really has to be performant , they need to know what workarounds they can do in PowerShell to speed things up, understanding where the bottlenecks in PowerShell are.

But this post isn’t about those performance solutions – I’m sure that we will cover a lot of them over the coming of the months. I want to RANT.

One of the reasons I think PowerShell has so many language quirks (and thus related gotchas when learning to do advanced stuff and solving bugs) is because it is Defined by Implementation instead of being Defined by Specification. To be honest, PowerShell is more of a platform , than a language or even a shell, and as it brings some new ideas and melds existing ideas in totally new ways, almost experimental ways, I don’t think it could have been defined any other way. However its quirks and yes also its performance is a result of that. I believe it needs to be reviewed by traditional language designers and not be excused “because its a shell language”. I believe that the importance of PowerShell is growing phenomenally and being part of Microsoft’s common engineering requirement I strongly believe such close working with the CLR team should be done, and even if PowerShell is defined by Implementation and will likely be in version 2 also – SPEND THE TIME TO AT LEAST DEFINE THE SPECIFICATION, DOCUMENT THE INTENDED (and thus real) BEHAVIOUR, RELEASE A FULL GRAMMAR, RELEASE OFFICIAL XSD SCHEMAS of the XML ELEMENTS, and if specification is what defines it, and that specification is best represented in the automated unit tests – maybe , just maybe even release such tests  , as per other dynamic languages. I think some of this stuff should at least be done BEFORE V2 is released. I mean getting a V2 and not even having a V1 grammar. </end of rant>

Disclaimer:

Despite the above concerns, I love PowerShell, and the general performance doesn’t bother me. Being able to code at the speed of thought, and do things with far less code than C#, and do things interactively and dynamically totally win out. PowerShell does introduce many new tangents on concepts and mash together some amazing things, its amazing they got it as right as they did the first time. I know if I had implemented such a platform/language it would be less consistent and probably slower than a ZX81. PowerShell V2, even though only in CTP2 already shows great performance enhancements.

If that disclaimer gave you the warm fuzzies, don’t get too comfortable, i have another pet peeve to blog about, and that is the fallacy called “Restricted Runspaces” and how the lack of being able to truly sandbox PowerShell has me running in the direction of IronRuby – But that’s for another day.

-Karl / Shell Tools

So how does this work?

1) you have to load an assembly into memory in powershell that contains your snapin.
2) you add the cmdlets directly into the runspace that is running and tell powershell to update its list of cmdlets.

Here is the C# code for a sample barebones SnapInini.

using System;

using System.Collections.Generic;

using System.Text;

using System.Management.Automation;

using System.Management.Automation.Runspaces;

namespace Snapinini

{

    public class DynamicCmdLet

    {

        public static void Load()

        {

            CmdletConfigurationEntry conf = new CmdletConfigurationEntry("dummy-cmdlet", typeof(ForeachDictionaryCmdLet), null);

            Runspace.DefaultRunspace.RunspaceConfiguration.Cmdlets.Append(conf);

            Runspace.DefaultRunspace.RunspaceConfiguration.Cmdlets.Update();

            Runspace.DefaultRunspace.CreateNestedPipeline(

                "new-alias dcmd dummy-cmdlet; write-host 'snapinini loaded'",

                false).Invoke();

        }

    }

    [Cmdlet("dummy", "cmdlet")]

    public class ForeachDictionaryCmdLet : System.Management.Automation.PSCmdlet

    {

        protected override void EndProcessing()

        {

            WriteObject("hello from the dummy cmdlet");

        }

    }

}

In the above sample I have a very very simple cmdlet. You can see that i get the defaultrunspace, go into its RunspaceConfiguration and add the cmdlets and update the list. I am additionally running some powershell script that adds an alias to the cmdlet and writes a message to the screen just as an example showing you that you can do more stuff if you wish. In the above code the load is a static method so its easy to call from powershell once you’ve loaded the assembly, but in all honesty the Load() code could just as well have been written in the calling PowerShell.

So how do we load and use this in PowerShell?

[system.Reflection.Assembly]::LoadFrom("snapinini.dll")

[snapinini.DynamicCmdLet]::load()

dummy-cmdlet

dcmd

Where to from here? This example is very simple, you could easily add multiple cmdlets into the equation, specify help files, add custom type definitions etc. Another thing I had experimented with is taking a real snapin and using reflection to see the cmdlets in it and adding them directly, however unless you know exactly what a snapin does this is dangerous because in its registration it might set up a bunch of other things also that are important.

Another thing I should cover next time is a safe way to load assemblies from any location and ensure that all their references get resolved seamlessly.

-Karl

So how does this work?

1) you have to load an assembly into memory in powershell that contains your snapin.
2) you add the cmdlets directly into the runspace that is running and tell powershell to update its list of cmdlets.

Here is the C# code for a sample barebones SnapInini.

using System;

using System.Collections.Generic;

using System.Text;

using System.Management.Automation;

using System.Management.Automation.Runspaces;

namespace Snapinini

{

    public class DynamicCmdLet

    {

        public static void Load()

        {

            CmdletConfigurationEntry conf = new CmdletConfigurationEntry("dummy-cmdlet", typeof(ForeachDictionaryCmdLet), null);

            Runspace.DefaultRunspace.RunspaceConfiguration.Cmdlets.Append(conf);

            Runspace.DefaultRunspace.RunspaceConfiguration.Cmdlets.Update();

            Runspace.DefaultRunspace.CreateNestedPipeline(

                "new-alias dcmd dummy-cmdlet; write-host 'snapinini loaded'",

                false).Invoke();

        }

    }

    [Cmdlet("dummy", "cmdlet")]

    public class ForeachDictionaryCmdLet : System.Management.Automation.PSCmdlet

    {

        protected override void EndProcessing()

        {

            WriteObject("hello from the dummy cmdlet");

        }

    }

}

In the above sample I have a very very simple cmdlet. You can see that i get the defaultrunspace, go into its RunspaceConfiguration and add the cmdlets and update the list. I am additionally running some powershell script that adds an alias to the cmdlet and writes a message to the screen just as an example showing you that you can do more stuff if you wish. In the above code the load is a static method so its easy to call from powershell once you’ve loaded the assembly, but in all honesty the Load() code could just as well have been written in the calling PowerShell.

So how do we load and use this in PowerShell?

[system.Reflection.Assembly]::LoadFrom("snapinini.dll")

[snapinini.DynamicCmdLet]::load()

dummy-cmdlet

dcmd

Where to from here? This example is very simple, you could easily add multiple cmdlets into the equation, specify help files, add custom type definitions etc. Another thing I had experimented with is taking a real snapin and using reflection to see the cmdlets in it and adding them directly, however unless you know exactly what a snapin does this is dangerous because in its registration it might set up a bunch of other things also that are important.

Another thing I should cover next time is a safe way to load assemblies from any location and ensure that all their references get resolved seamlessly.

-Karl

function get-psVersion

{

if ((get-Variable psversiontabl[e]) -eq $null)

   {

     new-Object system.Version "1.0.0.0"

   }

   else

    {

    $psversiontable.psversion

    }

}

-Karl

http://www.powershell.com

-Karl

http://www.powershell.com/downloads/psp1.zip

and if you happen across any bugs, we love it if you took a minute to submit them here.

Enjoy,

Karl , Tobias and Eddie / Shell Tools, LLC

http://www.citrix.com/English/ps2/products/product.asp?contentID=1297816

and now i can’t find the page about Full Armor Workflow Studio on their website as before.

Interesting stuff,

Karl

In PowerShell Plus you can see Variables and properties. by enabling it from the menu (Toolbars->Variables+Property) or easily toggle it with CTRL-T

You can see it has rich features where you can search and filter different variables, then when you click on one have it show up in the property grid. However we aren’t going deep into that today. we are covering the “View Current Pipeline” option

When you click this button, it toggles from showing the variables. to the actual results of the pipeline. So whenever you run something.. the actual results are shown as usual on the left as text, but also the actual dotnet objects that are returned by the command show up in the variable pane. and when you click on an item there, you can see all the properties for that particular object.

So in the above example I ran a command that on the first 5 processes in the system, and the current date. In the variable explorer you can see those 5 processes and the date and time. Also the 2nd process has been clicked on, and you can see all its properties in the property grid, including descriptions of the properties. You get to see a lot more data than PowerShell gives you as text.

You can download Powershell Plus from http://www.powershell.com

-Karl

Technorati Tags: powershell,powershell plus,shell Tools,IDE,scripting

$a = 1 | select-object name, age , sex

$b = 1 | select-object species, name , age

$a.psobject.properties | % { $_.name } | ? {$($b.psobject.properties | % { $_.name } ) -notcontains $_ }

$b.psobject.properties | % { $_.name } | ? {$($a.psobject.properties | % { $_.name } ) -notcontains $_ }

Here we simply create a couple of objects that have some similar and different properties. then the first example shows the properties in A that aren’t in B, and the next shows the properties in B that aren’t in A.

The main trick here is .psobject … all objects have a “hidden” psobject property that contains some cool PowerShell related stuff, including the properties. There are some good blog entries around on psobject and its definitely worth a deeper look. This technique is also the basis on a script i will introduce soon, my join-object function.

-Karl

Technorati Tags: powershell

Additionally, if you have already used your 45 Day trial, we have EXTENDED it another 45 days.

PowerShell Plus is now available with a 45 Day trial as well, and Additionally its available fully free for Non Commercial use as well.

So download both of these today and Enjoy

• 
  

  PowerShell Analyzer 1.0 – Direct Download

• 
  

  PowerShell Plus Beta – Direct Download

PowerShell Analyzer Screen-shots.

To get a grasp of what PowerShell Plus can do, Check out its trailer. its about 4 minutes, and definitely worth the time in our opinion.

Technorati Tags: Powershell Analyzer,Powershell Plus,Powershell Debugging