Functions, Cmdlets, and Modules

In PowerShell, functions, cmdlets, and modules are essential building blocks for scripting and automation. They allow you to execute code, organize reusable logic, and extend PowerShell's capabilities. Let’s break down each of these concepts in detail.

---

1. Functions

What is a Function?

A function is a block of PowerShell code that has been given a name. It can accept input (parameters) and return output. Functions are like mini-scripts that you can reuse throughout your session or scripts.

For example, you might create a function to calculate disk usage or to format output in a specific way.

Key Features of Functions

• Reusability: Write once, use many times.

• Parameters: Functions can accept input via parameters.

• Pipeline Support: Functions can be designed to work in pipelines, processing input from the previous command.

Listing Functions

To see all the functions available in your current session, use:

Get-ChildItem Function:\

This will list all functions, including built-in ones like help, more, and even C: (which is a function that runs Set-Location C:).

Viewing Function Code

To see the code inside a function, use:

Get-Content Function:\mkdir

This will display the code for the mkdir function, which is essentially a wrapper for New-Item.

Creating Your Own Functions

You can create your own functions using the function keyword. For example:

function Get-DiskUsage {
    Get-Volume | Select-Object DriveLetter, SizeRemaining, Size
}

Now, you can call Get-DiskUsage to retrieve disk usage information.

---

2. Cmdlets

What is a Cmdlet?

A cmdlet (pronounced "command-let") is a lightweight command used in PowerShell. Cmdlets are typically written in .NET and compiled into DLLs. They perform specific tasks and are the backbone of PowerShell's functionality.

Examples of cmdlets include:

• Get-Process: Retrieves information about running processes.

• Set-Location: Changes the current directory.

• Get-ChildItem: Lists files and folders.

Key Features of Cmdlets

• Verb-Noun Naming: Cmdlets follow a consistent naming pattern, such as Get-Process or Set-Location.

• Pipeline Support: Cmdlets can accept input from and send output to other cmdlets via the pipeline.

• Compiled Code: Cmdlets are compiled into DLLs, making them faster and more efficient than scripts.

Using Cmdlets

Cmdlets are used just like any other command. For example:

Get-Process -Name "notepad"

This retrieves information about all Notepad processes.

---

3. Modules

What is a Module?

A module is a package that contains cmdlets, functions, variables, aliases, and other resources. Modules are used to organize and distribute PowerShell code.

For example, the ActiveDirectory module provides cmdlets for managing Active Directory, while the SQLServer module provides cmdlets for working with SQL Server.

Key Features of Modules

• Organization: Modules group related functionality together.

• Reusability: Modules can be shared and reused across scripts and systems.

• Versioning: Modules can have version numbers and dependencies.

Module Structure

A module typically consists of:

• A .psm1 file: A PowerShell script that defines the module's functionality.

• A .psd1 file: A manifest file that describes the module (optional).

• DLLs: Compiled cmdlets (optional).

Module Paths

PowerShell looks for modules in specific directories, which are stored in the $env:PSModulePath environment variable. You can view these paths using:

$env:PSModulePath -Split ";"

This will show the directories where PowerShell searches for modules.

Using Modules

To use a module, you must first import it. For example:

Import-Module ActiveDirectory

This loads the ActiveDirectory module, making its cmdlets available for use.

Listing Modules

To see which modules are currently loaded, use:

Get-Module

To see all available modules (loaded or not), use:

Get-Module -ListAvailable

Automatic Module Loading

In PowerShell 3.0 and later, modules are automatically loaded when you use one of their cmdlets. For example, if you run Get-ADUser, PowerShell will automatically load the ActiveDirectory module if it isn’t already loaded.

---

4. Dot-Sourcing (Deprecated Technique)

What is Dot-Sourcing?

Dot-sourcing is an older technique for loading functions into PowerShell. It involves running a script in the current scope, which makes its functions and variables available in the session.

For example:

. C:\Scripts\MyFunctions.ps1

This loads the functions defined in MyFunctions.ps1 into the current session.

Why is Dot-Sourcing Deprecated?

While dot-sourcing still works, it’s considered outdated because:

• Modules provide a more organized and scalable way to manage functions.

• Dot-sourced functions are only available in the current session, whereas modules can be imported automatically.

Overlapping Names

If two dot-sourced scripts contain functions with the same name, the last one loaded will overwrite the earlier one. PowerShell follows a specific search order when resolving command names:

1. Aliases

2. Functions

3. Cmdlets

4. Native executables (e.g., ping.exe)

For example, if you have an alias, function, cmdlet, and executable all named Ping, PowerShell will use the alias first, then the function, then the cmdlet, and finally the executable