A cmdlet (pronounced as “command-let”) is a single-feature command that manipulates objects in PowerShell. You can recognize cmdlets by their name format which is verb and noun separated by a dash (-), such as Get-Help, Get-Process, and Start-Service.

In traditional shells, the commands are executable programs that range from the very simple (such as ren.exe) to the very complex (such as netsh.exe).

In PowerShell, most cmdlets are very simple, and they are designed to be used in combination with other cmdlets. For example, the “get” cmdlets only retrieve data, the “set” cmdlets only change data, the “format” cmdlets only format data, and the “out” cmdlets only direct the output to a specified destination.

get-help <cmdlet-name> -detailed

PS C:\Windows\system32> ipconfig

Windows IP Configuration

Ethernet adapter Ethernet:

   Connection-specific DNS Suffix  . :
   Link-local IPv6 Address . . . . . : fe80::6594:644d:560c:dbfb%15
   IPv4 Address. . . . . . . . . . . : 192.168.4.254
   Subnet Mask . . . . . . . . . . . : 255.255.255.0
   Default Gateway . . . . . . . . . : fe80::ed2:b5ff:fe1f:5174%15
                                       192.168.4.10

Tunnel adapter isatap.{962CC11B-3F41-40C1-8E02-F5CF5976F2D7}:

   Media State . . . . . . . . . . . : Media disconnected
   Connection-specific DNS Suffix  . :

PS C:\Windows\system32> net localgroup administrators
Alias name     administrators
Comment        Administrators have complete and unrestricted access to the computer/domain

Members

-------------------------------------------------------------------------------
techtutsonline\surender
localadmin
The command completed successfully.

You can even use PowerShell cmdlets, like Select-String, to manipulate the text that Windows programs return.

For example, the following command uses a pipeline operator to send the results of an ipconfig command to the PowerShell Select-String cmdlet, which searches for text in strings. In this case, you use Select-String to find the pattern “IPv4” in the ipconfig output.

PS C:\Windows\system32> ipconfig | select-string -pattern IPv4

   IPv4 Address. . . . . . . . . . . : 192.168.4.254

When a Windows command or tool has parameters, such as the “-r” (restart) parameter of shutdown command (shutdown -r), PowerShell passes the parameters to the tool without interpreting them.

However, if the tool uses a PowerShell reserved word, or uses a command format that is unknown to it, such as “-D:debug=false” parameter (PowerShell interprets this as two parameters, “-D” and “debug=false”), enclose the parameters in quotations marks to indicate to PowerShell that it should send the parameters to the tool without interpretation.

Processing Objects

Although you might not realize it at first, when you work in PowerShell, you are working with .NET Framework objects. As you gain experience, the power of object processing becomes more evident, and you’ll find yourself using the objects and even thinking in objects.

Technically, a .NET Framework object is an instance of a .NET Framework class that consists of data and the operations associated with that data. But you can think of an object as a data entity that has properties, which are like characteristics, and methods, which are actions that you can perform on the object.

For example, when you get a service in PowerShell, you are really getting an object that represents the service. When you view information about a service, you are viewing the properties of its service object. And, when you start a service, that is, when you change the Status property of the service to “Started,” you are using a method of the service object.

All objects of the same type have the same properties and methods, but each instance of an object can have different values for the properties. For example, every service object has a Name and Status property. However, each service can have a different name and a different status.

When you’re ready, it’s easy to learn about the objects. To find out what type of object a cmdlet is getting, use a pipeline operator (|) to send the results of a “get” command to the Get-Member cmdlet. For example, the following command sends the objects retrieved by a Get-Service command to Get-Member.

PS C:\Windows\system32> Get-Service | Get-Member

   TypeName: System.ServiceProcess.ServiceController

Name                      MemberType    Definition
----                      ----------    ----------
Name                      AliasProperty Name = ServiceName
RequiredServices          AliasProperty RequiredServices = ServicesDependedOn
Disposed                  Event         System.EventHandler Disposed(System.Object, System.EventArgs)
Close                     Method        void Close()
Continue                  Method        void Continue()
CreateObjRef              Method        System.Runtime.Remoting.ObjRef CreateObjRef(type requestedType)
Dispose                   Method        void Dispose(), void IDisposable.Dispose()
Equals                    Method        bool Equals(System.Object obj)
ExecuteCommand            Method        void ExecuteCommand(int command)
GetHashCode               Method        int GetHashCode()
GetLifetimeService        Method        System.Object GetLifetimeService()
GetType                   Method        type GetType()
InitializeLifetimeService Method        System.Object InitializeLifetimeService()
Pause                     Method        void Pause()
Refresh                   Method        void Refresh()
Start                     Method        void Start(), void Start(string[] args)
Stop                      Method        void Stop()

