Working with Objects

When Objects Clicked

I was writing a script to generate a report of all users from Active Directory. Coming from text-based scripting, my first instinct was to output user information as formatted text, then parse it later. It looked messy:

# My first terrible approach
Get-ADUser -Filter * | Format-Table Name, Email, Department
# Now I needed to parse this formatted text... yikes

A senior engineer reviewed my code and shook his head. "You're thinking in text. PowerShell gives you objects. Use them."

He showed me:

# The right way
$users = Get-ADUser -Filter * -Properties *
$users | Where-Object {$_.Department -eq 'IT'} | 
    Select-Object Name, EmailAddress, Department |
    Export-Csv -Path "IT_Users.csv"

Clean. Simple. No parsing. That's when I truly understood that PowerShell objects aren't just data structures - they're the foundation of everything PowerShell does well.

Understanding PowerShell Objects

In PowerShell, almost everything is an object. When you run Get-Process, you don't get text - you get process objects. Each object has:

• Properties: Data about the object (Name, CPU, Memory, etc.)

• Methods: Actions the object can perform (Kill, Refresh, etc.)

• Type: What kind of object it is (System.Diagnostics.Process)

Exploring Objects with Get-Member

The most important command for understanding objects:

# See everything about process objects
Get-Process | Get-Member

# Filter to just properties
Get-Process | Get-Member -MemberType Property

# Filter to just methods
Get-Process | Get-Member -MemberType Method

# See properties of file objects
Get-ChildItem | Get-Member -MemberType Property

Output shows:

• TypeName: The .NET type of the object

• Name: Property or method name

• MemberType: Whether it's a property, method, etc.

• Definition: Technical details about the member

Accessing Object Properties

Two ways to access properties:

# Dot notation (common)
$process = Get-Process -Name "pwsh" | Select-Object -First 1
$process.Name
$process.CPU
$process.WorkingSet

# Select-Object (useful in pipelines)
Get-Process -Name "pwsh" | Select-Object Name, CPU, WorkingSet

Calling Object Methods

Methods are actions objects can perform:

# Get a process object
$notepad = Get-Process -Name "notepad" | Select-Object -First 1

# Call methods
$notepad.Kill()           # Terminates the process
$notepad.Refresh()        # Updates the object's properties

# String methods
$text = "PowerShell"
$text.ToUpper()           # "POWERSHELL"
$text.ToLower()           # "powershell"
$text.Contains("Shell")   # True
$text.Replace("Shell", "Core")  # "PowerCore"

# DateTime methods
$now = Get-Date
$now.AddDays(7)           # Date 7 days from now
$now.AddHours(-2)         # Time 2 hours ago
$now.ToString("yyyy-MM-dd")  # Custom format

Deep Dive: Select-Object

Select-Object is your Swiss Army knife for working with objects.

Selecting Specific Properties

# Select just the properties you need
Get-Process | Select-Object Name, CPU, WorkingSet

# Select all properties
Get-Service -Name "wuauserv" | Select-Object *

# Exclude specific properties
Get-Process | Select-Object * -ExcludeProperty Company, Description

Limiting Results

# First 10 items
Get-Process | Select-Object -First 10

# Last 5 items
Get-ChildItem | Select-Object -Last 5

# Skip first 5, then take 10
Get-Process | Select-Object -Skip 5 -First 10

# Unique values only
Get-Process | Select-Object -Property Name -Unique

Calculated Properties

Create custom properties on the fly:

# Basic calculated property
Get-Process | Select-Object Name,
    @{Name='MemoryMB'; Expression={$_.WorkingSet / 1MB}}

# Multiple calculated properties
Get-Process | Select-Object Name,
    @{Name='MemoryMB'; Expression={[math]::Round($_.WorkingSet / 1MB, 2)}},
    @{Name='MemoryGB'; Expression={[math]::Round($_.WorkingSet / 1GB, 3)}},
    @{Name='CPUSeconds'; Expression={[math]::Round($_.CPU, 2)}}

# Conditional calculated property
Get-ChildItem | Select-Object Name,
    @{Name='Size'; Expression={
        if ($_.Length -gt 1MB) {
            "$([math]::Round($_.Length / 1MB, 2)) MB"
        } else {
            "$([math]::Round($_.Length / 1KB, 2)) KB"
        }
    }}

Calculated properties are essential for:

• Converting units (bytes to MB/GB)

• Formatting data (dates, numbers)

• Creating conditional values

• Combining multiple properties

Expanding Properties

Sometimes properties contain nested objects or arrays:

# Without -ExpandProperty (shows object type)
Get-Service | Select-Object -First 1 RequiredServices

# With -ExpandProperty (shows actual values)
Get-Service | Select-Object -First 1 -ExpandProperty RequiredServices

# Practical example: Get all loaded modules from processes
Get-Process -Name "pwsh" | Select-Object -ExpandProperty Modules | 
    Select-Object ModuleName -Unique

Deep Dive: Where-Object

