There’s no help yet, and very little error handling. But if you needed long paths (I know one of you did, because Jacques Willemen asked for it), then here are: Get-LongPath, Copy-LongPath, Move-LongPath, Remove-LongPath, Get-ContentLongPath, Set-ContentLongPath … and … uhm … Format-Color

Download the Experimental.IO Long Path Module

The script source is on PoshCode so please help me: write the next version of this module by contributing there.

There are a lot of XPath tutorials around the web, so there’s no need for me to get into that very much, but I just wanted to write a brief note about using XPath with documents that have namespaces (particularly, from .Net). The problem is that in order to select nodes that have a namespace assigned, you must use a namespace prefix and a NamespaceManager. So even if it’s the default namespace, if there’s an xmlns=”...” on the document, you have to create and use a prefix.

The bottom line is this: if you have an XML document that looks like this:

That bit at the top where it says: xmlns="http://schemas.microsoft.com/win/2004/08/events/event" is assigning a default namespace. Sometimes you’ll see something like this (eg: in RSS):

This one assigns a specific prefix “media” to the namespace url “http://search.yahoo.com/mrss/” ...

Selecting nodes with namespaces

In either case, if you want to select a node that’s assigned to a namespace (which is ALL the nodes in the first example, but just the ones that start with media: in the second example) in .net, you have to specify the namespace in order to select those nodes with XPath. PowerShell 2.0 has a Select-Xml cmdlet which accepts -Namespaces as a parameter: you simply provide a hashtable of names to urls.

If you had loaded the first document above into $xml, you could select the BootStartTime and BootEndTime using an XPath query like this: //e:Data[Name = ‘BootStartTime’ or Name = 'BootEndTime'] but we have to DEFINE that “e” namespace. To do so using Select-Xml you just pass it into the command

