PowerShell’s deep integration with the .NET Framework transforms it from a simple shell into a powerful automation platform. This integration allows you to leverage thousands of .NET classes, load custom assemblies, and create sophisticated scripts that rival compiled applications in capability.
Understanding .NET Objects in PowerShell
PowerShell is built on top of the .NET Framework, which means every PowerShell object is fundamentally a .NET object. This seamless integration provides access to properties, methods, and events from the entire .NET ecosystem.
Creating .NET Objects
PowerShell offers multiple approaches to instantiate .NET objects, each suited for different scenarios:
# Method 1: Using New-Object cmdlet
$stringBuilder = New-Object System.Text.StringBuilder
# Method 2: Using type accelerator and new() method
$arrayList = [System.Collections.ArrayList]::new()
# Method 3: Using static constructors
$guid = [System.Guid]::NewGuid()
# Method 4: Type accelerator with parentheses (PowerShell 5.0+)
$list = [System.Collections.Generic.List[string]]::new()
Output:
PS> $stringBuilder.GetType().FullName
System.Text.StringBuilder
PS> $arrayList.GetType().FullName
System.Collections.ArrayList
PS> $guid
d7c8f5a2-3b1e-4d6c-9f2a-8e7b3c4d5f6a
PS> $list.GetType().FullName
System.Collections.Generic.List`1[[System.String, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089]]
Working with Object Members
Use Get-Member to discover available properties, methods, and events:
# Examine DateTime object members
$date = Get-Date
$date | Get-Member
# Access specific properties
$date.Year
$date.Month
$date.DayOfWeek
# Call instance methods
$date.AddDays(7)
$date.ToString("yyyy-MM-dd")
Output:
PS> $date.Year
2025
PS> $date.DayOfWeek
Wednesday
PS> $date.AddDays(7)
Wednesday, October 29, 2025 4:59:00 PM
PS> $date.ToString("yyyy-MM-dd")
2025-10-22
Type Accelerators
Type accelerators are shorthand aliases for commonly used .NET types, making your code more readable and concise:
# Common type accelerators
[string] # System.String
[int] # System.Int32
[long] # System.Int64
[bool] # System.Boolean
[datetime] # System.DateTime
[xml] # System.Xml.XmlDocument
[regex] # System.Text.RegularExpressions.Regex
[hashtable] # System.Collections.Hashtable
# Using type accelerators
$number = [int]"42"
$pattern = [regex]"\d{3}-\d{4}"
$currentTime = [datetime]::Now
# View all type accelerators
[PSObject].Assembly.GetType("System.Management.Automation.TypeAccelerators")::Get
Creating Custom Type Accelerators
# Add a custom type accelerator
$typeAccelerators = [PSObject].Assembly.GetType(
"System.Management.Automation.TypeAccelerators"
)
$typeAccelerators::Add(
"StringBuilder",
[System.Text.StringBuilder]
)
# Now use the custom accelerator
$sb = [StringBuilder]::new()
$sb.Append("Hello")
$sb.Append(" World")
$sb.ToString()
Output:
Hello World
Loading and Using .NET Assemblies
Assemblies are compiled .NET libraries containing reusable code. PowerShell can load both system assemblies and custom DLLs.
Loading System Assemblies
# Load assembly by name
Add-Type -AssemblyName System.Windows.Forms
Add-Type -AssemblyName System.Drawing
# Create a Windows Form
$form = New-Object System.Windows.Forms.Form
$form.Text = "PowerShell GUI"
$form.Size = New-Object System.Drawing.Size(400, 300)
$form.StartPosition = "CenterScreen"
# Add a button
$button = New-Object System.Windows.Forms.Button
$button.Text = "Click Me"
$button.Size = New-Object System.Drawing.Size(100, 30)
$button.Location = New-Object System.Drawing.Point(150, 120)
$button.Add_Click({
[System.Windows.Forms.MessageBox]::Show("Button Clicked!")
})
$form.Controls.Add($button)
# $form.ShowDialog() # Uncomment to display
Loading Custom Assemblies
# Method 1: Load from file path
Add-Type -Path "C:\MyLibrary\CustomLib.dll"
# Method 2: Load from GAC (Global Assembly Cache)
[System.Reflection.Assembly]::LoadWithPartialName("MyAssembly")
# Method 3: Load with full assembly name
[System.Reflection.Assembly]::Load(
"MyAssembly, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null"
)
# List loaded assemblies
[System.AppDomain]::CurrentDomain.GetAssemblies() |
Select-Object FullName, Location |
Sort-Object FullName
Inline C# Code with Add-Type
One of PowerShell’s most powerful features is the ability to compile and use C# code directly within scripts:
# Define C# class inline
Add-Type -TypeDefinition @"
using System;
public class MathHelper
{
public static double CalculateCircleArea(double radius)
{
return Math.PI * radius * radius;
}
public static int Fibonacci(int n)
{
if (n <= 1) return n;
return Fibonacci(n - 1) + Fibonacci(n - 2);
}
public string Greet(string name)
{
return $"Hello, {name}! Welcome to .NET from PowerShell.";
}
}
"@
# Use the compiled class
[MathHelper]::CalculateCircleArea(5)
[MathHelper]::Fibonacci(10)
$helper = New-Object MathHelper
$helper.Greet("PowerShell User")
Output:
PS> [MathHelper]::CalculateCircleArea(5)
78.5398163397448
PS> [MathHelper]::Fibonacci(10)
55
PS> $helper.Greet("PowerShell User")
Hello, PowerShell User! Welcome to .NET from PowerShell.
Advanced Add-Type Usage
# Add type with referenced assemblies
Add-Type -TypeDefinition @"
using System;
using System.Net;
using System.IO;
public class WebHelper
{
public static string DownloadString(string url)
{
using (WebClient client = new WebClient())
{
return client.DownloadString(url);
}
}
public static void DownloadFile(string url, string path)
{
using (WebClient client = new WebClient())
{
client.DownloadFile(url, path);
}
}
}
"@ -ReferencedAssemblies System.Net
# Add type from source file
Add-Type -Path "C:\Scripts\MyClass.cs"
# Add type with compiler options
Add-Type -TypeDefinition $csharpCode -CompilerOptions "/optimize"
Working with Generic Types
Generic types enable type-safe collections and methods with compile-time type checking:
# Create generic List
$stringList = New-Object 'System.Collections.Generic.List[string]'
$stringList.Add("PowerShell")
$stringList.Add("Python")
$stringList.Add("JavaScript")
# Create generic Dictionary
$dictionary = New-Object 'System.Collections.Generic.Dictionary[string,int]'
$dictionary.Add("PowerShell", 2006)
$dictionary.Add("Python", 1991)
$dictionary.Add("JavaScript", 1995)
# Access dictionary items
$dictionary["PowerShell"]
$dictionary.ContainsKey("Ruby")
# Create generic Queue
$queue = New-Object 'System.Collections.Generic.Queue[int]'
$queue.Enqueue(10)
$queue.Enqueue(20)
$queue.Enqueue(30)
$queue.Dequeue()
# Create generic Stack
$stack = New-Object 'System.Collections.Generic.Stack[string]'
$stack.Push("First")
$stack.Push("Second")
$stack.Push("Third")
$stack.Pop()
Output:
PS> $stringList
PowerShell
Python
JavaScript
PS> $dictionary["PowerShell"]
2006
PS> $dictionary.ContainsKey("Ruby")
False
PS> $queue.Dequeue()
10
PS> $stack.Pop()
Third
Reflection and Dynamic Object Manipulation
Reflection allows you to inspect and manipulate types, methods, and properties at runtime:
# Get type information
$dateType = [datetime]
$dateType.FullName
$dateType.IsValueType
$dateType.IsClass
# Get all methods
$dateType.GetMethods() |
Where-Object { $_.IsStatic } |
Select-Object Name, ReturnType -First 5
# Get all properties
$dateType.GetProperties() |
Select-Object Name, PropertyType
# Invoke method dynamically
$methodInfo = $dateType.GetMethod("Parse", [type[]]@([string]))
$methodInfo.Invoke($null, @("2025-10-22"))
# Access private members (use carefully)
$obj = New-Object System.Text.StringBuilder
$type = $obj.GetType()
$field = $type.GetField("m_ChunkLength",
[System.Reflection.BindingFlags]"Instance,NonPublic")
Output:
PS> $dateType.FullName
System.DateTime
PS> $dateType.IsValueType
True
PS> $methodInfo.Invoke($null, @("2025-10-22"))
Tuesday, October 22, 2025 12:00:00 AM
Creating Objects from Type Information
# Create object using Activator
$type = [System.Text.StringBuilder]
$instance = [System.Activator]::CreateInstance($type)
$instance.Append("Created via Activator")
# Create with constructor parameters
$listType = [System.Collections.Generic.List[int]]
$listWithCapacity = [System.Activator]::CreateInstance($listType, 100)
$listWithCapacity.Capacity
Output:
PS> $instance.ToString()
Created via Activator
PS> $listWithCapacity.Capacity
100
Working with Events
.NET objects expose events that you can subscribe to for reactive programming:
# Create a FileSystemWatcher
$watcher = New-Object System.IO.FileSystemWatcher
$watcher.Path = "C:\Temp"
$watcher.Filter = "*.txt"
$watcher.IncludeSubdirectories = $false
$watcher.EnableRaisingEvents = $true
# Define event handler
$onCreated = {
param($source, $e)
Write-Host "File Created: $($e.FullPath)" -ForegroundColor Green
}
$onChange = {
param($source, $e)
Write-Host "File Changed: $($e.FullPath)" -ForegroundColor Yellow
}
# Register events
Register-ObjectEvent -InputObject $watcher -EventName Created -Action $onCreated
Register-ObjectEvent -InputObject $watcher -EventName Changed -Action $onChange
# List registered events
Get-EventSubscriber
# Unregister events when done
# Unregister-Event -SourceIdentifier *
Timer Events
# Create a timer
$timer = New-Object System.Timers.Timer
$timer.Interval = 2000 # 2 seconds
# Register elapsed event
$action = {
$global:timerCount++
Write-Host "Timer elapsed $global:timerCount times at $(Get-Date -Format 'HH:mm:ss')"
}
$global:timerCount = 0
Register-ObjectEvent -InputObject $timer -EventName Elapsed -Action $action
# Start and stop timer
$timer.Start()
Start-Sleep -Seconds 7
$timer.Stop()
# Clean up
Unregister-Event -SourceIdentifier *
$timer.Dispose()
Practical Examples
HTTP Request with WebClient
# Using WebClient for HTTP operations
$webClient = New-Object System.Net.WebClient
# Set headers
$webClient.Headers.Add("User-Agent", "PowerShell Script")
# Download string
$html = $webClient.DownloadString("https://example.com")
# Download file
$webClient.DownloadFile(
"https://example.com/file.zip",
"C:\Downloads\file.zip"
)
# Upload data
$response = $webClient.UploadString(
"https://api.example.com/data",
"POST",
'{"key": "value"}'
)
$webClient.Dispose()
XML Processing
# Create XML document
$xml = New-Object System.Xml.XmlDocument
# Load from string
$xmlString = @"
<configuration>
<appSettings>
<add key="Environment" value="Production"/>
<add key="MaxConnections" value="100"/>
</appSettings>
</configuration>
"@
$xml.LoadXml($xmlString)
# Navigate and query
$xml.SelectSingleNode("//add[@key='Environment']").value
$xml.configuration.appSettings.add | Where-Object { $_.key -eq "MaxConnections" }
# Create new elements
$newSetting = $xml.CreateElement("add")
$newSetting.SetAttribute("key", "Timeout")
$newSetting.SetAttribute("value", "30")
$xml.configuration.appSettings.AppendChild($newSetting)
# Save to file
$xml.Save("C:\config.xml")
Output:
PS> $xml.SelectSingleNode("//add[@key='Environment']").value
Production
PS> $xml.configuration.appSettings.add | Where-Object { $_.key -eq "MaxConnections" }
key value
--- -----
MaxConnections 100
JSON Serialization
# Using System.Text.Json (modern approach)
Add-Type -AssemblyName System.Text.Json
$person = [PSCustomObject]@{
Name = "John Doe"
Age = 30
Skills = @("PowerShell", ".NET", "Azure")
Active = $true
}
# Serialize to JSON
$jsonString = [System.Text.Json.JsonSerializer]::Serialize($person)
Write-Output $jsonString
# Deserialize from JSON
$jsonData = '{"Name":"Jane Smith","Age":28,"Active":true}'
$options = New-Object System.Text.Json.JsonSerializerOptions
$options.PropertyNameCaseInsensitive = $true
$deserializedPerson = [System.Text.Json.JsonSerializer]::Deserialize(
$jsonData,
[PSCustomObject],
$options
)
Performance Considerations
StringBuilder vs String Concatenation
# Inefficient: String concatenation in loop
Measure-Command {
$result = ""
for ($i = 0; $i -lt 1000; $i++) {
$result += "Item $i`n"
}
}
# Efficient: Using StringBuilder
Measure-Command {
$sb = New-Object System.Text.StringBuilder
for ($i = 0; $i -lt 1000; $i++) {
$sb.AppendLine("Item $i") | Out-Null
}
$result = $sb.ToString()
}
Output:
String concatenation: ~450ms
StringBuilder: ~15ms
Performance improvement: 30x faster
Choosing the Right Collection Type
# ArrayList - Legacy, not type-safe
$arrayList = New-Object System.Collections.ArrayList
$arrayList.Add(1) # Returns index, requires Out-Null
# List[T] - Modern, type-safe, better performance
$list = [System.Collections.Generic.List[int]]::new()
$list.Add(1) # Returns void
# HashSet - Unique values, O(1) lookup
$hashSet = [System.Collections.Generic.HashSet[string]]::new()
$hashSet.Add("PowerShell")
$hashSet.Contains("PowerShell") # Very fast lookup
# ConcurrentDictionary - Thread-safe
$concurrent = [System.Collections.Concurrent.ConcurrentDictionary[string,int]]::new()
$concurrent.TryAdd("Key", 100)
Best Practices
Proper Resource Disposal
# Always dispose of IDisposable objects
$streamReader = $null
try {
$streamReader = New-Object System.IO.StreamReader("C:\file.txt")
$content = $streamReader.ReadToEnd()
}
finally {
if ($streamReader) {
$streamReader.Dispose()
}
}
# Or use try-finally pattern
$stream = [System.IO.File]::OpenRead("C:\file.txt")
try {
# Use stream
}
finally {
$stream.Dispose()
}
Type Checking and Validation
# Check if object is of specific type
$obj = "Hello"
$obj -is [string] # True
$obj -is [int] # False
# Type casting with validation
try {
$number = [int]"123" # Success
$invalid = [int]"abc" # Throws error
}
catch {
Write-Host "Invalid conversion: $_"
}
# Safe type conversion
$result = $null
if ([int]::TryParse("123", [ref]$result)) {
Write-Host "Parsed successfully: $result"
}
Assembly Loading Best Practices
# Check if assembly is already loaded
$assemblyName = "System.Windows.Forms"
$loaded = [System.AppDomain]::CurrentDomain.GetAssemblies() |
Where-Object { $_.GetName().Name -eq $assemblyName }
if (-not $loaded) {
Add-Type -AssemblyName $assemblyName
}
# Load with error handling
try {
Add-Type -Path "C:\CustomLib.dll" -ErrorAction Stop
Write-Host "Assembly loaded successfully"
}
catch {
Write-Host "Failed to load assembly: $_"
}
Troubleshooting Common Issues
Assembly Version Conflicts
# View loaded assembly versions
[System.AppDomain]::CurrentDomain.GetAssemblies() |
Where-Object { $_.GetName().Name -like "*System*" } |
Select-Object @{N="Name";E={$_.GetName().Name}},
@{N="Version";E={$_.GetName().Version}} |
Sort-Object Name
# Force specific version
[System.Reflection.Assembly]::Load(
"MyAssembly, Version=2.0.0.0, Culture=neutral, PublicKeyToken=null"
)
Type Resolution Issues
# Find type in loaded assemblies
function Find-Type {
param([string]$TypeName)
[System.AppDomain]::CurrentDomain.GetAssemblies() |
ForEach-Object {
try {
$_.GetTypes() | Where-Object { $_.Name -like "*$TypeName*" }
}
catch {}
}
}
Find-Type "StringBuilder"
Advanced Scenarios
Creating Custom Attributes
Add-Type -TypeDefinition @"
using System;
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Method)]
public class AuthorAttribute : Attribute
{
public string Name { get; set; }
public string Date { get; set; }
public AuthorAttribute(string name, string date)
{
Name = name;
Date = date;
}
}
[Author("John Doe", "2025-10-22")]
public class CustomClass
{
[Author("Jane Smith", "2025-10-20")]
public void CustomMethod()
{
Console.WriteLine("Method with custom attribute");
}
}
"@
# Read custom attributes
$type = [CustomClass]
$attributes = $type.GetCustomAttributes($true)
$attributes | ForEach-Object {
"$($_.Name) - $($_.Date)"
}
Implementing Interfaces
Add-Type -TypeDefinition @"
using System;
using System.Collections.Generic;
public class CustomComparer : IComparer<string>
{
public int Compare(string x, string y)
{
// Compare by length first, then alphabetically
int lengthComparison = x.Length.CompareTo(y.Length);
return lengthComparison != 0 ? lengthComparison : string.Compare(x, y);
}
}
"@
# Use custom comparer
$list = [System.Collections.Generic.List[string]]::new()
$list.AddRange(@("PowerShell", "C#", "Python", "JavaScript", "Go"))
$list.Sort([CustomComparer]::new())
$list
Output:
Go
C#
Python
PowerShell
JavaScript
PowerShell’s integration with .NET objects and assemblies provides limitless possibilities for automation and scripting. By understanding how to create objects, load assemblies, compile inline C# code, and leverage the full .NET Framework, you can build sophisticated solutions that rival traditional compiled applications. The key is to choose the right approach for your scenario, follow best practices for resource management, and understand the performance implications of your choices. Whether you’re building GUI applications, processing data, or integrating with external APIs, the .NET Framework through PowerShell gives you the tools to accomplish any task.
- Understanding .NET Objects in PowerShell
- Type Accelerators
- Loading and Using .NET Assemblies
- Inline C# Code with Add-Type
- Working with Generic Types
- Reflection and Dynamic Object Manipulation
- Working with Events
- Practical Examples
- Performance Considerations
- Best Practices
- Troubleshooting Common Issues
- Advanced Scenarios
