PowerShell Advanced

Begin the PowerShell advanced course with module one intro, outlining the module structure and the single lesson on Polish versions and history.

Explore PowerShell versions and history, comparing Windows PowerShell 5.1 with PowerShell 7, and explain the shift to .NET Core and cross‑platform support across Windows, Linux, and macOS.

Explore how dot net empowers PowerShell, review properties and methods, and learn about the dot net framework and assemblies' static properties through three labs and real-world examples.

Discover what the dot net platform is, including dot net framework and dot net core, their languages and libraries, including cross-platform capabilities, and how ready-made code speeds up PowerShell development.

Compare .NET framework and .NET core, highlighting the cross-platform power of .NET core and PowerShell 7. Note that .NET framework remains Windows-only with no new features.

PowerShell advanced explains using .NET objects via cmdlets, and building with .NET classes directly when needed, plus the differences between .NET framework and .NET core.

PowerShell advanced reviews objects, properties, and methods from a dotnet class blueprint, using cars as examples. Properties include color, make, engine type; methods include accelerate, brake, horn.

Explore how objects originate from classes, exposing properties and methods in PowerShell, using service objects with name and display name and actions like start and stop.

Demonstrates creating a .NET process object in PowerShell, inspecting its properties and methods, and using the kill method to terminate a running process while exploring type names.

Learn how to use .NET classes directly in PowerShell and load assemblies, create objects like service controller, and call overloaded methods with arguments and return values.

Demonstrates using the System.Speech.Synthesis.SpeechSynthesizer to load the assembly, create a speaker object, and call speak with a string, while highlighting overloads.

Explore namespaces, assemblies, and classes in dot net, learn how constructors create speech synthesizer objects, and review method and property concepts with practical demos.

Learn how to instantiate a .NET class from PowerShell by loading the assembly, using the service controller and service process types, and creating objects with specific constructors.

Explore static properties and methods in the System.Math class, learn how to access them without creating objects, and see a round method example in action.

Explore accessing static properties and methods of the System.Math class, using min, max, and round overloads, while understanding namespace usage and assembly loading in PowerShell advanced workflows.

Discover how to use the system.windows.forms open file dialog in PowerShell to provide a graphical file picker, with a starting folder and translated C# examples.

Demonstrates using system.windows.forms.openfiledialog in PowerShell to create an open file dialog, set assembly, initial directory, and filter, then show the dialog and handle OK or Cancel results.

PowerShell advanced module 2 labs intro guides you through three labs from easy to challenging, using basic scripting and research with a Sherlock Holmes mindset, and includes solution videos.

Create an array list using the array list class, and use add and remove methods to manage two strings, Jack and Jill, then display the list to verify changes.

Learn to create and manipulate array lists in PowerShell and C#, using System.Collections namespaces, with add, remove, and display list methods, and explore generic lists with strings.

PowerShell advanced 2 lab b shows you create a text file pick me.txt with two lines in folder C Fufu one, then use an open file dialog to display it.

Explore how to retrieve and display text from files in PowerShell by using Get-Content and a file dialog, including handling file names and paths in a practical lab solution.

Select multiple text files in a directory, read their contents, and produce a consolidated output in PowerShell. Use hints in the solution video if you get stuck.

Explore the module 2 lab c solution to enable multi select in the open file dialog, iterate over file names with for each, and read each file’s contents for display.

Explore the what and why of PowerShell functions, including input parameters, return values, variables, scope, and error handling, through five lessons and four challenging labs.

Explore what functions are in PowerShell, why to use them, and how to create and call simple functions that perform a single task for reusable, modular scripts.

Explore how functions form their own worlds in PowerShell advanced module 3, and how variables, parameters, and scope differ inside and outside a function.

Explore how PowerShell functions return values such as strings, booleans, and service objects, and how other functions perform actions without outputs; learn about parameters, types, and passing names and paths.

Learn to create PowerShell advanced functions that return a single string, define typed string parameters, and bind values to demonstrate output, variable use, and basic cmdlet examples like Get-Service.

Demonstrate PowerShell advanced techniques by building a non-outputting function and a cmdlet example, including a speech method and a string parameter to create reusable commands.

Explore how PowerShell handles variables, parameters, and functions, a tale of two variables, showing pass-by-value behavior, scope isolation, and how function parameters act as local variables in demos.

Learn to use try-catch blocks in PowerShell to catch errors, log them to a text file, and present meaningful messages to users, demonstrated with a practical example.

Master try catch finally in PowerShell to handle terminating errors, log errors, clean up resources. Use Get-Service and Get-LocalUser to simulate errors cannot be found and verify error handling.

PowerShell advanced module 3 recap demonstrates multiple demo functions, including parameterless functions, parameterized functions, and functions that return values, to reinforce understanding through repeatable examples.

Explore creating a function with no return value and no parameters in PowerShell advanced, using Get Speak and start my service as examples.

Create a PowerShell function with parameters using Param and string inputs, and ensure the function does not return a value while demonstrating a speech synthesis example.

Demonstrate building a PowerShell function that returns a boolean with no parameters, using try-catch to test a path and user existence, and capture output for a future parameterized version.

Discover how to create a PowerShell function that returns a value and accepts parameters, using a local variable and proper parameter binding to ensure clear, reusable commands.

Dive into module three labs, progressing from easy to hard to reinforce your PowerShell skills, exploring the birth and use of functions, with dotnet-based function creation.

