metamorphism++

PS C:\> $PSVersionTable.PSVersion

Major  Minor  Patch  PreReleaseLabel BuildLabel
-----  -----  -----  --------------- ----------
7      1      0

Hi Guys !!

here an example to demonstrate the new feature

first create base class

PS C:\> class foo {
>>        $say = 'hello'
>>       [string] sayhello($name) {
>>          return '{0} {1}' -f $this.say, $name
>>        }
>> }

work well

PS C:\> [foo]::new().sayhello('world')
hello world

create a child class with the same method ‘sayhello’ to overid the base method class

PS C:\> class bar : foo {
>>         [string] sayhello($name) {
>>             return "power${name}"
>>         }
>>    }
PS C:\>

work well

PS C:\> [bar]::new().sayhello('shell')
powershell

but sometimes we need to append the result to method “sayhello” in base class and the method “sayhello” in our child class… like in ruby with “super” keyword

this example demonstate the behaviour missing in powershell. in this example i use “super” keyword

PS C:\> class bar : foo {
>>         super [string] sayhello($name) {
>>             return "power${name}"
>>         }
>>    }

PS C:\> [bar]::new().sayhello('shell')
hello shell
powershell

[SeeminglyScience]

the problem with your ideas

Just to be clear, the first example isn’t an idea, that’s how the PowerShell team decided to implement that functionality (side note: I can kinda see why. $base would have been a pain to implement with how the binder works, and since it probably doesn’t matter for DSC it likely wasn’t a big priority). Like that example currently works.

$base would have been nice, but implementing it today may not be feasible without breaking changes.

---

As for super, that’s sort of confusing with a return value. It always just adds them together? So if the method returns int, the parent returns 5 and the child returns 5 then the invocation returns 10?

[zett42]

Currently you can call a method of the base class like this, but it requires an ugly type cast (see about_Classes):

class bar : foo {
    [string] sayhello($name) {
        return ([foo] $this).sayhello($name) + "`npower${name}"
    }
}

Output:

hello shell
powershell

I would prefer to call the base class without having to repeat its name and without casting, similar to C#'s base keyword:

class bar : foo {
    [string] sayhello($name) {
        # Currently not possible!
        return $base.sayhello($name) + "`npower${name}"
    }
}