{"id":16741,"date":"2010-10-22T00:01:00","date_gmt":"2010-10-22T00:01:00","guid":{"rendered":"https:\/\/blogs.technet.microsoft.com\/heyscriptingguy\/2010\/10\/22\/make-windows-powershell-your-web-client\/"},"modified":"2010-10-22T00:01:00","modified_gmt":"2010-10-22T00:01:00","slug":"make-windows-powershell-your-web-client","status":"publish","type":"post","link":"https:\/\/devblogs.microsoft.com\/scripting\/make-windows-powershell-your-web-client\/","title":{"rendered":"Make Windows PowerShell Your Web Client"},"content":{"rendered":"

 <\/p>\n

Summary:<\/b> Interact with websites from Windows PowerShell with this how-to post that wraps .NET Framework classes.<\/span><\/p>\n

 <\/p>\n

\"Hey,Hey, Scripting Guy! I would like to be able to download files and things from the Internet via Windows PowerShell. Is there an easy way to do this? I have not been able to find a Windows PowerShell cmdlet, and I would like to share whatever I come up with other users. <\/span><\/p>\n

— BR<\/p>\n

 <\/p>\n

\"Hey,Hello BR, <\/span><\/p>\n

Microsoft Scripting Guy Ed Wilson here. James Brundage began talking about wrapping .NET Framework classes to work with the web in yesterday’s Hey, Scripting Guy! post. That post is a great introduction to wrapping .NET Framework classes to work with the Internet. Let’s let him complete the discussion. <\/span><\/p>\n

James Brundage is the founder of Start-Automating (<\/span>http:\/\/www.start-automating.com<\/span><\/a>), a company dedicated to saving people time and money by helping them automate. Start-Automating offers Windows PowerShell training and custom Windows PowerShell and .NET Framework development. James formerly worked on the Windows PowerShell team at Microsoft and is the author of the <\/span>PowerShellPack<\/span><\/a>, a collection of Windows PowerShell scripts to enable building user interfaces, interact with RSS feeds, retrieve system information, and more. You can follow James on Twitter @JamesBru. <\/span><\/p>\n

 <\/p>\n

A Series on Splatting (and Stuff)<\/h3>\n

Part 5: Splatting .NET Framework conclusion<\/h4>\n

In previous posts, we have covered how to build commands that wrap other commands with splatting and building bridges between two commands with splatting.  Yesterday we looked at improving a Windows PowerShell script that invoked a .NET command. Today, we will learn how to apply those skills to make some usable Windows PowerShell scripts to replace some hard-to-use .NET.<\/span><\/p>\n

Great! Let’s take the New-WebClient<\/b> function that was developed <\/span>yesterday<\/span><\/a>, because we can think of the next command we will write as bridging New-WebClient<\/b> and a quick function to invoke the method.  <\/span><\/p>\n

Our begin block will also contain this New-WebClient<\/b> function and a helper function called Invoke-Method<\/b> that lets us invoke .NET methods in a Windows PowerShell syntax.<\/span><\/p>\n

The $BeginBlock<\/b> variable will contain the two helper commands, and nothing else.  If these helper commands were going to be used by a larger group of commands, I’d put them into the same <\/span>module<\/span><\/a> as the command I’m working on. However, you can also embed a private command this way. The $BeginBlock<\/b> and its two functions are seen here. <\/span><\/p>\n

\n

$BeginBlock = {
    function New-WebClient
    {
        [CmdletBinding(DefaultParameterSetName=”Easy”)]
        param(
        [string]$BaseAddress,
        [Parameter(ParameterSetName=’Hard’)]
        [Net.ICredentials]$Credentials,
        [Parameter(ParameterSetName=’Easy’)]
        [Management.Automation.PSCredential]$Credential,
        [Parameter(ParameterSetName=’Hard’)]
        [Net.WebHeaderCollection]$Headers,
        [Parameter(ParameterSetName=’Easy’)]
        [Hashtable]$Header,
        [Parameter(ParameterSetName=’Hard’)]
        [Collections.Specialized.NameValueCollection]$QueryString,
        [Parameter(ParameterSetName=’Easy’)]
        [Hashtable]$Query,
        [Parameter(ParameterSetName=’Hard’)]
        [bool]$UseDefaultCredentials,
        [Parameter(ParameterSetName=’Easy’)]
        [Switch]$Anonymous    
        )
       
        process {
            if ($psCmdlet.ParameterSetName -eq “Hard”) {
                New-Object Net.Webclient -Property $psBoundParameters
            } else {
                $newWebClientParameters = @{} + $psBoundParameters<\/p>\n

                $newWebClientParameters.UseDefaultCredentials = -not $Anonymous
                $null = $newWebClientParameters.Remove(“Anonymous”)<\/p>\n

                if ($newWebClientParameters.Credential) {
                    $newWebClientParameters.Credentials = $newWebClientParameters.Credential.GetNetworkCredential()
                    $null = $newWebClientParameters.Remove(“Credential”)
                }<\/p>\n

                if ($newWebClientParameters.Header) {
                    $newWebClientParameters.Headers = New-Object Net.WebHeadercollection
                    foreach ($headerPair in $newWebClientParameters.Header.GetEnumerator()) {
                        $null = $newWebClientParameters.Headers.Add($headerPair.Key, $headerPair.Value)
                    }
                    $null = $newWebClientParameters.Remove(“Header”)
                }<\/p>\n

                if ($newWebClientParameters.Query) {
                    $newWebClientParameters.QueryString = New-Object Collections.Specialized.NameValueCollection
                    foreach ($QueryPair in $newWebClientParameters.Query.GetEnumerator()) {
                        $null = $newWebClientParameters.QueryString.Add($QueryPair.Key, $QueryPair.Value)
                    }
                    $null = $newWebClientParameters.Remove(“Query”)
                }
                New-WebClient @newWebclientParameters
            }
        }   
    }
       
    function Invoke-Method
    {
        param($Object, [string]$Method, $Parameters)
       
        process {
            $realMethod =$object.”${method}”
            if ($realMethod) {
                $realMethod.Invoke($Parameters)
            }       
        }
    }     
}<\/span><\/span><\/p>\n<\/blockquote>\n

The parameter block is next.  Remember how we said that most of what you do in .NET can be expressed as creating a class, setting lots of properties, and running lots of methods? The begin block took care of the first two.  The parameter block and process block will handle the rest.<\/span><\/p>\n

You can think of any Windows PowerShell command as one or more things that you can do.  Each parameter set may be a small variation on the thing.  Many commands actually contain many related operations in one, with each parameter set representing a different operation.<\/span><\/p>\n

When wrapping something from .NET in Windows PowerShell, it is easy to go down the list and turn methods into parameter sets.<\/span><\/p>\n

Here are the .NET methods we want to wrap:<\/span><\/p>\n