Practice creating functions in PowerShell in module three lab a by building a hello world function with a name parameter, then extend it to include a last name parameter.

Explore building and calling PowerShell functions with parameters, returning values, and string concatenation, using a hello world example to demonstrate outputs and parameter usage.

learn to build a wrapper function based on this one to create a local user with a name and a string password, converting it to a secure string.

Develop a PowerShell function to create a local user with name and password parameters, convert the password to a secure string, and demonstrate parameter scope and admin privileges.

Module three lab functions guide you to create a folder Seapower Show and a file partial text, then use test path to verify the file exists, treating commands as functions.

PowerShell advanced module three lab c solution shows how to create a directory item, check path existence with test-path, and handle booleans.

In module lab d, students build a PowerShell command that tests a path and returns true or false, then use it in an if statement to check path existence.

PowerShell advanced module three lab d solution shows how to test a path with get-item using try/catch and return true or false based on file existence.

Create PowerShell advanced scripts to speak text with a speech synthesizer and to select files via Windows Forms open file dialog using a begin directory parameter.

Create a function using the system.speech.synthesis.speech synthesizer to speak a string, via the System.Speech assembly. Demonstrate an OpenFileDialog example in Windows Forms to get a filename.

Learn to create commands and manage modules in PowerShell, using custom objects and functions. Explore where to store modules and apply the final module through guided projects.

Explore what cmdlets are, how functions become reusable commands, and how to create shareable scripts so others can use your custom commands in any PowerShell session.

Learn a step-by-step approach to creating a PowerShell cmdlet, using a test local user function, exploring command options, and leveraging documentation and basic regular expressions.

this module 4 demo introduces a beginning function in Windows PowerShell 5.1, showing function definition, boolean values, try/catch blocks, and building a composite workflow.

In module 4 step 1, the demo shows creating a cmdlet by adding cmdlet binding to an existing function, enabling verbose, debug, and error action parameters.

In module 4 of PowerShell advanced, learn to create a cmdlet by adding parameters, marking them mandatory, and wiring a help message.

In module 4 step 3, we create a cmdlet and implement parameter binding, adding a verbose switch to reveal command activity during testing with a store.

Explore creating a cmdlet in PowerShell by adding parameter aliases to support multiple user-friendly names and reduce script errors through flexible value binding.

Explore how to create a PowerShell cmdlet that accepts pipeline input and multiple values, using string arrays and a foreach loop to process multiple users.

Create a PowerShell cmdlet that accepts multiple values as a string array, then iterate with foreach to check each user's existence and output true or false accordingly.

In module 4 step 6, learn to create a cmdlet that accepts multiple string values and pipeline input, bind input to a name parameter, and test with local user scenarios.

This module demonstrates creating a cmdlet using begin process, process block, and end block to handle pipeline input and process multiple values with foreach.

Create a sophisticated PowerShell cmdlet that binds pipeline input by property name, processes CSV-like data from an array, and maps the name property to its parameter for accurate data handling.

Learn to create a cmdlet by defining a function with a synopsis, parameters, and examples, and use Get-Help to view syntax, descriptions, and common base help.

Learn how to create PowerShell custom objects using legacy hash table approaches and the newer object construction method for PowerShell 3 and up, enabling multi-source property merges and reports.

Create powerful custom objects in PowerShell by defining properties with a hash table, constructing them with new-object, and iterating with for-each to emit objects into the pipeline.

In PowerShell advanced, create a demo cmdlet that tests existence, returns true or false, and builds and outputs custom objects with name, description, and enabled properties via a for-each pipeline.

Learn how to build a PowerShell cmdlet with binding and parameters, using Write-Verbose to show debugging messages and Write-Error for error handling.

Learn what a partial module is, why to create one, and how commands live in a module loaded into memory for everyone to use, plus default storage.

Watch a hands-on demo of creating and storing a PowerShell module, naming it correctly, saving it in the module folder, and validating dynamic loading in PowerShell 5.

Create and store a PowerShell module manifest, including author, description, and requirements, and learn how the root module and ps1/psm1 file locations affect loading.

Master the end project by building a PowerShell function that outputs each user's group memberships, including administrators and user groups, with CSV-driven testing via foreach.

Build and test a PowerShell advanced solution for local group membership, iterating groups, filtering by a user, and constructing output objects for pipeline delivery.

Test if a local user exists using try and catch, handle non-existent users, and emit clear error messages for robust PowerShell scripts.

Engage in a challenging PowerShell advanced bonus project that tests local user management: verify user existence, adjust user and administrators group memberships, and create users when needed.

Explore a PowerShell advanced bonus project possible solution that handles importing users, creates local users, uses try with error action stop for terminating errors, and manages local group memberships.

Congratulate learners, encourage practice and applying automation with PowerShell, turn observations into commands and functions, challenge yourself, aim to be the go-to person, and continue learning beyond this course.

Download the stable PowerShell 7.0 release from GitHub, install it, enable remoting, and launch PowerShell 7 alongside Windows PowerShell.

Explore running Windows PowerShell 5.1 and PowerShell 7 side by side on Windows, compare interoperability, module compatibility, and common commands like Get-Service and Stop-Service for cross-version workflows.

Install Visual Studio Code and the PowerShell extension to enable IntelliSense and code completion for PowerShell, with integration across Windows PowerShell 5.0 to 7.

Explore using Visual Studio Code to switch between PowerShell 7 and Windows PowerShell 5.1. Manage default and integrated terminals, test scripts, and understand when scripts run in each shell.