PowerShell has several "type accelerators" which are used exactly like a casting operation. Examples of these special operators are [xml] and [wmi]. The former is used for quickly converting a string of xml into a fully-fledged System.Xml.XmlDocument object.

Often I find myself converting things to and from hexadecimal using the -f operator, but this always seemed like just a little too much typing for me. Enter the [hex] accelerator type:

As you can see from the source below, there's no magic here. This is just a straight cast, but I have no namespace. If I had a namespace, say, like "Nivot.PowerShell", we'd have to cast using [nivot.powershell.hex] instead of just [hex]. All of the trickery is done using operator overloads in C#. These tells .NET (and in turn, powershell) how to behave should someone try to add, subtract, remove or divide our instances.

The next step is to tell PowerShell's formatter what to do with the new type. Here's a simple format definition that tells the formatter to call ToString() on the Hex instance. This is the method that does the conversion by calling ToString("X") on the integer field. "X" means format the integer as hexadecimal using upper case. A lower-case "x" would output the value using lower-case (if you couldn't guess ).

If we don't load this format file, PowerShell just emits a couple of blank lines when you try to use it.  You'll notice from the screenshot above that the blank lines still appear. I'm not sure how to remove these - it looks pretty ugly compared to the output of the [int] object. If you want to play with this, you can download the zip file below and unzip the contents into a single folder and run "hex.ps1". I didn't bother with a full Snap-In, it just loads the DLL using reflection. It also loads the format ps1xml too. Have fun.

HexAccelerator1.zip (2.4 KB)

Just a minor thing, but this is a filter I've been using for a while now as a replacement for Get-Member. It's always annoyed me that the Get_ and Set_ methods are returned along with the actual properties. The only place that's actual useful is when you're using an object wrapped in the [xml] adapter since those objects do not expose the XmlDocument's properties in the adapted member set.

update: if you use (of course you do!) MoW's PowerTab, you can disable display of the accessor methods with $PowerTabConfig.ShowAccessorMethods = $false.

Someone on the PowerShell usenet group asked if it was possible to interact with SharePoint lists through our favourite little shell. Marco Shaw responded and put the pressure on by saying this was my bag of tricks. Who am I to say otherwise? so lets take a look at the recipe.

I noticed that my last script could not handle more complex webservices like the MSDN ContentService (unlike WSDL.EXE) for example, so I rewrote it from the ground up. This time, it supports Basic Profile 1.1 and can generate proxy instances for simple ASMX services and more complicated multi-schema services like the MSDN/TechNet Publishing System (MTPS) Content Service.

What's New:

• No need for the .NET 2.0 SDK, just PowerShell
• Auto discovery of all referenced schema
• No need to point it at page.asmx?wsdl any more, just the asmx
• Validation against WS-I Basic Profile 1.1

get-webservice2.ps1.txt (4.28 KB)  (updated 2007/12/19: errant comma in write-progress fixed)

1. #
2. # Get-WebService.ps1 (v2.0 Aug 6, 2007)
3. #
4. # Oisin Grehan <oising@gmail.com> (x0n)
5. #
6. # Usage:
7. #   $proxy = .\get-webservice2.ps1 [-Url] http://site/service.asmx [-Anonymous] [[-SoapProtocol] <Soap | Soap12>]
8. #
9. # to see available webmethods:
10. # $proxy | gm
11. #
12.  
13. # $url = "http://services.msdn.microsoft.com/contentservices/contentservice.asmx?wsdl"
14.  
15. param($url = $(throw "need `$url"), [switch]$Anonymous, [string]$protocol = "Soap")
16.  
17. [void][system.Reflection.Assembly]::LoadWithPartialName("system.web.services")
18.  
19. trap {
20.         "Error:`n`n $error";
21.         break;
22. }
23.  
24. #$request = [System.Net.WebRequest]::Create($url);
25. $dcp = new-object system.web.services.discovery.discoveryclientprotocol
26.  
27. if (! $Anonymous) {
28.     Write-Progress "Network Credentials" "Awaiting input..."
29.     $dcp.Credentials = (Get-Credential).GetNetworkCredential()
30. }
31.  
32. Write-Progress "Discovery" "Searching..."
33. $dcp.AllowAutoRedirect = $true
34. [void]$dcp.DiscoverAny($url)
35. $dcp.ResolveAll()
36.  
37. # get service name
38. foreach ($entry in $dcp.Documents.GetEnumerator()) { # needed for Dictionary
39.     if ($entry.Value -is [System.Web.Services.Description.ServiceDescription]) {
40.         $script:serviceName = $entry.Value.Services[0].Name
41.         Write-Verbose "Service: $serviceName"
42.     }
43. }
44.  
45. Write-Progress "WS-I Basic Profile 1.1" "Validating..."
46. $ns = new-Object System.CodeDom.CodeNamespace # "WebServices"
47.  
48. $wref = new-object System.Web.Services.Description.WebReference $dcp.Documents, $ns
49. $wrefs = new-object system.web.services.description.webreferencecollection
50. [void]$wrefs.Add($wref)
51.  
52. $ccUnit = new-object System.CodeDom.CodeCompileUnit
53. [void]$ccUnit.Namespaces.Add($ns)
54.  
55. $violations = new-object system.web.Services.Description.BasicProfileViolationCollection
56. $wsi11 = [system.web.services.WsiProfiles]::BasicProfile1_1
57.  
58. if ([system.web.Services.Description.WebServicesInteroperability]::CheckConformance($wsi11, $wref, $violations)) {
59.     Write-Progress "Proxy Generation" "Compiling..."
60.    
61.     $webRefOpts = new-object System.Web.Services.Description.WebReferenceOptions
62.         $webRefOpts.CodeGenerationOptions = "GenerateNewAsync","GenerateProperties" #,"GenerateOldAsync"
63.  
64.         #StringCollection strings = ServiceDescriptionImporter.GenerateWebReferences(
65.         #       webReferences, codeProvider, codeCompileUnit, parameters.GetWebReferenceOptions());
66.  
67.     $csprovider = new-object Microsoft.CSharp.CSharpCodeProvider
68.         $warnings = [System.Web.Services.Description.ServiceDescriptionImporter]::GenerateWebReferences(
69.                 $wrefs, $csprovider, $ccunit, $webRefOpts)
70.        
71.     if ($warnings.Count -eq 0) {
72.         $param = new-object system.CodeDom.Compiler.CompilerParameters
73.         [void]$param.ReferencedAssemblies.Add("System.Xml.dll")
74.         [void]$param.ReferencedAssemblies.Add("System.Web.Services.dll")       
75.         $param.GenerateInMemory = $true;
76.         #$param.TempFiles = (new-object System.CodeDom.Compiler.TempFileCollection "c:\temp", $true)
77.         $param.GenerateExecutable = $false;
78.         #$param.OutputAssembly = "$($ns.Name)_$($sdname).dll"
79.         $param.TreatWarningsAsErrors = $false;
80.         $param.WarningLevel = 4;
81.        
82.         # do it
83.         $compileResults = $csprovider.CompileAssemblyFromDom($param, $ccUnit);
84.  
85.         if ($compileResults.Errors.Count -gt 0) {
86.             Write-Progress "Proxy Generation" "Failed."
87.             foreach ($output in $compileResults.Output) { write-host $output }
88.             foreach ($err in $compileResults.Errors) { write-warning $err }           
89.         } else {           
90.             $assembly = $compileResults.CompiledAssembly
91.  
92.             if ($assembly) {
93.                 $serviceType = $assembly.GetType($serviceName)               
94.                 $assembly.GetTypes() | % { Write-Verbose $_.FullName }
95.             } else {
96.                 Write-Warning "Failed: `$assembly is null"
97.                                 return
98.             }
99.            
100.             # return proxy instance
101.             $proxy = new-object $serviceType.FullName
102.             if (! $Anonymous) {
103.                 $proxy.Credentials = $dcp.Credentials
104.             }
105.             $proxy # dump instance to pipeline
106.         }
107.     } else {
108.         Write-Progress "Proxy Generation" "Failed."       
109.         Write-Warning $warnings
110.     }
111.     #Write-Progress -Completed
112. }

For me, this opens up a whole new world of PowerShell interaction with remote servers. No more constructing soap packets - just point it at a WSDL url, and you get back a first-class object with methods that you can call corresponding to remote webmethods. PowerShell's [xml] accelerator automatically wraps the responses so you can easily manipulate the results.

Have fun!

UPDATE: newer more robust version 2.0 available!