Of course, you don’t have to use Select-Xml, you can do this in plain .Net without cmdlets (and this is what you would have to do in C#). In fact, depending on the situation, it might even be simpler:

Selecting nodes regardless of namespaces

There are, however, two ways that you could avoid specifying the namespaces. The first is to just avoid specifying the node name at all. In that first example, that would be fairly easy, because the “BootStartTime” and “BootEndTime” names are unique to the nodes we’re interested in (even if there were boatloads of identical events, you’ll never have a Name=“BootStartTime” attribute on the tag, for instance). The second way is to filter using the local-name function, and specify just the “local” name (which is the non-namespace-qualified part of the name).

So to ignore the tag name, we can just use a * for a wildcard. The only real difference is that we don’t need the namespace, and the XPath pattern will be different:

Or to specify the local name, we can use the Local-Name function. Again, we don’t need a namespace, we are just changing the XPath to be a more specific match:

How do I find an item (in an array) based on one of it’s properties?

Actually, the question was rather more complicated than that. They were importing a bunch of users from a csv file, and wanted to sort them and search them based on a specific column. There are many ways to skin this cat. Imagine that you have a CSV file, and have imported it, like so:

Now, imagine that the CSV file has thousands of users in it, and that you need to not only sort the data by first name or last name on demand, but you also need to pull users from the list (by name) on demand.

These are trivial tasks in PowerShell:

This works but will have some performance issues when the list gets too long, because your search algorithm is … well, we could say it’s O(n), or just say it’s slow, because you’re basically going through the whole list every time. And I do mean the WHOLE list. You were looking for “Bob” ... but the Where-Object cmdlet doesn’t know your data is sorted, and doesn’t know you only want one user, so it’s going to iterate the whole list, because Select-Object can’t signal it to stop.

There are several ways to solve this, but what it comes down to is that you need a (better) search algorithm than Where-Object can implement: simply put, you’d like to use a binary search, since the data is already sorted.

Binary Search

I’m not going to get into this much, but to put it simply: a binary search algorithm is pretty much the fastest search you can have, but it depends on the data being pre-sorted in order. It works by starting in the middle, and comparing the middle item to the item you are searching for. If what you’re searching for comes BEFORE that item, then it discards the second half of the items, and examines the middle item of the first half. In this way, it eliminates half the items each time, and returns the correct item (if it exists) in roughly (log n) steps.

So how do we do that in PowerShell?

Well, that’s easy: Just use the static method: [Array]::BinarySearch… The only problem is, in order for BinarySearch to work, the items have to be not only sorted, but comparable. Because we’re trying to compare PSObjects, you can’t just compare two items from the $users array and determine the correct order…

If you wanted to use [Array]::Sort you could use an overload that lets you pass in a second array (of comparable items) to serve as the keys for the non-comparable items, but this won’t work for BinarySearch:

So you need what is an “IComparer.” That is, a class which implements a “Compare” method which can be used to determine the order of the objects. Sadly, this requires a custom type — something you can’t do in pure PowerShell script, believe it or not. PowerShell does not have the ability to create custom classes (which is how you can tell it’s not a real programming language), so when you need a custom type in PowerShell you have to drop to another .Net language like C# or Python.

In PowerShell 2.0 there is a cmdlet “Add-Type” which can take a string representing C# source-code, and compile it in memory for immediate use, but in PowerShell 1.0 you need to have a script version of it, which I called New-Type, to avoid confusion because it only handles one of Add-Type’s four usage models:

Once you have Add-Type, you can create a ScriptBlock-based implementation of IComparer, by passing this as a string:

So now you have everything you need, and you can write your custom comparer, and do binary search. The one thing you need to be aware of is that when you’re doing binary search, you’re going to want to pass in the thing you’re searching for (ie: the first name) not an Object with a FirstName property. So your binary search needs a case for when the second parameter is a string:

Now, you may not think this is a big deal, so let me just share with you the results of searching a collection of about 49000 users:

What you see here is two things:

1. Searching for a single user using Where-Object takes pretty much as long as (re)sorting the whole array, because every single item must be checked.

1. Using BinarySearch rocks

BinarySearch is not always faster: If your array is initially unsorted, the requirement to pre-sort the array costs basically the same as any speedup you might get for a single search. Also, because of the call to the script, if the array is very small, like the four users in the sample above, it’s actually faster to just loop through them (20ms versus 24ms on my PC). The BinarySearch starts paying off pretty quickly as you scale up the number of searches and records, but it does take both more records (the break-even point for just the search is about 10, in this contrived example), and more searches (if you have to eat the cost of the initial sort).

In any case, New-Type certainly has many other uses, and the ScriptBlockComparer can be used for other things as well … although I will say that as far as I can tell, sorting is almost always better performed with the sort cmdlet than with [Array]::Sort and an IComparer.

A while ago I wrote a little class for calling console apps from a .Net application, and I’ve been using it in several of my apps (most notably in PoshConsole) and it works great, but since the only place I’ve really published it is in PoshConsole, I thought I’d write it up here, and share it with you …

Basically, it’s a slick invisible event-based wrapper around the Windows native console. What I mean is, it calls AllocConsole when it’s instantiated to create a native console, and hides the console window so it doesn’t show up. This allows you to run any console app you need to from within your app without having it popup a black window Note this doesn’t let you run graphical consoles like EDIT.COM, but it can handle interactive apps like cmd.exe, batch files, or ftp.exe). All you really have to do is create one of my NativeConsole objects, handle its WriteOutputLine and WriteErrorLine events … and use its WriteInput method to send input or commands to the console app.

You can check out how it works in my WPF-based PoshConsole, and you can get the latest version of it from that project as well (it’s in \trunk\Huddled\Interop\NativeConsole.cs) but for now, here’s the single file source code, with a more liberal set of licenses than I allow for PoshConsole.

It turned out to be an interesting problem, because even though the source code on the MSDN Library has a /C parameter to cause the application to write to stdout, the one which comes with windows doesn’t, so the only obvious way to get output is in a MessageBox. However, there is also an exit code, but the exit code doesn’t seem to end up in $LASTEXITCODE or $? at all (maybe because the app is actually not a console app? I don’t get it, really). So the real problem became: how do I capture the exit code of an application in PowerShell?

Someone sent me an email today (Jan 7 2010) mentioning that if you nest your call to regsvr32 inside a call to cmd.exe … it does set the $LastExitCode:

cmd /c "regsvr32 /s 'C:\Path\To\Some.dll'"
$LastExitCode ## Will be set correctly.

