PowerShell Automation Mastery: Practical Scripting Techniques

function Process-UserFiles {
    param(
        [Parameter(Mandatory=$true)]
        [string]$SourcePath,
        
        [Parameter(Mandatory=$true)]
        [string]$DestinationPath,
        
        [int]$RetentionDays = 30,
        
        [ValidateSet("Copy", "Move")]
        [string]$Operation = "Copy"
    )
    
    # Validate paths exist
    if (-not (Test-Path $SourcePath)) {
        throw "Source path does not exist: $SourcePath"
    }
    
    if (-not (Test-Path $DestinationPath)) {
        New-Item -ItemType Directory -Path $DestinationPath -Force | Out-Null
    }
    
    # Get files modified within retention period
    $cutoffDate = (Get-Date).AddDays(-$RetentionDays)
    $files = Get-ChildItem -Path $SourcePath -File | 
             Where-Object { $_.LastWriteTime -ge $cutoffDate }
    
    # Process each file based on operation type
    foreach ($file in $files) {
        $destinationFile = Join-Path $DestinationPath $file.Name
        
        try {
            if ($Operation -eq "Copy") {
                Copy-Item -Path $file.FullName -Destination $destinationFile -Force
                Write-Verbose "Copied: $($file.Name)"
            } else {
                Move-Item -Path $file.FullName -Destination $destinationFile -Force
                Write-Verbose "Moved: $($file.Name)"
            }
            
            # Log successful operation
            Write-Information "Processed file: $($file.Name)" -InformationAction Continue
        }
        catch {
            Write-Error "Failed to process $($file.Name): $($_.Exception.Message)"
        }
    }
    
    # Return processing summary
    return [PSCustomObject]@{
        TotalFiles = $files.Count
        Operation = $Operation
        ProcessedDate = Get-Date
    }
}

# Usage example with error handling
try {
    $result = Process-UserFiles -SourcePath "C:\Users\Public\Documents" `
                                -DestinationPath "D:\Archive\UserFiles" `
                                -RetentionDays 60 `
                                -Operation "Move" `
                                -ErrorAction Stop
    Write-Output "Processed $($result.TotalFiles) files successfully"
}
catch {
    Write-Error "Processing failed: $($_.Exception.Message)"
}

# Function to deploy application to multiple servers
function Deploy-Application {
    param(
        [Parameter(Mandatory=$true)]
        [string[]]$ComputerNames,
        
        [Parameter(Mandatory=$true)]
        [string]$SourcePath,
        
        [string]$DeploymentPath = "C:\Applications",
        
        [pscredential]$Credential
    )
    
    $results = @()
    
    foreach ($computer in $ComputerNames) {
        try {
            Write-Output "Starting deployment to $computer"
            
            # Test connectivity
            if (-not (Test-Connection -ComputerName $computer -Count 1 -Quiet)) {
                throw "Computer $computer is not reachable"
            }
            
            # Create session
            $sessionParams = @{
                ComputerName = $computer
                ErrorAction = 'Stop'
            }
            
            if ($Credential) {
                $sessionParams.Credential = $Credential
            }
            
            $session = New-PSSession @sessionParams
            
            # Copy files
            Copy-Item -Path $SourcePath -Destination $DeploymentPath -ToSession $session -Recurse -Force
            
            # Execute remote commands
            $deployResult = Invoke-Command -Session $session -ScriptBlock {
                param($DeploymentPath)
                
                # Validate deployment
                if (-not (Test-Path $DeploymentPath)) {
                    throw "Deployment failed: files not copied"
                }
                
                # Register application (example)
                & "$DeploymentPath\install.bat" 2>&1
                
                return "Deployment successful on $env:COMPUTERNAME"
            } -ArgumentList $DeploymentPath
            
            $results += [PSCustomObject]@{
                ComputerName = $computer
                Status = "Success"
                Message = $deployResult
                Timestamp = Get-Date
            }
            
            # Clean up session
            Remove-PSSession -Session $session
        }
        catch {
            $results += [PSCustomObject]@{
                ComputerName = $computer
                Status = "Failed"
                Message = $_.Exception.Message
                Timestamp = Get-Date
            }
            Write-Warning "Deployment to $computer failed: $($_.Exception.Message)"
        }
    }
    
    return $results
}

# Usage example
$servers = @("SERVER01", "SERVER02", "SERVER03")
$deployResults = Deploy-Application -ComputerNames $servers -SourcePath ".\LatestBuild"

# Generate deployment report
$deployResults | Export-Csv -Path ".\DeploymentReport.csv" -NoTypeInformation

# Slow approach: Processing large files with Get-Content
$largeFile = "C:\Logs\application.log"
$lines = Get-Content $largeFile
$filteredLines = $lines | Where-Object { $_ -like "*ERROR*" }

# Faster approach: Use .NET StreamReader for large files
$filteredLines = [System.Collections.ArrayList]::new()
$reader = [System.IO.StreamReader]::new($largeFile)

try {
    while ($null -ne ($line = $reader.ReadLine())) {
        if ($line -like "*ERROR*") {
            $filteredLines.Add($line) | Out-Null
        }
    }
}
finally {
    $reader.Close()
    $reader.Dispose()
}

# Fastest approach: Use PowerShell 7+ ForEach-Object -Parallel for CPU-bound tasks
$files = Get-ChildItem -Path "C:\Logs" -Filter "*.log" -File
$results = $files | ForEach-Object -Parallel {
    $errorCount = 0
    $reader = [System.IO.StreamReader]::new($_.FullName)
    
    while ($null -ne ($line = $reader.ReadLine())) {
        if ($line -like "*ERROR*") {
            $errorCount++
        }
    }
    
    $reader.Close()
    $reader.Dispose()
    
    return [PSCustomObject]@{
        FileName = $_.Name
        ErrorCount = $errorCount
    }
} -ThrottleLimit 5

$results | Sort-Object ErrorCount -Descending