Learn PowerShell: Episode 5, Parameters + C# Descriptions + Overloads

Introduction

In this tutorial, we will explore the concepts of parameters, method descriptions, overloads, and the use of the Get-Member command in PowerShell. This guide is designed for those looking to deepen their understanding of PowerShell, particularly in relation to object methods and properties. By the end, you will be able to effectively use methods with parameters, understand method descriptions, and explore the members of objects.

Chapter 1: Calling with Parameters

Understanding Method Parameters

• Methods are functions associated with objects that can take parameters.
• Parameters allow you to pass information into methods.

Example: Using the MoveTo Method

1. Identify the File Object: Suppose you have a file named abc.txt.
2. Call the MoveTo Method:

   $file = Get-Item "abc.txt"
   $file.MoveTo("def.txt")
   

   • Parameter: The MoveTo method takes one string parameter, the new name for the file.
   • Error Handling: If you attempt to run MoveTo without providing a parameter, you will receive an error indicating that a suitable overload is not found.

Example: Using a Method with Two Parameters

1. Using the Replace Method on Strings:
   • This method can replace occurrences of a substring in a string.

   $string = "A,B"
   $result = $string.Replace(",", ".")
   

   • Parameters: The first parameter is the text to replace, and the second is the text to replace it with.

Tips for Using Parameters

• Always check how many parameters a method requires.
• Separate multiple parameters with a comma.
• Remember that the order of parameters matters.

Chapter 2: Formal Descriptions

Understanding Method Descriptions

• PowerShell methods can be described in a format similar to C#:
  • Return Type: Specifies what the method returns (e.g., void if nothing is returned).
  • Method Name: The name of the method.
  • Parameters: Listed within parentheses, with their types specified.

Example Descriptions

• A method like GetType:

  Type GetType()
  

  • Returns a Type object and has no parameters.

• A method with parameters:

  bool WaitForExit(int milliseconds)
  

  • Returns a bool and takes an integer parameter.

Importance of Understanding Descriptions

• Familiarity with this format helps in reading documentation and understanding method functionalities.

Chapter 3: Viewing Members

Using the Get-Member Command

• The Get-Member cmdlet is used to view the properties and methods of an object.

1. Example:

   Get-Process | Get-Member
   

   • This command lists all members of the first process object returned.

What You See in the Output

• MemberType: Indicates if it's a method or property.
• Definition: Shows the method signature, including its return type and parameters.

Practical Application

• Use Get-Member to explore unknown objects and discover available methods and properties.

Chapter 4: Overloads

Understanding Overloads

• Methods can have multiple versions (overloads) that differ in parameter count or type.
• Example: The MoveTo method can be called with one or two parameters, one for the new name and one for overwrite options.

How to View Overloads

• If you want to see all overloads of a method:
  • Type the method name without parentheses.

  $file.MoveTo
  

Chapter 5: How "Where" Works

Filtering Objects with Where

• Where is used to filter collections based on a condition.
• Example:

  Get-Process | Where { $_.ProcessName -eq "powershell" }
  

• This command checks each object and returns those that match the specified condition.

How Where Functions

• It evaluates the provided condition for each object.
• Returns objects where the condition evaluates to true.

Chapter 6: Experimenting with Types

Filtering Directories from Files

• Use the Get-ChildItem (alias ls) to list files and directories.
• To filter only directories, use:

  Get-ChildItem | Where { $_.GetType().FullName -eq "System.IO.DirectoryInfo" }
  

Conclusion

In this tutorial, we covered how to effectively work with methods, parameters, and overloads in PowerShell. We learned how to use the Get-Member cmdlet to explore object members and how to filter objects with the Where command. Experimenting with these concepts will enhance your PowerShell skills, allowing you to create more dynamic and efficient scripts. Continue practicing by exploring more methods and properties in PowerShell.