Where-Object filters objects based on conditions.

Basic Filtering

# Single condition
Get-Process | Where-Object {$_.CPU -gt 10}

# Property equals value
Get-Service | Where-Object {$_.Status -eq 'Running'}

# Property not equals
Get-Service | Where-Object {$_.Status -ne 'Stopped'}

# Property greater than
Get-ChildItem | Where-Object {$_.Length -gt 1MB}

# Property less than
Get-Process | Where-Object {$_.WorkingSet -lt 10MB}

Comparison Operators

# Equality operators
-eq    # Equal
-ne    # Not equal
-gt    # Greater than
-ge    # Greater than or equal
-lt    # Less than
-le    # Less than or equal

# String operators
-like      # Wildcard matching
-notlike   # Wildcard not matching
-match     # Regex matching
-notmatch  # Regex not matching

# Examples
Get-Process | Where-Object {$_.Name -like "pw*"}
Get-Process | Where-Object {$_.Name -match "^p.*sh$"}
Get-ChildItem | Where-Object {$_.Name -notlike "*.exe"}

Multiple Conditions

# AND conditions (both must be true)
Get-Process | Where-Object {$_.CPU -gt 10 -and $_.WorkingSet -gt 100MB}

# OR conditions (either can be true)
Get-Service | Where-Object {$_.Status -eq 'Running' -or $_.StartType -eq 'Automatic'}

# Complex conditions with parentheses
Get-ChildItem | Where-Object {
    ($_.Extension -eq '.txt' -or $_.Extension -eq '.log') -and $_.Length -gt 1MB
}

# Mixing AND and OR
Get-Process | Where-Object {
    ($_.Name -like "*chrome*" -or $_.Name -like "*firefox*") -and $_.WorkingSet -gt 100MB
}

Simplified Syntax (PowerShell 3.0+)

# Traditional syntax
Get-Process | Where-Object {$_.CPU -gt 10}

# Simplified syntax
Get-Process | Where-Object CPU -gt 10

# Multiple conditions with simplified syntax
Get-ChildItem | Where-Object Extension -eq '.txt' | Where-Object Length -gt 1KB

# I prefer the traditional syntax for complex conditions, but simplified for simple ones

Advanced Object Manipulation

Sorting Objects

# Sort by single property ascending
Get-Process | Sort-Object CPU

# Sort descending
Get-Process | Sort-Object CPU -Descending

# Sort by multiple properties
Get-ChildItem | Sort-Object Extension, Length

# Mixed order sorting
Get-Process | Sort-Object @{Expression='CPU'; Descending=$true}, Name

Grouping Objects

# Group by property
Get-Process | Group-Object Company

# Group with count
Get-ChildItem | Group-Object Extension | Select-Object Count, Name

# Group and format
Get-Service | Group-Object Status | 
    Select-Object @{Name='Status'; Expression={$_.Name}},
                  @{Name='Count'; Expression={$_.Count}}

Measuring Objects

# Count objects
(Get-Process).Count
Get-Process | Measure-Object

# Sum property
Get-ChildItem | Measure-Object -Property Length -Sum

# Statistical analysis
Get-Process | Measure-Object -Property WorkingSet -Average -Minimum -Maximum -Sum

# Practical example: Total disk usage
$stats = Get-ChildItem -Recurse -File | Measure-Object -Property Length -Sum
Write-Host "Total size: $([math]::Round($stats.Sum / 1GB, 2)) GB"

Working with Complex Objects

Nested Properties

Objects often contain other objects:

# Process object contains StartInfo object
$process = Get-Process -Name "pwsh" | Select-Object -First 1
$process.StartInfo.FileName

# File object contains timestamps
$file = Get-ChildItem | Select-Object -First 1
$file.CreationTime.Year
$file.LastWriteTime.ToString("yyyy-MM-dd HH:mm")

# Service object contains dependent services
$service = Get-Service -Name "wuauserv"
$service.DependentServices

Array Properties

Some properties contain arrays:

# Process modules (array of loaded DLLs)
$modules = (Get-Process -Name "pwsh").Modules
$modules.Count
$modules[0].ModuleName

# Iterate through array property
Get-Process -Name "pwsh" | ForEach-Object {
    $_.Modules | Select-Object ModuleName -First 5
}

Creating Custom Objects

Sometimes you need to create your own objects:

Using PSCustomObject

# Simple custom object
$server = [PSCustomObject]@{
    Name = "SERVER01"
    IP = "192.168.1.100"
    Status = "Online"
    LastCheck = Get-Date
}

# Access properties
$server.Name
$server.Status

# Create multiple custom objects
$servers = @(
    [PSCustomObject]@{Name='SERVER01'; IP='192.168.1.100'; Status='Online'},
    [PSCustomObject]@{Name='SERVER02'; IP='192.168.1.101'; Status='Offline'},
    [PSCustomObject]@{Name='SERVER03'; IP='192.168.1.102'; Status='Online'}
)