Well, the simplest thing would be to just go around that — to compile and distribute the MSDN sample with the /c console output option so I don’t need the exit code. Of course, they are very clear that we shouldn’t do that because the sample isn’t “safe,” and distributing it afterward would probably be a problem with licensing. Well, I don’t know about that, but I figured the best thing would be to just use the exit code from the existing RegSvr32.exe rather than asking people to use what they would perceive as a 3rd party RegSvr32.

And if we play around a bit with the .Net Process and ProcessStartInfo classes, it’s not to hard to get the exit code …

After a bit more experimentation with the return values, I came up with a function called RegisterDllServer which appears below. The function has a -Verbose switch and a -Debug switch which turn on some helpful messages (the Debug switch actually allows the RegSvr32 message boxes to show up, so you shouldn’t use that if you’re calling it from within a script).

So, to answer the original question, to use this to register all the dll’s in a folder you could just call it like ls *.dll | RegSvr32 using the alias that the script sets up at the end, or to be more complete, call it like: ls *.dll | % {$r=$(RegSvr $_); if($r -gt 0){ "FAILED: $_" } else { "SUCCEEDED: $_" }} … nice, eh?

Anyway, it looks really interesting, and I can’t help but think that perhaps the Linux command-line could benefit from apps implementing this standard too . In particular, I like the TCSV format option as a way of enhancing plain old CSV data with type and structure information … and the standardized naming convention. Ultimately, these five points (from the spec) should be the standard for any command-line interface (although I know many linux die-hards will note they’ve been living without number five for many years):

1. Consistent verb and parameter naming conventions.
2. Consistent command syntax
3. Common behaviors.
4. Consistent error messages and exit codes.

1. Schema-enhanced data streams and formatting.

However, Appendix A – Standardized Verb Sets and Verb Names got my attention in particular, because it actually obsoletes a few of the Verbs that were in this list on the PowerShell blog and which they’ve actually been using in the Community Extensions … Specifically, Write is marked as obsolete in favor of Set — and it’s pair Get, is to be used instead of the obsolete Read. In addition, there’s no mention of Out and *Where* is only mentioned as an obsolete version of Resolve (which really made me wonder about “Where-Object” but I guess that can be the exception that proves the rule?). The spec actually says that it is required to use verbs from the list of standard verbs in Appendix A., so there doesn’t seem to be an option to invent your own verbs.

If you have any comments about the spec, I guess you should put them on this post on their blog, rather than on this thread in the PSCX forum.

I’ll have to write another post on this later, after I’ve had a chance to re-read the spec and digest it a bit … so far it looks really good, but it sure would throw the monkey-wrench in my old console “Hello World” apps in C++ and Java … I wonder if someone will create a wrapper to make writing compliant command line apps easier (without resorting to writing PowerShell commandlets which are practically compliant automatically). I also wonder how long it will be until a new PowerShell release comes out that actually understands TCSV...

As I announced recently I have created a Windows Automation PowerShell Snapin project to house this snapin on CodePlex, and added a bunch of features. You should head over there for the download.

Original Post

I’ve been crazy busy the last few weeks, but I’ve been really rather distracted from my main project and it’s past time I got back to it. To really feel like I’ve moved on, I need to write a bunch of articles here and publish a couple of cool apps and some source code so that I can feel like I’ve reached a release point. What I’ve been playing with in all this coding is the new technology that’s been coming out of Microsoft in the last couple months: PowerShell, .NET 3 and WPF, and Windows Vista so you may or may not actually be able to use these apps …

So yeah, anyway … I’ve been playing around with PowerShell cmdlets, and as a shell geek, I couldn’t help wondering why there wasn’t a way to enumerate windows and move them around … so I wrote one. Eventually this will show up in the PowerShell Community Extensions — but I’m posting it here for now because the powershell cmdlet process is pretty interesting.

I started off by writing a wrapper for some of the Win32 APIs, and then a PSSnapIn which provides Get-Window and Remove-Window. When you execute Get-Window, the resulting object is a Win32.Window which has methods for closing, moving, resizing, maximizing and restoring, etc. The Remove-Window cmdlet is just a wrapper to call the Close() method, but it seems to make sense in the PowerShell pipe, since you can pipe the window objects through filters etc.