[output cut]

To find the values of all of the properties of a particular object, use a pipeline operator (|) to send the results of a “get” command to a Format-List or Format-Table cmdlet. Use the Property parameter of the format cmdlets with a value of all (*). For example, to find all of the properties of the Windows Update service on the system, type:

PS C:\Windows\system32> Get-Service wuauserv | Format-List -Property *

Name                : wuauserv
RequiredServices    : {rpcss}
CanPauseAndContinue : False
CanShutdown         : False
CanStop             : False
DisplayName         : Windows Update
DependentServices   : {}
MachineName         : .
ServiceName         : wuauserv
ServicesDependedOn  : {rpcss}
ServiceHandle       : SafeServiceHandle
Status              : Stopped
ServiceType         : Win32ShareProcess
Site                :
Container           :

Remember that PowerShell is not case sensitive. It means cmdlet “Get-Service” and “get-service” will return same result. But you will see PowerShell commands written in PascalCase in many blogs . This is because PowerShell uses TAB key for auto-completion and the TAB key automatically changes the first letter to uppercase. If you type “get-ser” and press TAB key, you will notice that the cmdlet name changes to “Get-Service”. The PascalCase also improves readability.

Object Pipelines

One major advantage of using objects is that it makes much easier to pipeline commands. Pipeline means to pass the output of one cmdlet to another cmdlet as input. In a traditional command-line environment, you would have to manipulate text to convert output from one format to another and to remove titles and column headings.

PowerShell provides a new architecture that is based on objects, rather than text. The cmdlet that receives an object can act directly on its properties and methods without any conversion or manipulation. Users can refer to properties and methods of the object by name, rather than calculating the position of the data in the output.

In the following example, the result of an ipconfig command is passed to a findstr command. The pipeline operator (|) sends the result of the command on its left to the command on its right. In PowerShell, you do not need to manipulate strings or calculate data offsets.

PS C:\Windows\system32> ipconfig | findstr "Address"
   Link-local IPv6 Address . . . . . : fe80::6594:644d:560c:dbfb%15
   IPv4 Address. . . . . . . . . . . : 192.168.4.254

PowerShell System Requirements

When PowerShell was initially started (with version 1.0), it was mainly designed to work with only local computer. The latter version (version 2.0 and above) included the PowerShell Remoting feature which allow the system administrators to run the commands on remote computers and servers.

In this section, I will look into the system requirements for Windows PowerShell 3.0 and Windows PowerShell 4.0, and for special features, such as Windows PowerShell Integrated Scripting Environment (ISE), CIM commands, and workflows.

Windows 8.1 and Windows Server 2012 R2 comes with Windows PowerShell installed by default.

Operating System Requirements

Windows PowerShell 4.0 runs on the following versions of Windows:

• Windows 8.1, installed by default
• Windows Server 2012 R2, installed by default
• Windows 7 with Service Pack 1, install Windows Management Framework 4.0 to run Windows PowerShell 4.0
• Windows Server 2008 R2 with Service Pack 1, install Windows Management Framework 4.0 to run Windows PowerShell 4.0.

Windows PowerShell 3.0 runs on the following versions of Windows:

• Windows 8, installed by default
• Windows Server 2012, installed by default
• Windows 7 with Service Pack 1, install Windows Management Framework 3.0 to run Windows PowerShell 3.0
• Windows Server 2008 R2 with Service Pack 1, install Windows Management Framework 3.0 to run Windows PowerShell 3.0
• Windows Server 2008 with Service Pack 2, install Windows Management Framework 3.0 to run Windows PowerShell 3.0.

Microsoft .NET Framework Requirements

Windows PowerShell 4.0 requires the full installation of Microsoft .NET Framework 4.5. Windows 8.1 and Windows Server 2012 R2 include Microsoft .NET Framework 4.5 by default.

Windows PowerShell 3.0 requires the full installation of Microsoft .NET Framework 4. Windows 8 and Windows Server 2012 include Microsoft .NET Framework 4.5 by default, which fulfills this requirement.

To install Microsoft .NET Framework 4.5  download the file dotNetFx45_Full_setup.exe from Microsoft Download Center.

WS-Management 3.0