为何重载PowerShell类的get_/set_函数未达预期效果？

Great question—let's break down what's happening here, because it ties into how PowerShell and .NET handle properties under the hood.

First, let's confirm the behavior you observed: when you define a PowerShell class with a property, Get-Member -Force does show hidden get_Property and set_Property methods. Here's your example code for reference:

class myClass { [int]$Property }
[myClass]::new() | Get-Member -Force | Where-Object { $_.Name -like "*Property" }

Which outputs:

TypeName: myClass
Name        MemberType Definition
----        ---------- ----------
get_Property Method     int get_Property()
set_Property Method     void set_Property(int )
Property    Property   int Property {get;set;}

The Core Issue: .NET Property Access vs. Explicit Method Calls #

The key misunderstanding here is that those get_*/set_* methods are the .NET runtime's internal implementation of the property accessors—not the entry point PowerShell uses for property syntax ($obj.Property or $obj.Property = value).

When you use PowerShell's property syntax, it directly interacts with the .NET PropertyInfo object for that property, which invokes the built-in getter/setter logic. The get_Property/set_Property methods you see are just how the CLR exposes those accessors at the method level—they're not methods you can overload to change property behavior.

If you try to manually define a get_Property method in your class, you're just adding a regular named method, not replacing the property's actual accessor. PowerShell won't route property reads/writes to this custom method; you'd have to call it explicitly like $obj.get_Property() to run it.

The Correct Way to Customize Property Access #

If you want to add custom logic to property gets/sets in a PowerShell class, you need to use the property block syntax to define explicit get and set blocks, like this:

class myClass {
    # Hidden backing field to store the actual value
    hidden [int]$_propertyValue

    [int] Property {
        get {
            # Custom getter logic here
            Write-Host "Custom getter triggered for Property"
            return $this._propertyValue
        }
        set {
            # Custom setter logic here
            Write-Host "Custom setter triggered for Property with value: $value"
            $this._propertyValue = $value
        }
    }
}

Now, when you use property syntax, your custom logic runs automatically:

$obj = [myClass]::new()
$obj.Property = 42  # Triggers the custom setter
$val = $obj.Property  # Triggers the custom getter

Why This Differs from Operator Overloads (Like -eq/.Equals()) #

Your comparison to -eq calling .Equals() is a good one, but the difference is that operator overloads in .NET (and PowerShell) are explicitly mapped to method names (like op_Equality for -eq). Property access, however, is a separate .NET construct that uses PropertyInfo to route access, not direct method calls to get_*/set_*. Those methods are an implementation detail, not part of the public contract for property interaction.

内容的提问来源于stack exchange，提问作者syneticon-dj