# Work with them like any objects
$servers | Where-Object Status -eq 'Online'
$servers | Select-Object Name, IP

Adding Properties to Existing Objects

# Get an object
$process = Get-Process -Name "pwsh" | Select-Object -First 1

# Add a custom property
$process | Add-Member -MemberType NoteProperty -Name "CustomTag" -Value "Production"

# Add a calculated property
$process | Add-Member -MemberType ScriptProperty -Name "MemoryMB" -Value {
    [math]::Round($this.WorkingSet / 1MB, 2)
}

# Access new properties
$process.CustomTag
$process.MemoryMB

Real-World Examples

Server Inventory Report

Creating a custom inventory from multiple sources:

$servers = Get-Content "servers.txt"

$inventory = foreach ($server in $servers) {
    [PSCustomObject]@{
        ServerName = $server
        Ping = Test-Connection -ComputerName $server -Count 1 -Quiet
        DiskSpaceGB = if (Test-Connection -ComputerName $server -Count 1 -Quiet) {
            (Get-WmiObject -ComputerName $server -Class Win32_LogicalDisk -Filter "DeviceID='C:'" |
             Select-Object -ExpandProperty FreeSpace) / 1GB
        } else {
            "Unreachable"
        }
        LastCheck = Get-Date
    }
}

$inventory | Export-Csv -Path "ServerInventory.csv" -NoTypeInformation

Log Analysis

Processing log files into structured objects:

$logEntries = Get-Content "app.log" | ForEach-Object {
    if ($_ -match '^(\d{4}-\d{2}-\d{2}) (\d{2}:\d{2}:\d{2}) \[(\w+)\] (.+)$') {
        [PSCustomObject]@{
            Date = [datetime]"$($Matches[1]) $($Matches[2])"
            Level = $Matches[3]
            Message = $Matches[4]
        }
    }
}

# Filter errors
$errors = $logEntries | Where-Object Level -eq 'ERROR'

# Group by hour
$logEntries | Group-Object {$_.Date.Hour} | 
    Select-Object @{Name='Hour'; Expression={$_.Name}}, Count

Resource Usage Dashboard

Combining multiple data sources:

$dashboard = [PSCustomObject]@{
    Timestamp = Get-Date
    TopCPUProcesses = Get-Process | 
        Sort-Object CPU -Descending | 
        Select-Object -First 5 Name, CPU
    TopMemoryProcesses = Get-Process |
        Sort-Object WorkingSet -Descending |
        Select-Object -First 5 Name, @{Name='MemoryMB'; Expression={$_.WorkingSet / 1MB}}
    DiskSpace = Get-PSDrive -PSProvider FileSystem |
        Select-Object Name, @{Name='FreeGB'; Expression={$_.Free / 1GB}}, 
                             @{Name='UsedGB'; Expression={$_.Used / 1GB}}
    RunningServices = (Get-Service | Where-Object Status -eq 'Running').Count
    StoppedServices = (Get-Service | Where-Object Status -eq 'Stopped').Count
}

$dashboard

Common Pitfalls

1. Modifying Objects in the Pipeline

Problem: Objects in the pipeline can't be modified directly Solution: Create new objects with desired properties

# Won't work
Get-Process | ForEach-Object { $_.CustomProp = "Value" }

# Use custom objects instead
Get-Process | Select-Object *, @{Name='CustomProp'; Expression={"Value"}}

2. Forgetting About Property Types

Problem: Treating all properties as strings Solution: Check property types and convert as needed

# Check types
Get-Process | Get-Member -MemberType Property

# Convert when needed
$process.WorkingSet.ToString()  # Number to string
[int]$stringNumber  # String to number

3. Not Using Calculated Properties

Problem: Trying to format data outside PowerShell Solution: Use calculated properties in Select-Object

4. Overusing Select-Object *

Problem: Select-Object * returns everything, including hidden properties Solution: Only select what you need for better performance

Key Takeaways

• Everything in PowerShell is an object with properties and methods

• Get-Member reveals object structure - use it constantly

• Select-Object controls which properties you work with

• Where-Object filters objects based on conditions

• Calculated properties transform data on the fly

• Custom objects combine data from multiple sources

• Object types matter - understand what you're working with

• Don't format early - keep objects as objects until final output

What You've Learned

✅ How to explore objects with Get-Member ✅ Accessing object properties and methods ✅ Advanced Select-Object techniques including calculated properties ✅ Complex filtering with Where-Object ✅ Creating custom objects for reporting ✅ Working with nested and complex objects ✅ Real-world object manipulation patterns

Next Steps

Now that you master objects, it's time to learn how to store and manipulate data with variables. In Variables and Data Types, you'll discover:

• Creating and using variables

• PowerShell data types

• Arrays and hashtables

• Variable scope and lifetime

• Best practices for variable naming

Variables are the foundation of reusable scripts - let's make your code flexible and maintainable.

---

Ready to work with variables? Continue to Variables and Data Types →