I still need to finish up the Move-Window cmdlet — it’s an advanced window-organizing feature. Right now it’s only feature is that it can tile windows vertically or horizontally with percentages specified by you. The features there are a little weak, but it’s past time I show you what I mean.

What you would want to do is install the snapin and then try typing these commands one at a time (so you can see the results).

A little explanation is in order:

• Obviously the first three lines basically start up a few copies of notepad — three of them empty, one with a text file.
• The next line shows how Get-Window works with wildcard matching on the window titles … and how Move-Window uses percentage values to organize windows.
• Then you see that you can pipe the output of Get-Process (aliased as ps) through Move-Window. You can pipe it through Get-Window too, but the important take away here is that Remove-Window and Move-Window can both take processes as input — as long as those processes have actual windows. You’ll also notice that final parameter “0” to cause Move-Window to tile horizontally instead of vertically — “1” is the default.
• The next three lines are examples of how you can call methods on individual Window objects.

• And finally, the next-to-last line is just an example of how you can use Where-Object to filter windows, and the last line is just to get rid of the remaining instances of notepad.

You can download Win32.Window for PowerShell (it’s a 7-zip file, you’ll need TugZip or 7-Zip) ... it includes the source (which you can use under any of several open source licenses including Ms-PL, BSD and GPL) and the actual DLL in the bin/Release directory, along with the scripts Install.ps1 and Uninstall.ps1

Feature requests and code contributions are both welcome!

The RSS Platform is intended to introduce a unified approach to RSS for Windows applications, where all applications use the same RSS feed store, and a service handles downloading the RSS feeds — including enclosures if requested — and normalizes them so applications need not handle parsing all the different feed formats (that is, you only need to parse the Microsoft-normalized RSS 2.0 with extensions).

As a platform for building RSS-based applications, it’s very well done, and well thought out. It’s now ridiculously easy to create an RSS reader, since the platform removes all need to parse XML except in the weirdest situations, and allows all applications to be instantly integrated on the same list of RSS feeds … let me show you ….

I’ll be using the RSS Platform in my SOM Recommender project, so I’ll have some more sample code I can share later on, including use of some of the events (there are events for all the things that could happen to feed folders or feeds themselves, including creations, renaming, deletion, etc). At the very least, you’d want to check out GetWatcher method (see the examples) and the FeedItemCountChanged and FeedDownloadCompleted events.

For now, I have a very simple example: a single function which exercises some of the most interesting methods in the API, but doesn’t use any of the events for detecting the arrival of new feed items nor the asynchronous download feature. This simple example is a console application which will fetch a feed. As you can see, it parses the command line for the url and name parameters.

Once you’ve specified a feed by name and URL, it will be stored in the “RssMe Feeds” folder so you can just refer to it by name in the future. However, there’s one major problem with that: the FeedStore doesn’t have a concept of aliases or shortcuts, and the feed URLs have to be unique, so if you’ve already bookmarked a feed, RssMe would be able to show you the items from it, but not pull it up by name, unless you specify the full path to it. Honestly, this is the most frustrating thing to me (as a developer, and as a user) about the feed store: what I’d like to be able to do is add a feed in multiple folders and have them automatically share the “read” state of the items.

That would allow applications to create a subfolder (as RssMe does) and rely on it as a way of organizing the feeds they use. As it is, if third-party applications want to use only some of the feeds in the feed store, they will have to keep a list of URLs separately since they may not be able to add the feed to their own folder if it’s already in the store elsewhere. Once they’ve done that, they can just retrieve them by URL from the store.

Although the source code is inline below, you can download the Visual Studio 2005 project which can be compiled by just running msbuild (that’s in your Microsoft.Net\Framework folder in C:\Windows … for some reason it’s not on the path, so you’ll probably need to type the whole path. If you’re not familiar with MSBuild, try the /help argument but you can specify that you want to build the “Release” build by just running: MSBuild /p:Configuration=Release assuming you’ve fixed the path problem). Or you can download the compiled example

The command-line for this sample app is basically:

• RssMe /url:http://huddledmasses.org/feed/atom/ /name:HM.O
• RssMe /url:http://del.icio.us/rss/ /name:"Delicious Recent"

• RssMe /name:HM.O