{"id":10055,"date":"2015-10-21T06:00:00","date_gmt":"2015-10-21T13:00:00","guid":{"rendered":"https:\/\/www.sapien.com\/blog\/?p=10055"},"modified":"2015-10-21T17:24:13","modified_gmt":"2015-10-22T00:24:13","slug":"why-do-we-need-constructors","status":"publish","type":"post","link":"https:\/\/dev.sapien.com\/blog\/2015\/10\/21\/why-do-we-need-constructors\/","title":{"rendered":"Why Do We Need Constructors?"},"content":{"rendered":"

While traveling after PowerShell Summit Europe in Stockholm, I was honored to be the guest of the Microsoft Technical User Group in Oslo, Norway (@MTUG_Norge<\/a>). This well-established user group meets on the beautiful campus of the University of Oslo, a short light-rail ride from downtown Oslo.<\/p>\n

We got together for a hands-on lab on classes in PowerShell 5.0. It was an experienced group — mainly IT operations folks — who are well-versed in PowerShell. The concepts are all new, but the group of 35-40 people were quick to understand them.<\/p>\n

One thoughtful guy asked a particularly good question: Why do we need constructors? As PowerShell scripters, we’re used to the New-Object<\/a> cmdlet and creating objects<\/a> with PSCustomObject, PSObject, and hash tables. Why do we need yet another concept in object creation?<\/p>\n

Why Constructors?<\/h1>\n

The short answer is that, unbeknownst to us, we’ve been using constructors all along. But, in its quest to make us successful, PowerShell has (mostly) hidden the concept from us.<\/p>\n

A constructor<\/i><\/b> is a special method of a class that initializes new objects or instances<\/i> of the class. Without a constructor, you can’t create instances of the class. Imagine that you could create a class that represents files, but without constructors, you couldn’t create any files based on the class.<\/p>\n

Some types of classes, including abstract classes<\/a> and interfaces<\/a>, don’t need constructors, because you don’t create instances of them. Instead, you use them as base classes and derive subclasses from them.<\/p>\n

(Cool digression: Abstract classes aren’t required to have constructors, but they can have them. You can call the constructor of an abstract class to create a new instance of a subclass<\/i><\/b> that’s based on (“derived from”) the abstract class. Thanks to Doug Finke<\/a> for his excellent tutelage.)<\/p>\n

(Fun fact: You can implement multiple interfaces, but you can derive a class from only one base class.)<\/p>\n

How do you use a constructor?<\/h1>\n

Even though constructors are methods, you don’t call them directly.<\/p>\n

Instead, constructors determine the parameter values or “arguments”<\/i><\/b> that you are required to provide to the New-Object<\/b> cmdlet or the New<\/b> static method.<\/p>\n

For example, let’s create a Tree class that has two properties, Species (a string) and Height (an integer).<\/p>\n

class Tree {\r\n    [String]$Species\r\n    [int32]$Height\r\n    \u2026\r\n}<\/pre>\n
The Tree class also has one constructor that takes one string value (for the species) and one integer value (for the height).<\/p>\n
# In Help: Constructor1: [String]$Species, [Int32]$Height<\/p>\n
When you create a tree, you must provide precisely one string and one integer in the specified order. (The order matters because you don’t type parameter names.)<\/p>\n
New-Object -TypeName Tree -ArgumentList 'Mimosa', 10<\/pre>\n
-or-<\/p>\n
[Tree]::New('Mimosa', 10)<\/pre>\n
This works:<\/p>\n
Species Height\r\n------- ------\r\nMimosa 10<\/pre>\n
If you try to create a Tree with missing, extra, or different objects, the command fails.<\/p>\n
PS C:\\> New-Object -TypeName Tree -ArgumentList 10\r\n\r\nNew-Object : Cannot find an overload for \"Tree\" and the argument count: \"1\".\r\nAt line:1 char:1\r\n+ New-Object -TypeName Tree -ArgumentList 10\r\n+ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\r\n+ CategoryInfo : InvalidOperation: (:) [New-Object], MethodException\r\n+ FullyQualifiedErrorId : ConstructorInvokedThrowException,Microsoft.PowerShell.Commands.NewObjectCommand<\/pre>\n
How do I write a constructor?<\/h1>\n
Constructors initialize<\/i> the new object, that is, they set the startup property values for the object. They might also do other things necessary to make the object usable.<\/p>\n
You can distinguish constructors from other methods of a class because constructors always have the same name as the class<\/b>. If the class is Tree, it’s constructors are all named Tree, too.<\/p>\n
A constructor<\/i> is a method, so it has a script block and (optional) parameters.<\/p>\n
Syntax:<\/p>\n
<ClassName> ( [<optional_parameters>] ) {\r\n    <statements and commands\u2026>\r\n}<\/pre>\n
For example, the Tree class has a constructor that takes a Species string. Like the class, the constructor is named Tree.<\/p>\n
Tree ( [string]$Species ) {\r\n    $this.Species = $Species\r\n}<\/pre>\n
You can have multiple constructors. But, because the parser looks only at parameter types, not names, the constructors must take different types.<\/p>\n
This constructor in the Tree class takes a string and an integer. It assigns the string to the Species property and the integer to the Height property.<\/p>\n
Tree ( [string]$Species, [int32]$Height ) {\r\n\r\n    $this.Species = $Species\r\n    $this.Height = $Height\r\n}<\/pre>\n
Here is the tree class with its Tree constructors.<\/p>\n
class Tree ()\r\n{\r\n\r\n    [String]$Species\r\n    [int32]$Height\r\n\r\n    # Here is a constructor. Notice the name.\r\n    Tree ( [string]$Species ) {\r\n        $this.Species = $Species\r\n    }\r\n\r\n    # Here is another constructor. It's also named Tree, but it takes different parameter types.\r\n    Tree ( [string]$Species, [int32]$Height ) {\r\n        $this.Species = $Species\r\n        $this.Height = $Height\r\n    } \r\n\r\n    # Here is a different method with a different name.\r\n    [int32] Grow ( [uint32]$Amount) )\r\n    {\r\n        $this.Height += $Amount\r\n        return $this.Height\r\n    }\r\n}<\/pre>\n
Constructors don’t return anything. A\u00a0return type is not permitted.<\/p>\n
To use the first constructor, I need to submit a string, such as ‘Mimosa’.<\/p>\n
New-Object -Typename Tree -ArgumentList 'Mimosa'<\/pre>\n
-or-<\/p>\n
[Tree]::New('Mimosa')<\/pre>\n
To use the second constructor, I submit a string and an integer, in that order.<\/p>\n
New-Object -Typename Tree -ArgumentList 'Mimosa, 10'<\/pre>\n
-or-<\/p>\n
[Tree]::New('Mimosa', 10)<\/pre>\n
How do I find the constructors of a class?<\/h1>\n
The simplest way to get the constructors in a class is to use the New<\/b> static property of all classes.<\/p>\n
The syntax is:<\/p>\n
[<ClassName>]::New<\/pre>\n
For example, to get the constructors in the Tree class:<\/p>\n
PS C:\\> [Tree]::New\r\n\r\nOverloadDefinitions\r\n-------------------\r\nTree new(string Species)\r\nTree new(string Species, int Height)<\/pre>\n
Must I write a constructor?<\/h3>\n
Surprisingly, the answer is no.<\/p>\n
When you create a class, Windows PowerShell creates a default constructor for you.\u00a0A default constructor<\/em>\u00a0has no parameters and takes no arguments or values.\u00a0You might\u00a0hear it\u00a0called a null constructor <\/em>or\u00a0parameter-less constructor<\/em>.<\/p>\n
For example, if I create a Tree class with nothing in it, I can create a Tree object.<\/p>\n
PS C:\\> class Tree {}\r\nPS C:\\> $myTree = New-Object -TypeName Tree\r\nPS C:\\> $myTree | Get-Member\r\n\r\n   TypeName: Tree\r\n\r\nName        MemberType Definition\r\n----        ---------- ----------\r\nEquals      Method     bool Equals(System.Object obj)\r\nGetHashCode Method     int GetHashCode()\r\nGetType     Method     type GetType()\r\nToString    Method     string ToString()<\/pre>\n
If you use the New static property of the Tree class, you can see the default constructor that Windows PowerShell created for you.<\/p>\n
PS C:\\> [Tree]::New\r\n\r\nOverloadDefinitions\r\n-------------------\r\nTree new()<\/pre>\n
However, if you add a constructor to the Tree class, the “free” default constructor disappears.<\/p>\n
PS C:> class Tree {\r\n>> Tree ([String]$Species) {}\r\n>> }\r\n>>\r\nPS C:\\> [Tree]::New\r\n\r\nOverloadDefinitions\r\n-------------------\r\nTree new(string Species)<\/pre>\n
If you want a default constructor in your class, you need to add it explicitly. (And, you should, because it allows people to use hash tables to create objects. I’ll explain in detail in a later blog post.)<\/p>\n
PS C:\\> class Tree {\r\n>>\r\n>> Tree () {}\r\n>> Tree ([String]$Species) {}\r\n>> }\r\n>>\r\nPS C:\\> [Tree]::New\r\n\r\nOverloadDefinitions\r\n-------------------\r\nTree new()\r\nTree new(string Species)<\/pre>\n
 <\/p>\n
Constructors are very new to Windows PowerShell users, but we’ve been using them whenever we use the New-Object cmdlet, and Windows PowerShell has been using them to create objects whenever we use a Get cmdlet. Now, in Windows PowerShell 5.0, we can create them, as well as use them.<\/p>\n
Thanks again to MTUG_Norge and its members for having me. I really enjoyed it.<\/p>\n
June Blender is a technology evangelist at SAPIEN Technologies, Inc and a Windows PowerShell MVP. You can reach her at <\/i>juneb@sapien.com<\/i><\/a>\u00a0and follow her on Twitter at <\/i>@juneb_get_help<\/i><\/a>.<\/i><\/p>\n","protected":false},"excerpt":{"rendered":"
While traveling after PowerShell Summit Europe in Stockholm, I was honored to be the guest of the Microsoft Technical User Group in Oslo, Norway (@MTUG_Norge). This well-established user group meets on the beautiful campus of the University of Oslo, a short light-rail ride from downtown Oslo. We got together for a hands-on lab on classes […]<\/p>\n","protected":false},"author":31,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"_monsterinsights_skip_tracking":false,"_monsterinsights_sitenote_active":false,"_monsterinsights_sitenote_note":"","_monsterinsights_sitenote_category":0,"footnotes":""},"categories":[1033,941,25],"tags":[612,934,961,524,997],"class_list":["post-10055","post","type-post","status-publish","format-standard","hentry","category-classes-in-powershell-5-0","category-powershell-5-0","category-windows-powershell","tag-classes","tag-juneb","tag-powershell-5-0","tag-user-groups","tag-windows-powershell"],"jetpack_featured_media_url":"","_links":{"self":[{"href":"https:\/\/dev.sapien.com\/blog\/wp-json\/wp\/v2\/posts\/10055","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/dev.sapien.com\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/dev.sapien.com\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/dev.sapien.com\/blog\/wp-json\/wp\/v2\/users\/31"}],"replies":[{"embeddable":true,"href":"https:\/\/dev.sapien.com\/blog\/wp-json\/wp\/v2\/comments?post=10055"}],"version-history":[{"count":24,"href":"https:\/\/dev.sapien.com\/blog\/wp-json\/wp\/v2\/posts\/10055\/revisions"}],"predecessor-version":[{"id":10147,"href":"https:\/\/dev.sapien.com\/blog\/wp-json\/wp\/v2\/posts\/10055\/revisions\/10147"}],"wp:attachment":[{"href":"https:\/\/dev.sapien.com\/blog\/wp-json\/wp\/v2\/media?parent=10055"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/dev.sapien.com\/blog\/wp-json\/wp\/v2\/categories?post=10055"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/dev.sapien.com\/blog\/wp-json\/wp\/v2\/tags?post=10055"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}